From c4774b47d326e4114f96232f1389a555639d7348 Mon Sep 17 00:00:00 2001 From: rossberg-chromium Date: Thu, 1 Jun 2017 11:58:07 +0200 Subject: [PATCH] [spec/interpreter] Specify text format and adapt interpreter (#471) This change specifies the text format, based on earlier discussion between @binji, @lukewagner, @sunfishcode, and myself. It also adapts the interpreter to the changes listed below. The changes relative to the .wast format previously implemented in the interpreter and other tools are the following. Removals: - some of the more baroque forms of sugar for `if` - binary module bodies - anything script related (assertions, invokes, etc) - `infinity` as a secondary spelling for float `inf` Additions: - \u{...} escapes in strings (see below) - more than just one inline export (that is, you can write (func $f (export "f1") (export "f2") ...), closing a gap in the syntax), and it combines with import - the toplevel (module ...) is optional Changes: One breaking change makes the syntax forward compatible with some of the future extensions that have been discussed: - non-empty block signatures must now be written (result i32), in order to generalise cleanly to function signatures Unicode: - the lexical syntax is defined in terms of Unicode characters (i.e., code points) - comments and strings may contain mostly arbitrary Unicode, the rest stays within ASCII - in strings, a Unicode character denotes its UTF-8 encoding - in strings, Unicode characters can be given explicitly with \u{...} notation - .wat files are assumed to be encoded in UTF-8 Misc Remarks: - formatting characters: currently only the minimum set of formatting characters are allowed as white space (\t, \n, \r); we could include more, e.g. the whole set of ASCII "format effectors" (\b, \v, \f), but you quickly get into a lot of Unicode complexity if you want to go further than that - Unicode in comments: similarly, in order to avoid getting into Unicode specifics, any legal code point is currently allowed in comments; should we be more restrictive? - binary module bodies: they would seem pretty unusual for a "text" format, so are not included for now. - abbreviations: to avoid combinatorial complexity in defining the AST to map on, most syntactic sugar is specified in the form of "abbreviations", simple rewritings into the core syntax - inline function signatures: I tried to come up with a decent way to describe their rewriting into type indices (and the potential insertion of new type definitions) in terms of rules, but ultimately gave up; it's too cumbersome to express succinctly; so this is the one part that is left partially informal (though hopefully still unambiguous) - formatting: many of the rules do not currently fit the page width; I left them as is for now, and plan to clean up layout issues once the spec is complete, probably tweaking some layout parameters as well - tests: lots of stuff we could write tests for, e.g. regarding the Unicode support... --- document/.gitignore | 1 + document/appendix-textual/index.rst | 8 - document/binary/conventions.rst | 4 +- document/binary/instructions.rst | 34 +- document/binary/modules.rst | 28 +- document/binary/types.rst | 16 +- document/binary/values.rst | 37 +- document/execution/instructions.rst | 4 +- document/execution/runtime.rst | 2 +- document/index.rst | 2 +- document/math.def | 180 ++- document/syntax/conventions.rst | 9 + document/syntax/instructions.rst | 19 +- document/syntax/modules.rst | 1 + document/syntax/values.rst | 26 +- document/text/conventions.rst | 140 +++ document/text/index.rst | 14 + document/text/instructions.rst | 504 +++++++++ document/text/lexical.rst | 111 ++ document/text/modules.rst | 598 ++++++++++ document/text/types.rst | 143 +++ document/text/values.rst | 259 +++++ document/validation/conventions.rst | 2 +- document/validation/modules.rst | 1 + interpreter/Makefile | 33 +- interpreter/README.md | 53 +- interpreter/host/import.ml | 4 +- interpreter/host/js.ml | 21 +- interpreter/host/run.ml | 66 +- interpreter/spec/ast.ml | 14 + interpreter/spec/float.ml | 1 - interpreter/text/arrange.ml | 21 +- interpreter/text/lexer.mll | 86 +- interpreter/text/parse.ml | 4 +- interpreter/text/parse.mli | 2 +- interpreter/text/parser.mly | 349 +++--- interpreter/util/lib.ml | 2 +- test/core/block.wast | 114 +- test/core/br.wast | 149 ++- test/core/br_if.wast | 76 +- test/core/br_table.wast | 178 +-- test/core/call.wast | 47 +- test/core/call_indirect.wast | 62 +- test/core/comments.wast | Bin 652 -> 701 bytes test/core/conversions.wast | 60 +- test/core/exports.wast | 2 + test/core/f32.wast | 1068 +++++++++--------- test/core/f32_bitwise.wast | 144 +-- test/core/f32_cmp.wast | 912 +++++++-------- test/core/f64.wast | 1068 +++++++++--------- test/core/f64_bitwise.wast | 144 +-- test/core/f64_cmp.wast | 912 +++++++-------- test/core/fac.wast | 28 +- test/core/float_exprs.wast | 194 ++-- test/core/float_literals.wast | 12 +- test/core/float_misc.wast | 30 +- test/core/forward.wast | 12 +- test/core/func.wast | 10 +- test/core/if.wast | 88 +- test/core/imports.wast | 6 + test/core/inline-module.wast | 1 + test/core/labels.wast | 73 +- test/core/left-to-right.wast | 6 +- test/core/loop.wast | 108 +- test/core/memory.wast | 10 +- test/core/nop.wast | 40 +- test/core/return.wast | 30 +- test/core/stack.wast | 4 +- test/core/switch.wast | 10 +- test/core/token-keyword-separation.fail.wast | 1 + test/core/token-number-separation.fail.wast | 1 + test/core/typecheck.wast | 24 +- test/core/unreachable.wast | 46 +- test/core/unreached-invalid.wast | 52 +- test/core/unwind.wast | 54 +- 75 files changed, 5443 insertions(+), 3132 deletions(-) delete mode 100644 document/appendix-textual/index.rst create mode 100644 document/text/conventions.rst create mode 100644 document/text/index.rst create mode 100644 document/text/instructions.rst create mode 100644 document/text/lexical.rst create mode 100644 document/text/modules.rst create mode 100644 document/text/types.rst create mode 100644 document/text/values.rst create mode 100644 test/core/inline-module.wast create mode 100644 test/core/token-keyword-separation.fail.wast create mode 100644 test/core/token-number-separation.fail.wast diff --git a/document/.gitignore b/document/.gitignore index 09f98591a9..b932ec283e 100644 --- a/document/.gitignore +++ b/document/.gitignore @@ -1,2 +1,3 @@ _build _static +document/*.pyc diff --git a/document/appendix-textual/index.rst b/document/appendix-textual/index.rst deleted file mode 100644 index e7ea647eb8..0000000000 --- a/document/appendix-textual/index.rst +++ /dev/null @@ -1,8 +0,0 @@ -.. text-format: - -Appendix: Text Format ---------------------- - -.. todo:: - - Describe diff --git a/document/binary/conventions.rst b/document/binary/conventions.rst index c48bc84843..32f9512063 100644 --- a/document/binary/conventions.rst +++ b/document/binary/conventions.rst @@ -44,10 +44,10 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac * :math:`B^n` is a sequence of :math:`n\geq 0` iterations of :math:`B`. * :math:`B^\ast` is a possibly empty sequence of iterations of :math:`B`. - (This is a shorthand for :math:`A^n` used where :math:`n` is not relevant.) + (This is a shorthand for :math:`B^n` used where :math:`n` is not relevant.) * :math:`B^?` is an optional occurrence of :math:`B`. - (This is a shorthand for :math:`A^n` where :math:`n \leq 1`.) + (This is a shorthand for :math:`B^n` where :math:`n \leq 1`.) * :math:`x{:}B` denotes the same language as the nonterminal :math:`B`, but also binds the variable :math:`x` to the attribute synthesized for :math:`B`. diff --git a/document/binary/instructions.rst b/document/binary/instructions.rst index fb64b6634c..a1e0fd3280 100644 --- a/document/binary/instructions.rst +++ b/document/binary/instructions.rst @@ -16,24 +16,23 @@ The only exception are :ref:`structured control instructions ` have varying encodings. For structured instructions, the nested instruction sequences are terminated with explicit opcodes for |END| and |ELSE|. -.. _valid-nop: -.. _valid-unreachable: -.. _valid-block: -.. _valid-loop: -.. _valid-if: -.. _valid-br: -.. _valid-br_if: -.. _valid-br_table: -.. _valid-return: -.. _valid-call: -.. _valid-call_indirect: +.. _binary-nop: +.. _binary-unreachable: +.. _binary-block: +.. _binary-loop: +.. _binary-if: +.. _binary-br: +.. _binary-br_if: +.. _binary-br_table: +.. _binary-return: +.. _binary-call: +.. _binary-call_indirect: .. math:: \begin{array}{llclll} @@ -51,8 +50,8 @@ Control Instructions &\Rightarrow& \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END \\ &&|& \hex{0C}~~l{:}\Blabelidx &\Rightarrow& \BR~l \\ &&|& \hex{0D}~~l{:}\Blabelidx &\Rightarrow& \BRIF~l \\ &&|& - \hex{0E}~~l^\ast{:}\Bvec(\Blabelidx)~~l_N{:}\Blabelidx &\Rightarrow& - \BRTABLE~l^\ast~l_N \\ &&|& + \hex{0E}~~l^\ast{:}\Bvec(\Blabelidx)~~l_N{:}\Blabelidx + &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|& \hex{0F} &\Rightarrow& \RETURN \\ &&|& \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|& \hex{11}~~x{:}\Btypeidx &\Rightarrow& \CALLINDIRECT~x \\ @@ -65,7 +64,6 @@ Control Instructions .. _binary-instr-parametric: .. index:: value type, polymorphism pair: binary format; instruction - single: abstract syntax; instruction Parametric Instructions ~~~~~~~~~~~~~~~~~~~~~~~ @@ -86,7 +84,6 @@ Parametric Instructions .. _binary-instr-variable: .. index:: variable instructions, local index, global index pair: binary format; instruction - single: abstract syntax; instruction Variable Instructions ~~~~~~~~~~~~~~~~~~~~~ @@ -113,8 +110,7 @@ Variable Instructions .. _binary-instr-memory: .. _binary-memarg: .. index:: memory instruction, memory index - pair: validation; instruction - single: abstract syntax; instruction + pair: binary format; instruction Memory Instructions ~~~~~~~~~~~~~~~~~~~ @@ -168,7 +164,6 @@ Each variant of :ref:`memory instruction ` is encoded with .. _binary-instr-numeric: .. index:: numeric instruction pair: binary format; instruction - single: abstract syntax; instruction Numeric Instructions ~~~~~~~~~~~~~~~~~~~~ @@ -370,7 +365,6 @@ All other numeric instructions are plain opcodes without any immediates. .. _binary-expr: .. index:: expression pair: binary format; expression - single: abstract syntax; expression single: expression; constant Expressions diff --git a/document/binary/modules.rst b/document/binary/modules.rst index bd20c8be73..ebcfcbf2d7 100644 --- a/document/binary/modules.rst +++ b/document/binary/modules.rst @@ -17,7 +17,7 @@ except that :ref:`function definitions ` are split into two section .. _binary-globalidx: .. _binary-localidx: .. _binary-labelidx: -.. index:: index, index space, type index, function index, table index, memory index, global index, local index, label index +.. index:: index, type index, function index, table index, memory index, global index, local index, label index pair: binary format; type index pair: binary format; function index pair: binary format; table index @@ -25,13 +25,6 @@ except that :ref:`function definitions ` are split into two section pair: binary format; global index pair: binary format; local index pair: binary format; label index - single: abstract syntax; type index - single: abstract syntax; function index - single: abstract syntax; table index - single: abstract syntax; memory index - single: abstract syntax; global index - single: abstract syntax; local index - single: abstract syntax; label index Indices ~~~~~~~ @@ -112,7 +105,6 @@ Their contents consist of a :ref:`name ` further identifying the cu .. _binary-type: .. index:: ! type section, type definition pair: binary format; type section - single: abstract syntax; type definition pair: section; type Type Section @@ -132,7 +124,6 @@ It decodes into a vector of :ref:`function types ` that represe .. _binary-import: .. index:: ! import section, import, name, function type, table type, memory type, global type pair: binary format; import - single: abstract syntax; import pair: section; import Import Section @@ -160,7 +151,6 @@ It decodes into a vector of :ref:`imports ` that represent the |I .. _binary-func: .. index:: ! function section, function, type index, function type pair: binary format; function - single: abstract syntax; function pair: section; function Function Section @@ -181,7 +171,6 @@ The |LOCALS| and |BODY| fields of the respective functions are encoded separatel .. _binary-table: .. index:: ! table section, table, table type pair: binary format; table - single: abstract syntax; table pair: section; table Table Section @@ -203,7 +192,6 @@ It decodes into a vector of :ref:`tables ` that represent the |TAB .. _binary-mem: .. index:: ! memory section, memory, memory type pair: binary format; memory - single: abstract syntax; memory pair: section; memory Memory Section @@ -225,7 +213,6 @@ It decodes into a vector of :ref:`memories ` that represent the |MEM .. _binary-global: .. index:: ! global section, global, global type, expression pair: binary format; global - single: abstract syntax; global pair: section; global Global Section @@ -248,7 +235,6 @@ It decodes into a vector of :ref:`globals ` that represent the |G .. _binary-export: .. index:: ! export section, export, name, index, function index, table index, memory index, global index pair: binary format; export - single: abstract syntax; export pair: section; export Export Section @@ -276,7 +262,6 @@ It decodes into a vector of :ref:`exports ` that represent the |E .. _binary-start: .. index:: ! start section, start function, function index pair: binary format; start function - single: abstract syntax; start function single: section; start single: start function; section @@ -299,7 +284,6 @@ It decodes into an optional :ref:`start function ` that represents .. _binary-elem: .. index:: ! element section, element, table index, expression, function index pair: binary format; element - single: abstract syntax; element pair: section; element single: table; element single: element; segment @@ -324,7 +308,7 @@ It decodes into a vector of :ref:`element segments ` that represent .. _binary-local: .. index:: ! code section, function, local, type index, function type pair: binary format; function - single: abstract syntax; function + pair: binary format; local pair: section; code Code Section @@ -360,14 +344,14 @@ denoting *count* locals of the same value type. &\Rightarrow& \X{code} & (\X{size} = ||\Bfunc||) \\ \production{function} & \Bfunc &::=& (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr - &\Rightarrow& \F{concat}((t^\ast)^\ast), e^\ast - & (|\F{concat}((t^\ast)^\ast)| < 2^{32}) \\ + &\Rightarrow& \concat((t^\ast)^\ast), e^\ast + & (|\concat((t^\ast)^\ast)| < 2^{32}) \\ \production{locals} & \Blocals &::=& n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\ \end{array} Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`. -The meta function :math:`\F{concat}((t^\ast)^\ast)` denotes the sequence of types formed by concatenating all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`. +The meta function :math:`\F{concat}((t^\ast)^\ast)` concatenates all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`. Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector ` is malformed. .. note:: @@ -379,7 +363,6 @@ Any code for which the length of the resulting sequence is out of bounds of the .. _binary-data: .. index:: ! data section, data, memory, memory index, expression, byte pair: binary format; data - single: abstract syntax; data pair: section; data single: memory; data single: data; segment @@ -405,7 +388,6 @@ It decodes into a vector of :ref:`data segments ` that represent th .. _binary-version: .. index:: module, section, type definition, function type, function, table, memory, global, element, data, start function, import, export, context, version pair: binary format; module - single: abstract syntax; module Modules ~~~~~~~ diff --git a/document/binary/types.rst b/document/binary/types.rst index fde083402b..e4b646ef55 100644 --- a/document/binary/types.rst +++ b/document/binary/types.rst @@ -1,7 +1,6 @@ .. _binary-type: .. index:: type pair: binary format; type - single: abstract syntax; type Types ----- @@ -9,7 +8,6 @@ Types .. _binary-valtype: .. index:: value type pair: binary format; value type - single: abstract syntax; value type Value Types ~~~~~~~~~~~ @@ -34,7 +32,6 @@ Value Types .. _binary-blocktype: .. index:: result type, value type pair: binary format; result type - single: abstract syntax; result type Result Types ~~~~~~~~~~~~ @@ -55,7 +52,6 @@ The only :ref:`result types ` occurring in the binary format .. _binary-functype: .. index:: function type, value type, result type pair: binary format; function type - single: abstract syntax; function type Function Types ~~~~~~~~~~~~~~ @@ -73,7 +69,6 @@ Function Types .. _binary-limits: .. index:: limits pair: binary format; limits - single: abstract syntax; limits Limits ~~~~~~ @@ -90,8 +85,7 @@ Limits .. _binary-memtype: .. index:: memory type, limits, page size - single: binary format; memory type - pair: abstract syntax; memory type + pair: binary format; memory type Memory Types ~~~~~~~~~~~~ @@ -105,13 +99,11 @@ Memory Types \end{array} -.. _syntax-tabletype: -.. _syntax-elemtype: +.. _binary-tabletype: +.. _binary-elemtype: .. index:: table type, element type, limits pair: binary format; table type pair: binary format; element type - single: abstract syntax; table type - single: abstract syntax; element type Table Types ~~~~~~~~~~~ @@ -131,8 +123,6 @@ Table Types .. index:: global type, mutability, value type pair: binary format; global type pair: binary format; mutability - single: abstract syntax; global type - single: abstract syntax; mutability Global Types ~~~~~~~~~~~~ diff --git a/document/binary/values.rst b/document/binary/values.rst index 8a4366501c..9f530c0e3f 100644 --- a/document/binary/values.rst +++ b/document/binary/values.rst @@ -1,7 +1,6 @@ .. _binary-value: .. index:: value - binary: binary format; value - single: abstract syntax; value + pair: binary format; value Values ------ @@ -9,13 +8,12 @@ Values .. _binary-byte: .. index:: byte - pair: binary encoding; byte - single: abstract syntax; byte + pair: binary format; byte Bytes ~~~~~ -:ref:`Bytes ` encode themselves. +:ref:`Bytes ` encode themselves. .. math:: \begin{array}{llcll@{\qquad}l} @@ -29,15 +27,11 @@ Bytes .. _binary-int: .. _binary-sint: .. _binary-uint: -.. index:: integer, unsigned integer, signed integer, uninterpreted integer +.. index:: integer, unsigned integer, signed integer, uninterpreted integer, LEB128 pair: binary format; integer pair: binary format; unsigned integer pair: binary format; signed integer pair: binary format; uninterpreted integer - single: abstract syntax; integer - single: abstract syntax; unsigned integer - single: abstract syntax; signed integer - single: abstract syntax; uninterpreted integer Integers ~~~~~~~~ @@ -45,22 +39,22 @@ Integers All :ref:`integers ` are encoded using the `LEB128 `_ variable-length integer encoding, in either unsigned or signed variant. :ref:`Unsigned integers ` are encoded in `unsigned LEB128 `_ format. -As an additional constraint, the total number of bytes encoding a value of type :math:`\uX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes. +As an additional constraint, the total number of bytes encoding a value of type :math:`\uN` must not exceed :math:`\F{ceil}(N/7)` bytes. .. math:: \begin{array}{llclll@{\qquad}l} - \production{unsigned integer} & \BuX{N} &::=& + \production{unsigned integer} & \BuN &::=& n{:}\Bbyte &\Rightarrow& n & (n < 2^7 \wedge n < 2^N) \\ &&|& n{:}\Bbyte~~m{:}\BuX{(N\B{-7})} &\Rightarrow& 2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\ \end{array} :ref:`Signed integers ` are encoded in `signed LEB128 `_ format, which uses a 2's complement representation. -As an additional constraint, the total number of bytes encoding a value of type :math:`\sX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes. +As an additional constraint, the total number of bytes encoding a value of type :math:`\sN` must not exceed :math:`\F{ceil}(N/7)` bytes. .. math:: \begin{array}{llclll@{\qquad}l} - \production{signed integer} & \BsX{N} &::=& + \production{signed integer} & \BsN &::=& n{:}\Bbyte &\Rightarrow& n & (n < 2^6 \wedge n < 2^{N-1}) \\ &&|& n{:}\Bbyte &\Rightarrow& n-2^7 & (2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|& n{:}\Bbyte~~m{:}\BsX{(N\B{-7})} &\Rightarrow& @@ -71,8 +65,8 @@ As an additional constraint, the total number of bytes encoding a value of type .. math:: \begin{array}{llclll@{\qquad\qquad}l} - \production{uninterpreted integer} & \BiX{N} &::=& - n{:}\BsX{N} &\Rightarrow& i & (n = \signed_{\iX{N}}(i)) + \production{uninterpreted integer} & \BiN &::=& + n{:}\BsN &\Rightarrow& i & (n = \signed_{\iN}(i)) \end{array} .. note:: @@ -90,16 +84,15 @@ As an additional constraint, the total number of bytes encoding a value of type .. _binary-float: .. index:: floating-point number pair: binary format; floating-point number - single: abstract syntax; floating-point number Floating-Point ~~~~~~~~~~~~~~ -:ref:`Floating point ` values are encoded directly by their IEEE bit pattern in `little endian `_ byte order: +:ref:`Floating point ` values are encoded directly by their `IEEE 754 `_ bit pattern in `little endian `_ byte order: .. math:: \begin{array}{llclll@{\qquad\qquad}l} - \production{floating-point number} & \BfX{N} &::=& + \production{floating-point number} & \BfN &::=& b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \F{reverse}(b^\ast) \\ \end{array} @@ -109,7 +102,6 @@ Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in re .. _binary-vec: .. index:: vector pair: binary format; vector - single: abstract syntax; vector Vectors ~~~~~~~ @@ -124,14 +116,13 @@ Vectors .. _binary-name: -.. index:: name, byte +.. index:: name, byte, Unicode, UTF-8 pair: binary format; name - single: abstract syntax; name Names ~~~~~ -:ref:`Names ` are encoded like a :ref:`vector ` of bytes containing the `UTF-8 `_ encoding of the name's code point sequence. +:ref:`Names ` are encoded like a :ref:`vector ` of bytes containing the `Unicode `_ UTF-8 encoding of the name's code point sequence. .. math:: \begin{array}{llclll@{\qquad}l} diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst index ceb257a935..fc977d44ea 100644 --- a/document/execution/instructions.rst +++ b/document/execution/instructions.rst @@ -918,7 +918,7 @@ Entering :math:`\instr^\ast` with label :math:`L` 1. Push :math:`L` to the stack. -2. :ref:`Jump ` to the start of the instruction sequence :math:`\instr^\ast`. +2. Jump to the start of the instruction sequence :math:`\instr^\ast`. .. note:: No formal reduction rule is needed for entering an instruction sequence, @@ -973,7 +973,7 @@ Invocation of :ref:`function address ` :math:`a` 1. Assert: due to :ref:`validation `, :math:`S.\FUNCS[a]` exists. -2. Let :math:`f` be the :ref:`function instance `, :math:`S.\FUNCS[a]`. +2. Let :math:`f` be the :ref:`function instance `, :math:`S.\FUNCS[a]`. 3. Assert: due to :ref:`validation `, :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]` exists. diff --git a/document/execution/runtime.rst b/document/execution/runtime.rst index 028865b42b..a7e6ead042 100644 --- a/document/execution/runtime.rst +++ b/document/execution/runtime.rst @@ -407,7 +407,7 @@ and a reference to the function's own :ref:`module instance ` \{ \LOCALS~\val^\ast, \MODULE~\moduleinst\} \\ \end{array} -The values of the locals are mutated by respective :ref:`variable instructions `. +The values of the locals are mutated by respective :ref:`variable instructions `. Conventions diff --git a/document/index.rst b/document/index.rst index 417975647c..6b29eefc1f 100644 --- a/document/index.rst +++ b/document/index.rst @@ -13,9 +13,9 @@ WebAssembly Specification validation/index execution/index binary/index + text/index appendix-properties/index appendix-algorithm/index - appendix-textual/index appendix-names/index .. only:: latex diff --git a/document/math.def b/document/math.def index 6d970bc711..bbde450aca 100644 --- a/document/math.def +++ b/document/math.def @@ -10,17 +10,55 @@ .. F - functions .. K - keywords / terminals .. B - binary grammar non-terminals +.. T - textual grammar non-terminals .. |X| mathdef:: \mathit .. |F| mathdef:: \mathrm .. |K| mathdef:: \mathsf .. |B| mathdef:: \mathtt +.. |T| mathdef:: \mathtt .. Auxiliary definitions for grammars .. |production| mathdef:: \void -.. |with| mathdef:: ~\xref{syntax/conventions}{syntax-record}{\mbox{with}}~ +.. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}} +.. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}} +.. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus} +.. |bigcompose| mathdef:: \xref{syntax/conventions}{syntax-record}{\bigoplus} + + +.. Lexical grammar, terminals + +.. |textl| mathdef:: \mbox{‘} +.. |textr| mathdef:: \mbox{’} +.. |text#1| mathdef:: \textl\mathtt{#1}\textr + +.. |Tcommentl| mathdef:: \text{{(}{;}} +.. |Tcommentr| mathdef:: \text{{;}{)}} +.. |Tcommentd| mathdef:: \text{{;}{;}} + + +.. Lexical grammar, non-terminals + +.. |Tchar| mathdef:: \xref{text/lexical}{text-char}{\T{char}} +.. |Tspace| mathdef:: \xref{text/lexical}{text-space}{\T{space}} +.. |Tformat| mathdef:: \xref{text/lexical}{text-format}{\T{format}} + +.. |Ttoken| mathdef:: \xref{text/lexical}{text-token}{\T{token}} +.. |Tkeyword| mathdef:: \xref{text/lexical}{text-keyword}{\T{keyword}} +.. |Treserved| mathdef:: \xref{text/lexical}{text-reserved}{\T{reserved}} + +.. |Tcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{comment}} +.. |Tlinecomment| mathdef:: \xref{text/lexical}{text-comment}{\T{linecomment}} +.. |Tblockcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{blockcomment}} +.. |Tlinechar| mathdef:: \xref{text/lexical}{text-comment}{\T{linechar}} +.. |Tblockchar| mathdef:: \xref{text/lexical}{text-comment}{\T{blockchar}} + + +.. Lexical grammar, meta functions + +.. |utf8| mathdef:: \xref{syntax/values}{syntax-utf8}{\F{utf8}} .. Values, terminals @@ -99,6 +137,57 @@ .. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}} +.. Values, textual non-terminals + +.. |Tbyte| mathdef:: \xref{text/values}{text-byte}{\T{byte}} + +.. |Tsign| mathdef:: \xref{text/values}{text-sign}{\T{sign}} +.. |Tdigit| mathdef:: \xref{text/values}{text-digit}{\T{digit}} +.. |Thexdigit| mathdef:: \xref{text/values}{text-hexdigit}{\T{hexdigit}} +.. |Tnum| mathdef:: \xref{text/values}{text-num}{\T{num}} +.. |Thexnum| mathdef:: \xref{text/values}{text-hexnum}{\T{hexnum}} +.. |Tfrac| mathdef:: \xref{text/values}{text-frac}{\T{frac}} +.. |Thexfrac| mathdef:: \xref{text/values}{text-hexfrac}{\T{hexfrac}} +.. |Tfloat| mathdef:: \xref{text/values}{text-float}{\T{float}} +.. |Thexfloat| mathdef:: \xref{text/values}{text-hexfloat}{\T{hexfloat}} + +.. |TuX#1| mathdef:: {\T{u}#1} +.. |TsX#1| mathdef:: {\T{s}#1} +.. |TiX#1| mathdef:: {\T{i}#1} +.. |TfX#1| mathdef:: {\T{f}#1} + +.. |TuN| mathdef:: \xref{text/values}{text-int}{\TuX{N}} +.. |Tu1| mathdef:: \xref{text/values}{text-int}{\TuX{\T{1}}} +.. |Tu8| mathdef:: \xref{text/values}{text-int}{\TuX{\T{8}}} +.. |Tu16| mathdef:: \xref{text/values}{text-int}{\TuX{\T{16}}} +.. |Tu32| mathdef:: \xref{text/values}{text-int}{\TuX{\T{32}}} +.. |Tu64| mathdef:: \xref{text/values}{text-int}{\TuX{\T{64}}} + +.. |TsN| mathdef:: \xref{text/values}{text-int}{\TsX{N}} +.. |Ts32| mathdef:: \xref{text/values}{text-int}{\TsX{\T{32}}} +.. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}} + +.. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}} +.. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}} +.. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}} + +.. |TfN| mathdef:: \xref{text/values}{text-float}{\TfX{N}} +.. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}} +.. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}} + +.. |Tvec| mathdef:: \xref{text/values}{text-vec}{\T{vec}} +.. |Tstring| mathdef:: \xref{text/values}{text-string}{\T{string}} +.. |Tstringelem| mathdef:: \xref{text/values}{text-string}{\T{stringelem}} +.. |Tstringchar| mathdef:: \xref{text/values}{text-string}{\T{stringchar}} +.. |Tname| mathdef:: \xref{text/values}{text-name}{\T{name}} +.. |Tcodepoint| mathdef:: \xref{text/values}{text-name}{\T{codepoint}} +.. |Tcodeval| mathdef:: \xref{text/values}{text-name}{\T{codeval}} +.. |Tcodecont| mathdef:: \xref{text/values}{text-name}{\T{cont}} + +.. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}} +.. |Tidchar| mathdef:: \xref{text/values}{text-id}{\T{idchar}} + + .. Types, terminals .. |I8| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i8}} @@ -110,7 +199,7 @@ .. |ANYFUNC| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{anyfunc}} .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}} -.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}} +.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}} .. |MIN| mathdef:: \K{min} .. |MAX| mathdef:: \K{max} @@ -143,6 +232,22 @@ .. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}} +.. Types, textual non-terminals + +.. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}} +.. |Tresulttype| mathdef:: \xref{text/types}{text-resulttype}{\T{resulttype}} +.. |Tblocktype| mathdef:: \xref{text/types}{text-blocktype}{\T{blocktype}} +.. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}} +.. |Tglobaltype| mathdef:: \xref{text/types}{text-globaltype}{\T{globaltype}} +.. |Ttabletype| mathdef:: \xref{text/types}{text-tabletype}{\T{tabletype}} +.. |Telemtype| mathdef:: \xref{text/types}{text-elemtype}{\T{elemtype}} +.. |Tmemtype| mathdef:: \xref{text/types}{text-memtype}{\T{memtype}} +.. |Texterntype| mathdef:: \xref{text/types}{text-externtype}{\T{externtype}} +.. |Tlimits| mathdef:: \xref{text/types}{text-limits}{\T{limits}} +.. |Tparam| mathdef:: \xref{text/types}{text-functype}{\T{param}} +.. |Tresult| mathdef:: \xref{text/types}{text-functype}{\T{result}} + + .. Indices .. |typeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\X{typeidx}} @@ -161,6 +266,22 @@ .. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}} .. |Blabelidx| mathdef:: \xref{binary/modules}{binary-labelidx}{\B{labelidx}} +.. |Ttypeidx| mathdef:: \xref{text/modules}{text-typeidx}{\T{typeidx}} +.. |Tfuncidx| mathdef:: \xref{text/modules}{text-funcidx}{\T{funcidx}} +.. |Ttableidx| mathdef:: \xref{text/modules}{text-tableidx}{\T{tableidx}} +.. |Tmemidx| mathdef:: \xref{text/modules}{text-memidx}{\T{memidx}} +.. |Tglobalidx| mathdef:: \xref{text/modules}{text-globalidx}{\T{globalidx}} +.. |Tlocalidx| mathdef:: \xref{text/modules}{text-localidx}{\T{localidx}} +.. |Tlabelidx| mathdef:: \xref{text/modules}{text-labelidx}{\T{labelidx}} + +.. |Ttypebind| mathdef:: \xref{text/modules}{text-typebind}{\T{typebind}} +.. |Tfuncbind| mathdef:: \xref{text/modules}{text-funcbind}{\T{funcbind}} +.. |Ttablebind| mathdef:: \xref{text/modules}{text-tablebind}{\T{tablebind}} +.. |Tmembind| mathdef:: \xref{text/modules}{text-membind}{\T{membind}} +.. |Tglobalbind| mathdef:: \xref{text/modules}{text-globalbind}{\T{globalbind}} +.. |Tlocalbind| mathdef:: \xref{text/modules}{text-localbind}{\T{localbind}} +.. |Tlabelbind| mathdef:: \xref{text/modules}{text-labelbind}{\T{labelbind}} + .. Modules, terminals @@ -250,6 +371,30 @@ .. |Bstart| mathdef:: \xref{binary/modules}{binary-start}{\B{start}} +.. Modules, textual non-terminals + +.. |Tmodule| mathdef:: \xref{text/modules}{text-module}{\T{module}} +.. |Tmodulebody| mathdef:: \xref{text/modules}{text-modulebody}{\T{modulebody}} +.. |Tmodulefield| mathdef:: \xref{text/modules}{text-modulefield}{\T{modulefield}} +.. |Ttype| mathdef:: \xref{text/modules}{text-type}{\T{type}} +.. |Ttypeuse| mathdef:: \xref{text/modules}{text-typeuse}{\T{typeuse}} +.. |Tfunc| mathdef:: \xref{text/modules}{text-func}{\T{func}} +.. |Ttable| mathdef:: \xref{text/modules}{text-table}{\T{table}} +.. |Tmem| mathdef:: \xref{text/modules}{text-mem}{\T{mem}} +.. |Tglobal| mathdef:: \xref{text/modules}{text-global}{\T{global}} +.. |Timport| mathdef:: \xref{text/modules}{text-import}{\T{import}} +.. |Texport| mathdef:: \xref{text/modules}{text-export}{\T{export}} +.. |Timportdesc| mathdef:: \xref{text/modules}{text-importdesc}{\T{importdesc}} +.. |Texportdesc| mathdef:: \xref{text/modules}{text-exportdesc}{\T{exportdesc}} +.. |Telem| mathdef:: \xref{text/modules}{text-elem}{\T{elem}} +.. |Tcode| mathdef:: \xref{text/modules}{text-code}{\T{code}} +.. |Tlocal| mathdef:: \xref{text/modules}{text-local}{\T{local}} +.. |Tlocals| mathdef:: \xref{text/modules}{text-local}{\T{locals}} +.. |Tdata| mathdef:: \xref{text/modules}{text-data}{\T{data}} +.. |Tdatastring| mathdef:: \xref{text/modules}{text-datastring}{\T{datastring}} +.. |Tstart| mathdef:: \xref{text/modules}{text-start}{\T{start}} + + .. Modules, meta functions .. |funcs| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{funcs}} @@ -377,6 +522,31 @@ .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}} +.. Instructions, textual non-terminals + +.. |Tmemarg| mathdef:: \xref{text/instructions}{text-memarg}{\T{memarg}} +.. |Talign| mathdef:: \xref{text/instructions}{text-memarg}{\T{align}} +.. |Toffset| mathdef:: \xref{text/instructions}{text-memarg}{\T{offset}} + +.. |Tlabel| mathdef:: \xref{text/instructions}{text-label}{\T{label}} +.. |Tinstr| mathdef:: \xref{text/instructions}{text-instr}{\T{instr}} +.. |Tplaininstr| mathdef:: \xref{text/instructions}{text-plaininstr}{\T{plaininstr}} +.. |Tblockinstr| mathdef:: \xref{text/instructions}{text-blockinstr}{\T{blockinstr}} +.. |Tfoldedinstr| mathdef:: \xref{text/instructions}{text-foldedinstr}{\T{foldedinstr}} +.. |Texpr| mathdef:: \xref{text/instructions}{text-expr}{\T{expr}} + + +.. Context, textual + +.. |TYPEDEFS| mathdef:: \K{typedefs} + + +.. Contexts, meta functions + +.. |idfresh| mathdef:: ~\xref{text/values}{text-id-fresh}{\mbox{fresh}} +.. |idcwellformed| mathdef:: ~\xref{text/conventions}{text-context-wf}{\mbox{well-formed}} + + .. Runtime, terminals .. |MUT| mathdef:: \K{mut} @@ -422,3 +592,9 @@ .. |signed| mathdef:: \xref{execution/numerics}{aux-signed}{\F{signed}} .. |extend| mathdef:: \xref{execution/numerics}{aux-extend}{\F{extend}} .. |wrap| mathdef:: \xref{execution/numerics}{aux-wrap}{\F{wrap}} + +.. todo... + +.. |ieee| mathdef:: \F{ieee} +.. |ieeeinf| mathdef:: \F{ieeeinf} +.. |ieeenan| mathdef:: \F{ieeenan} diff --git a/document/syntax/conventions.rst b/document/syntax/conventions.rst index 3f0c82b3be..f35dc11d47 100644 --- a/document/syntax/conventions.rst +++ b/document/syntax/conventions.rst @@ -58,6 +58,8 @@ When dealing with syntactic constructs the following notation is also used: * :math:`s \with [i:n] = A^n` denotes the same sequence as :math:`s`, except that the sub-sequence :math:`s[i:n]` is replaced with :math:`A^n`. +* :math:`\concat(s^\ast)` denotes the flat sequence formed by concatenating all sequences :math:`s_i^\ast` in :math:`s^\ast`. + Moreover, the following conventions are employed: * The notation :math:`x^n`, where :math:`x` is a non-terminal symbol, is treated as a meta variable ranging over respective sequences of :math:`x` (similarly for :math:`x^\ast`, :math:`x^+`, :math:`x^?`). @@ -79,6 +81,13 @@ The following notation is adopted for manipulating such records: * :math:`r \with \K{field} = A` denotes the same record as :math:`r`, except that the value of the :math:`\K{field}` component is replaced with :math:`A`. +* :math:`r_1 \compose r_2` denotes the composition of two records with the same fields of sequences by appending each sequence pointwise: + + .. math:: + \{ \K{field}_1\,A_1^\ast, \K{field}_2\,A_2^\ast, \dots \} \compose \{ \K{field}_1\,B_1^\ast, \K{field}_2\,B_2^\ast, \dots \} = \{ \K{field}_1\,A_1^\ast~B_1^\ast, \K{field}_2\,A_2^\ast~B_2^\ast, \dots \} + +* :math:`\bigcompose r^\ast` denotes the composition of a sequence of records, respectively; if the sequence is empty, then all fields of the resulting record are empty. + The update notation for sequences and records generalizes recursively to nested components accessed by "paths" :math:`\X{pth} ::= ([\dots] \;| \;.\K{field})^+`: * :math:`s \with [i]\,\X{pth} = A` is short for :math:`s \with [i] = (s[i] \with \X{pth} = A)`. diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst index 07bf174d83..afd5f694f8 100644 --- a/document/syntax/instructions.rst +++ b/document/syntax/instructions.rst @@ -221,7 +221,7 @@ The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument. Memory Instructions ~~~~~~~~~~~~~~~~~~~ -Instructions in this group are concerned with :ref:`linear memory `. +Instructions in this group are concerned with :ref:`linear memory `. .. math:: \begin{array}{llll} @@ -264,11 +264,20 @@ Both instructions operate in units of :ref:`page size `. all memory instructions implicitly operate on :ref:`memory ` :ref:`index ` :math:`0`. This restriction may be lifted in future versions. -The precise semantics of memory instructions is :ref:`described ` in the :ref:`Instruction ` section. - .. _syntax-instr-control: -.. _syntax-isntr-seq: +.. _syntax-instr-seq: +.. _syntax-nop: +.. _syntax-unreachable: +.. _syntax-block: +.. _syntax-loop: +.. _syntax-if: +.. _syntax-br: +.. _syntax-br_if: +.. _syntax-br_table: +.. _syntax-return: +.. _syntax-call: +.. _syntax-call_indirect: .. _syntax-label: .. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector pair: abstract syntax; instruction @@ -333,7 +342,7 @@ However, forward branches that target a control instruction with a non-empty res The |CALL| instruction invokes another function, consuming the necessary arguments from the stack and returning the result values of the call. The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table `. Since tables may contain function elements of heterogeneous type |ANYFUNC|, -the callee is dynamically checked against the :ref:`function type ` indexed by the instruction's immediate, and the call aborted with a :ref:`trap ` if it does not match. +the callee is dynamically checked against the :ref:`function type ` indexed by the instruction's immediate, and the call aborted with a :ref:`trap ` if it does not match. .. note:: In the current version of WebAssembly, diff --git a/document/syntax/modules.rst b/document/syntax/modules.rst index d879612f92..ed3905910a 100644 --- a/document/syntax/modules.rst +++ b/document/syntax/modules.rst @@ -106,6 +106,7 @@ They are referenced by :ref:`type indices `. .. _syntax-local: .. index:: ! function, ! local, function index, local index, type index, value type, expression, import pair: abstract syntax; function + pair: abstract syntax; local Functions ~~~~~~~~~ diff --git a/document/syntax/values.rst b/document/syntax/values.rst index faa1aa2017..89ecfe8d54 100644 --- a/document/syntax/values.rst +++ b/document/syntax/values.rst @@ -60,7 +60,7 @@ Different classes of *integers* with different value ranges are distinguished by The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context. In the abstract syntax, they are represented as unsigned. -However, some operations :ref:`convert ` them to signed based on a 2's complement interpretation. +However, some operations :ref:`convert ` them to signed based on a 2's complement interpretation. Conventions @@ -109,7 +109,8 @@ A vector can have at most :math:`2^{32}-1` elements. .. _syntax-name: -.. index:: ! name, byte +.. _syntax-utf8: +.. index:: ! name, byte, Unicode, UTF-8, code point pair: abstract syntax; name Names @@ -118,19 +119,26 @@ Names *Names* are sequences of *scalar* `Unicode `_ *code points*. .. math:: - \begin{array}{llll} + \begin{array}{llclll} \production{name} & \name &::=& - \codepoint^\ast \\ + \codepoint^\ast & (|\utf8(\codepoint^\ast)| < 2^{32}) \\ \production{code point} & \codepoint &::=& \unicode{0000} ~|~ \dots ~|~ \unicode{D7FF} ~|~ \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\ \end{array} -.. todo:: - The definition of a name as an arbitrary sequence of scalar code points is too general. - So would be the definition of a vector. - Only names whose UTF-8 encoding is within the bounds of the maximum vector lengths must be included. - How specify this? +Due to the limitations of the :ref:`binary format `, +the lengths of a name is bounded by the length of its `UTF-8 `_ encoding. +The auxiliary |utf8| function expressing this encoding is defined as follows: + +.. math:: + \begin{array}{lcl@{\qquad}l} + \utf8(c^\ast) &=& (\utf8(c))^\ast \\[1ex] + \utf8(c) &=& b & (c < \unicode{80} \wedge c = b) \\ + \utf8(c) &=& b_1~b_2 & (\unicode{80} \leq c < \unicode{800} \wedge c = 2^6\cdot(b_1-\hex{C0})+(b_2-\hex{80})) \\ + \utf8(c) &=& b_1~b_2~b_3 & (\unicode{800} \leq c < \unicode{10000} \wedge c = 2^{12}\cdot(b_1-\hex{C0})+2^6\cdot(b_2-\hex{80})+(b_3-\hex{80})) \\ + \utf8(c) &=& b_1~b_2~b_3~b_4 & (\unicode{10000} \leq c < \unicode{110000} \wedge c = 2^{18}\cdot(b_1-\hex{C0})+2^{12}\cdot(b_2-\hex{80})+2^6\cdot(b_3-\hex{80})+(b_4-\hex{80})) \\ + \end{array} Convention diff --git a/document/text/conventions.rst b/document/text/conventions.rst new file mode 100644 index 0000000000..94b2ebd9ac --- /dev/null +++ b/document/text/conventions.rst @@ -0,0 +1,140 @@ +.. index:: ! text format, Unicode, UTF-8, S-expression + +Conventions +----------- + +The textual format for WebAssembly :ref:`modules ` is a rendering of their :ref:`abstract syntax ` into *S-expressions*. + +Like the :ref:`binary format `, the text format is defined by an *attribute grammar*. +A text string is a well-formed description of a module if and only if it is generated by the grammar. + +Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses. +Thus, the attribute grammar implicitly defines a *parsing* function. +Some productions also take a :ref:`context ` as an inherited attribute +that records bound :ref:`identifers `. + +Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax. +However, it also defines a number of *abbreviations* that are *syntactic sugar* over the core syntax. + +The recommended extension for source files containing WebAssembly modules in text format is ":math:`\T{.wat}`". +Files with this extension are assumed to be encoded in `Unicode UTF-8 `_. + + +.. _text-grammar: +.. index:: grammar notation, notation, Unicode + single: text format; grammar + pair: text format; notation + +Grammar +~~~~~~~ + +The following conventions are adopted in defining grammar rules for the text format. +They mirror the conventions used for :ref:`abstract syntax ` and for the :ref:`binary format `. +In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, typewriter font is adopted for the former. + +* Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`; + or expressed as `Unicode `_ code points: :math:`\unicode{0A}`. + (All characters written literally are unambiguously drawn from the `7-bit ASCII `_ subset of Unicode.) + +* Nonterminal symbols are written in typewriter font: :math:`\T{valtype}, \T{instr}`. + +* Arbitrary :ref:`white space ` is allowed in any place where the grammar contains spaces, except where noted otherwise, such as the :ref:`lexical syntax `. + +* :math:`T^n` is a sequence of :math:`n\geq 0` iterations of :math:`T`. + +* :math:`T^\ast` is a possibly empty sequence of iterations of :math:`T`. + (This is a shorthand for :math:`T^n` used where :math:`n` is not relevant.) + +* :math:`T^+` is a sequence of one or more iterations of :math:`T`. + (This is a shorthand for :math:`T^n` where :math:`n \geq 1`.) + +* :math:`T^?` is an optional occurrence of :math:`T`. + (This is a shorthand for :math:`T^n` where :math:`n \leq 1`.) + +* :math:`x{:}T` denotes the same language as the nonterminal :math:`T`, but also binds the variable :math:`x` to the attribute synthesized for :math:`T`. + +* Productions are written :math:`\T{name} ::= T \Rightarrow A`, where :math:`A` is the attribute that is synthesized for :math:`\T{name}`, usually from attribute variables bound in :math:`T`. + +* Some productions are augmented by side conditions in parentheses, which restrict the applicability of the production. They provide a shorthand for a combinatorial expansion of the production into many separate cases. + +.. note:: + For example, the :ref:`textual grammar ` for :ref:`value types ` is given as follows: + + .. math:: + \begin{array}{llcll@{\qquad\qquad}l} + \production{value types} & \Tvaltype &::=& + \text{i32} &\Rightarrow& \I32 \\ &&|& + \text{i64} &\Rightarrow& \I64 \\ &&|& + \text{f32} &\Rightarrow& \F32 \\ &&|& + \text{f64} &\Rightarrow& \F64 \\ + \end{array} + + The :ref:`textual grammar ` for :ref:`limits ` is defined as follows: + + .. math:: + \begin{array}{llclll} + \production{limits} & \Tlimits &::=& + n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|& + n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\ + \end{array} + + The variables :math:`n` and :math:`m` name the attributes of the respective |Tu32| nonterminals, which in this case are the actual :ref:`unsigned integers ` they decode into. + The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values. + + +.. _text-abbreviations: +.. index:: ! abbreviations + +Abbreviations +~~~~~~~~~~~~~ + +In addition to the core grammar, which corresponds directly to the :ref:`abstract syntax `, the textual syntax also defines a number of *abbreviations* that can be used for convenience and readability. + +Abbreviations are defined by rewrite rules specifying their expansion into the core syntax: + +.. math:: + \X{abbreviation~syntax} \quad\equiv\quad \X{expanded~syntax} + +These expansions are assumed to be applied, recursively and in order of appearance, before applying the core grammar rules to construct the abstract syntax. + + +.. _text-context: +.. _text-context-wf: +.. index:: ! identifier context, identifier, index, index space + +Contexts +~~~~~~~~ + +The text format allows to use symbolic :ref:`identifiers ` in place of :ref:`indices `. +To resolve these identifiers into concrete indices, +some grammar production are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space `. +In addition, the context records the types defined in the module, so that :ref:`parameter ` indices can be computed for :ref:`functions `. + +It is convenient to define identifier contexts as :ref:`records ` :math:`I` with abstract syntax: + +.. math:: + \begin{array}{llll} + \production{(identifier context)} & I &::=& + \begin{array}[t]{l@{~}ll} + \{ & \TYPES & (\Tid^?)^\ast, \\ + & \FUNCS & (\Tid^?)^\ast, \\ + & \TABLES & (\Tid^?)^\ast, \\ + & \MEMS & (\Tid^?)^\ast, \\ + & \GLOBALS & (\Tid^?)^\ast, \\ + & \LOCALS & (\Tid^?)^\ast, \\ + & \LABELS & (\Tid^?)^\ast, \\ + & \TYPEDEFS & \functype^\ast ~\} \\ + \end{array} + \end{array} + +For each index space, such a context contains the list of :ref:`identifiers ` assigned to the defined indices. +Unnamed indices are associated with empty (:math:`\epsilon`) entries in these lists. + +An identifier context is *well-formed* if no index space contains duplicate identifiers. + + +Conventions +........... + +To avoid unnecessary clutter, empty components are omitted when writing out identifier contexts. +For example, the record :math:`\{\}` is shorthand for an :ref:`identifier context ` whose components are all empty. diff --git a/document/text/index.rst b/document/text/index.rst new file mode 100644 index 0000000000..89889e5cfb --- /dev/null +++ b/document/text/index.rst @@ -0,0 +1,14 @@ +.. _text-format: + +Text Format +=========== + +.. toctree:: + :maxdepth: 2 + + conventions + lexical + values + types + instructions + modules diff --git a/document/text/instructions.rst b/document/text/instructions.rst new file mode 100644 index 0000000000..ea2e70620c --- /dev/null +++ b/document/text/instructions.rst @@ -0,0 +1,504 @@ +.. _text-instr: +.. index:: instruction + +Instructions +------------ + +Instructions are syntactically distinguished into *plain* and *structured* instructions. + +.. math:: + \begin{array}{llclll} + \production{instruction} & \Tinstr_I &::=& + \X{in}{:}\Tplaininstr_I + &\Rightarrow& \X{in} \\ &&|& + \X{in}{:}\Tblockinstr_I + &\Rightarrow& \X{in} \\ + \end{array} + +In addition, as a syntactic abbreviation, instructions can be written in :ref:`folded ` form as S-expressions, to group them visually. + + +.. _text-index: +.. _text-typeidx: +.. _text-funcidx: +.. _text-tableidx: +.. _text-memidx: +.. _text-globalidx: +.. _text-localidx: +.. _text-labelidx: +.. index:: index, type index, function index, table index, memory index, global index, local index, label index + pair: text format; type index + pair: text format; function index + pair: text format; table index + pair: text format; memory index + pair: text format; global index + pair: text format; local index + pair: text format; label index + +Indices +~~~~~~~ + +:ref:`Indices ` can be given either in raw numeric form or as symbolic :ref:`identifiers ` when bound by a respective construct. +Such identifiers are looked up in the suitable space of the :ref:`identifier context `. + +.. math:: + \begin{array}{llcllllllll} + \production{type index} & \Ttypeidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\TYPES[x] = v) \\ + \production{function index} & \Tfuncidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\FUNCS[x] = v) \\ + \production{table index} & \Ttableidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\TABLES[x] = v) \\ + \production{memory index} & \Tmemidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\MEMS[x] = v) \\ + \production{global index} & \Tglobalidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\GLOBALS[x] = v) \\ + \production{local index} & \Tlocalidx_I &::=& + x{:}\Tu32 &\Rightarrow& x &|& + v{:}\Tid &\Rightarrow& x & (I.\LOCALS[x] = v) \\ + \production{label index} & \Tlabelidx_I &::=& + l{:}\Tu32 &\Rightarrow& l &|& + v{:}\Tid &\Rightarrow& l & (I.\LABELS[l] = v) \\ + \end{array} + + +.. _text-label: +.. index:: index, label index + pair: text format; label index + +:ref:`Structured control instructions ` can be annotated with a symbolic :ref:`label identifier `. +They are the only symbolic identifiers that can be bound locally in an instruction sequence. +The following grammar handles the corresponding update to the :ref:`identifier context ` by producing a context with an additional label entry. + +.. math:: + \begin{array}{llcllll} + \production{label} & \Tlabel_I &::=& + \epsilon &\Rightarrow& \{\LABELS~(\epsilon)\} \compose I \\ &&|& + v{:}\Tid &\Rightarrow& \{\LABELS~v\} \compose I + & (v \notin I.\LABELS) \\ + \end{array} + +.. note:: + The new label entry is inserted at the *beginning* of the label list in the identifier context. + This effectively shifts all existing labels up by one, + mirroring the fact that control instructions are indexed relatively not absolutely. + + +.. _text-instr-control: +.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism + pair: text format; instruction + +Control Instructions +~~~~~~~~~~~~~~~~~~~~ + +.. _text-block: +.. _text-loop: +.. _text-if: + +:ref:`Structured control instructions ` can bind an optional symbolic :ref:`label identifier `. +The same identifier may optionally be repeated after the corresponding :math:`\T{end}` and :math:`\T{else}` pseudo instructions. + +.. math:: + \begin{array}{llclll} + \production{block instruction} & \Tblockinstr_I &::=& + \text{block}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^? + \\ &&&\qquad \Rightarrow\quad \BLOCK~\X{rt}~\X{in}^\ast~\END + \qquad\quad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|& + \text{loop}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^? + \\ &&&\qquad \Rightarrow\quad \LOOP~\X{rt}~\X{in}^\ast~\END + \qquad\qquad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|& + \text{if}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~ + \text{else}~~\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid_2^? + \\ &&&\qquad \Rightarrow\quad \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END + \qquad (\Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\ + \end{array} + +.. _text-nop: +.. _text-unreachable: +.. _text-br: +.. _text-br_if: +.. _text-br_table: +.. _text-return: +.. _text-call: +.. _text-call_indirect: + +All other control instruction are represented verbatim. + +.. math:: + \begin{array}{llclll} + \production{plain instruction} & \Tplaininstr_I &::=& + \text{unreachable} &\Rightarrow& \UNREACHABLE \\ &&|& + \text{nop} &\Rightarrow& \NOP \\ &&|& + \text{br}~~l{:}\Tlabelidx_I &\Rightarrow& \BR~l \\ &&|& + \text{br\_if}~~l{:}\Tlabelidx_I &\Rightarrow& \BRIF~l \\ &&|& + \text{br\_table}~~l^\ast{:}\Tvec(\Tlabelidx_I)~~l_N{:}\Tlabelidx_I + &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|& + \text{return} &\Rightarrow& \RETURN \\ &&|& + \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|& + \text{call\_indirect}~~x{:}\Ttypeidx_I &\Rightarrow& \CALLINDIRECT~x \\ + \end{array} + + +Abbreviations +............. + +The :math:`\text{else}` keyword of an :math:`\text{if}` instruction can be omitted if the following instruction sequence is empty. + +.. math:: + \begin{array}{llclll} + \production{block instruction} & + \text{if}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} + &\equiv& + \text{if}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{else}~~\text{end} + \end{array} + + +.. _text-instr-parametric: +.. index:: value type, polymorphism + pair: text format; instruction + +Parametric Instructions +~~~~~~~~~~~~~~~~~~~~~~~ + +.. _text-drop: +.. _text-select: + +.. math:: + \begin{array}{llclll} + \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|& + \text{drop} &\Rightarrow& \DROP \\ &&|& + \text{select} &\Rightarrow& \SELECT \\ + \end{array} + + +.. _text-instr-variable: +.. index:: variable instructions, local index, global index + pair: text format; instruction + +Variable Instructions +~~~~~~~~~~~~~~~~~~~~~ + +.. _text-get_local: +.. _text-set_local: +.. _text-tee_local: +.. _text-get_global: +.. _text-set_global: + +.. math:: + \begin{array}{llclll} + \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|& + \text{get\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \GETLOCAL~x \\ &&|& + \text{set\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \SETLOCAL~x \\ &&|& + \text{tee\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \TEELOCAL~x \\ &&|& + \text{get\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \GETGLOBAL~x \\ &&|& + \text{set\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \SETGLOBAL~x \\ + \end{array} + + +.. _text-instr-memory: +.. _text-memarg: +.. index:: memory instruction, memory index + pair: text format; instruction + +Memory Instructions +~~~~~~~~~~~~~~~~~~~ + +.. _text-memarg: +.. _text-load: +.. _text-loadn: +.. _text-store: +.. _text-storen: +.. _text-current_memory: +.. _text-grow_memory: + +The offset and alignment immediates to memory instructions are optional. +The offset defaults to :math:`\T{0}`, the alignment to the storage size of the respective memory access, which is its *natural alignment*. +Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword token `, so no :ref:`white space ` is allowed around the :math:`\text{=}`. + +.. math:: + \begin{array}{llclll} + \production{memory argument} & \Tmemarg_N &::=& + o{:}\Toffset~~a{:}\Talign_N &\Rightarrow& \{ \ALIGN~a,~\OFFSET~o \} \\ + \production{memory offset} & \Toffset &::=& + \text{offset{=}}o{:}\Tu32 &\Rightarrow& o \\ &&|& + \epsilon &\Rightarrow& 0 \\ + \production{memory alignment} & \Talign_N &::=& + \text{align{=}}a{:}\Tu32 &\Rightarrow& a \\ &&|& + \epsilon &\Rightarrow& N \\ + \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|& + \text{i32.load}~~m{:}\Tmemarg_4 &\Rightarrow& \I32.\LOAD~m \\ &&|& + \text{i64.load}~~m{:}\Tmemarg_8 &\Rightarrow& \I64.\LOAD~m \\ &&|& + \text{f32.load}~~m{:}\Tmemarg_4 &\Rightarrow& \F32.\LOAD~m \\ &&|& + \text{f64.load}~~m{:}\Tmemarg_8 &\Rightarrow& \F64.\LOAD~m \\ &&|& + \text{i32.load8\_s}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\LOAD\K{8\_s}~m \\ &&|& + \text{i32.load8\_u}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\LOAD\K{8\_u}~m \\ &&|& + \text{i32.load16\_s}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\LOAD\K{16\_s}~m \\ &&|& + \text{i32.load16\_u}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\LOAD\K{16\_u}~m \\ &&|& + \text{i64.load8\_s}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\LOAD\K{8\_s}~m \\ &&|& + \text{i64.load8\_u}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\LOAD\K{8\_u}~m \\ &&|& + \text{i64.load16\_s}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\LOAD\K{16\_s}~m \\ &&|& + \text{i64.load16\_u}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\LOAD\K{16\_u}~m \\ &&|& + \text{i64.load32\_s}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\LOAD\K{32\_s}~m \\ &&|& + \text{i64.load32\_u}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\LOAD\K{32\_u}~m \\ &&|& + \text{i32.store}~~m{:}\Tmemarg_4 &\Rightarrow& \I32.\STORE~m \\ &&|& + \text{i64.store}~~m{:}\Tmemarg_8 &\Rightarrow& \I64.\STORE~m \\ &&|& + \text{f32.store}~~m{:}\Tmemarg_4 &\Rightarrow& \F32.\STORE~m \\ &&|& + \text{f64.store}~~m{:}\Tmemarg_8 &\Rightarrow& \F64.\STORE~m \\ &&|& + \text{i32.store8}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\STORE\K{8}~m \\ &&|& + \text{i32.store16}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\STORE\K{16}~m \\ &&|& + \text{i64.store8}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\STORE\K{8}~m \\ &&|& + \text{i64.store16}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\STORE\K{16}~m \\ &&|& + \text{i64.store32}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\STORE\K{32}~m \\ &&|& + \text{current\_memory} &\Rightarrow& \CURRENTMEMORY \\ &&|& + \text{grow\_memory} &\Rightarrow& \GROWMEMORY \\ + \end{array} + + +.. _text-instr-numeric: +.. index:: numeric instruction + pair: text format; instruction + +Numeric Instructions +~~~~~~~~~~~~~~~~~~~~ + +.. _text-const: + +.. math:: + \begin{array}{llclll} + \production{instruction} & \Tplaininstr_I &::=& \dots \\&&|& + \text{i32.const}~~n{:}\Ti32 &\Rightarrow& \I32.\CONST~n \\ &&|& + \text{i64.const}~~n{:}\Ti64 &\Rightarrow& \I64.\CONST~n \\ &&|& + \text{f32.const}~~z{:}\Tf32 &\Rightarrow& \F32.\CONST~z \\ &&|& + \text{f64.const}~~z{:}\Tf64 &\Rightarrow& \F64.\CONST~z \\ + \end{array} + +.. _text-unop: +.. _text-binop: + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{i32.clz} &\Rightarrow& \I32.\CLZ \\ &&|& + \text{i32.ctz} &\Rightarrow& \I32.\CTZ \\ &&|& + \text{i32.popcnt} &\Rightarrow& \I32.\POPCNT \\ &&|& + \text{i32.add} &\Rightarrow& \I32.\ADD \\ &&|& + \text{i32.sub} &\Rightarrow& \I32.\SUB \\ &&|& + \text{i32.mul} &\Rightarrow& \I32.\MUL \\ &&|& + \text{i32.div\_s} &\Rightarrow& \I32.\DIV\K{\_s} \\ &&|& + \text{i32.div\_u} &\Rightarrow& \I32.\DIV\K{\_u} \\ &&|& + \text{i32.rem\_s} &\Rightarrow& \I32.\REM\K{\_s} \\ &&|& + \text{i32.rem\_u} &\Rightarrow& \I32.\REM\K{\_u} \\ &&|& + \text{i32.and} &\Rightarrow& \I32.\AND \\ &&|& + \text{i32.or} &\Rightarrow& \I32.\OR \\ &&|& + \text{i32.xor} &\Rightarrow& \I32.\XOR \\ &&|& + \text{i32.shl} &\Rightarrow& \I32.\SHL \\ &&|& + \text{i32.shr\_s} &\Rightarrow& \I32.\SHR\K{\_s} \\ &&|& + \text{i32.shr\_u} &\Rightarrow& \I32.\SHR\K{\_u} \\ &&|& + \text{i32.rotl} &\Rightarrow& \I32.\ROTL \\ &&|& + \text{i32.rotr} &\Rightarrow& \I32.\ROTR \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{i64.clz} &\Rightarrow& \I64.\CLZ \\ &&|& + \text{i64.ctz} &\Rightarrow& \I64.\CTZ \\ &&|& + \text{i64.popcnt} &\Rightarrow& \I64.\POPCNT \\ &&|& + \text{i64.add} &\Rightarrow& \I64.\ADD \\ &&|& + \text{i64.sub} &\Rightarrow& \I64.\SUB \\ &&|& + \text{i64.mul} &\Rightarrow& \I64.\MUL \\ &&|& + \text{i64.div\_s} &\Rightarrow& \I64.\DIV\K{\_s} \\ &&|& + \text{i64.div\_u} &\Rightarrow& \I64.\DIV\K{\_u} \\ &&|& + \text{i64.rem\_s} &\Rightarrow& \I64.\REM\K{\_s} \\ &&|& + \text{i64.rem\_u} &\Rightarrow& \I64.\REM\K{\_u} \\ &&|& + \text{i64.and} &\Rightarrow& \I64.\AND \\ &&|& + \text{i64.or} &\Rightarrow& \I64.\OR \\ &&|& + \text{i64.xor} &\Rightarrow& \I64.\XOR \\ &&|& + \text{i64.shl} &\Rightarrow& \I64.\SHL \\ &&|& + \text{i64.shr\_s} &\Rightarrow& \I64.\SHR\K{\_s} \\ &&|& + \text{i64.shr\_u} &\Rightarrow& \I64.\SHR\K{\_u} \\ &&|& + \text{i64.rotl} &\Rightarrow& \I64.\ROTL \\ &&|& + \text{i64.rotr} &\Rightarrow& \I64.\ROTR \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{f32.abs} &\Rightarrow& \F32.\ABS \\ &&|& + \text{f32.neg} &\Rightarrow& \F32.\NEG \\ &&|& + \text{f32.ceil} &\Rightarrow& \F32.\CEIL \\ &&|& + \text{f32.floor} &\Rightarrow& \F32.\FLOOR \\ &&|& + \text{f32.trunc} &\Rightarrow& \F32.\TRUNC \\ &&|& + \text{f32.nearest} &\Rightarrow& \F32.\NEAREST \\ &&|& + \text{f32.sqrt} &\Rightarrow& \F32.\SQRT \\ &&|& + \text{f32.add} &\Rightarrow& \F32.\ADD \\ &&|& + \text{f32.sub} &\Rightarrow& \F32.\SUB \\ &&|& + \text{f32.mul} &\Rightarrow& \F32.\MUL \\ &&|& + \text{f32.div} &\Rightarrow& \F32.\DIV \\ &&|& + \text{f32.min} &\Rightarrow& \F32.\FMIN \\ &&|& + \text{f32.max} &\Rightarrow& \F32.\FMAX \\ &&|& + \text{f32.copysign} &\Rightarrow& \F32.\COPYSIGN \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{f64.abs} &\Rightarrow& \F64.\ABS \\ &&|& + \text{f64.neg} &\Rightarrow& \F64.\NEG \\ &&|& + \text{f64.ceil} &\Rightarrow& \F64.\CEIL \\ &&|& + \text{f64.floor} &\Rightarrow& \F64.\FLOOR \\ &&|& + \text{f64.trunc} &\Rightarrow& \F64.\TRUNC \\ &&|& + \text{f64.nearest} &\Rightarrow& \F64.\NEAREST \\ &&|& + \text{f64.sqrt} &\Rightarrow& \F64.\SQRT \\ &&|& + \text{f64.add} &\Rightarrow& \F64.\ADD \\ &&|& + \text{f64.sub} &\Rightarrow& \F64.\SUB \\ &&|& + \text{f64.mul} &\Rightarrow& \F64.\MUL \\ &&|& + \text{f64.div} &\Rightarrow& \F64.\DIV \\ &&|& + \text{f64.min} &\Rightarrow& \F64.\FMIN \\ &&|& + \text{f64.max} &\Rightarrow& \F64.\FMAX \\ &&|& + \text{f64.copysign} &\Rightarrow& \F64.\COPYSIGN \\ + \end{array} + +.. _text-testop: +.. _text-relop: + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{i32.eqz} &\Rightarrow& \I32.\EQZ \\ &&|& + \text{i32.eq} &\Rightarrow& \I32.\EQ \\ &&|& + \text{i32.ne} &\Rightarrow& \I32.\NE \\ &&|& + \text{i32.lt\_s} &\Rightarrow& \I32.\LT\K{\_s} \\ &&|& + \text{i32.lt\_u} &\Rightarrow& \I32.\LT\K{\_u} \\ &&|& + \text{i32.gt\_s} &\Rightarrow& \I32.\GT\K{\_s} \\ &&|& + \text{i32.gt\_u} &\Rightarrow& \I32.\GT\K{\_u} \\ &&|& + \text{i32.le\_s} &\Rightarrow& \I32.\LE\K{\_s} \\ &&|& + \text{i32.le\_u} &\Rightarrow& \I32.\LE\K{\_u} \\ &&|& + \text{i32.ge\_s} &\Rightarrow& \I32.\GE\K{\_s} \\ &&|& + \text{i32.ge\_u} &\Rightarrow& \I32.\GE\K{\_u} \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{i64.eqz} &\Rightarrow& \I64.\EQZ \\ &&|& + \text{i64.eq} &\Rightarrow& \I64.\EQ \\ &&|& + \text{i64.ne} &\Rightarrow& \I64.\NE \\ &&|& + \text{i64.lt\_s} &\Rightarrow& \I64.\LT\K{\_s} \\ &&|& + \text{i64.lt\_u} &\Rightarrow& \I64.\LT\K{\_u} \\ &&|& + \text{i64.gt\_s} &\Rightarrow& \I64.\GT\K{\_s} \\ &&|& + \text{i64.gt\_u} &\Rightarrow& \I64.\GT\K{\_u} \\ &&|& + \text{i64.le\_s} &\Rightarrow& \I64.\LE\K{\_s} \\ &&|& + \text{i64.le\_u} &\Rightarrow& \I64.\LE\K{\_u} \\ &&|& + \text{i64.ge\_s} &\Rightarrow& \I64.\GE\K{\_s} \\ &&|& + \text{i64.ge\_u} &\Rightarrow& \I64.\GE\K{\_u} \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{f32.eq} &\Rightarrow& \F32.\EQ \\ &&|& + \text{f32.ne} &\Rightarrow& \F32.\NE \\ &&|& + \text{f32.lt} &\Rightarrow& \F32.\LT \\ &&|& + \text{f32.gt} &\Rightarrow& \F32.\GT \\ &&|& + \text{f32.le} &\Rightarrow& \F32.\LE \\ &&|& + \text{f32.ge} &\Rightarrow& \F32.\GE \\ + \end{array} + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{f64.eq} &\Rightarrow& \F64.\EQ \\ &&|& + \text{f64.ne} &\Rightarrow& \F64.\NE \\ &&|& + \text{f64.lt} &\Rightarrow& \F64.\LT \\ &&|& + \text{f64.gt} &\Rightarrow& \F64.\GT \\ &&|& + \text{f64.le} &\Rightarrow& \F64.\LE \\ &&|& + \text{f64.ge} &\Rightarrow& \F64.\GE \\ + \end{array} + +.. _text-cvtop: + +.. math:: + \begin{array}{llclll} + \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|& + \text{i32.wrap/i64} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|& + \text{i32.trunc\_s/f32} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|& + \text{i32.trunc\_u/f32} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|& + \text{i32.trunc\_s/f64} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F64 \\ &&|& + \text{i32.trunc\_u/f64} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F64 \\ &&|& + \text{i64.extend\_s/i32} &\Rightarrow& \I64.\EXTEND\K{\_s/}\I32 \\ &&|& + \text{i64.extend\_u/i32} &\Rightarrow& \I64.\EXTEND\K{\_u/}\I32 \\ &&|& + \text{i64.trunc\_s/f32} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F32 \\ &&|& + \text{i64.trunc\_u/f32} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F32 \\ &&|& + \text{i64.trunc\_s/f64} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F64 \\ &&|& + \text{i64.trunc\_u/f64} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F64 \\ &&|& + \text{f32.convert\_s/i32} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I32 \\ &&|& + \text{f32.convert\_u/i32} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I32 \\ &&|& + \text{f32.convert\_s/i64} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I64 \\ &&|& + \text{f32.convert\_u/i64} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I64 \\ &&|& + \text{f32.demote/f64} &\Rightarrow& \F32.\DEMOTE\K{/}\F64 \\ &&|& + \text{f64.convert\_s/i32} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I32 \\ &&|& + \text{f64.convert\_u/i32} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|& + \text{f64.convert\_s/i64} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|& + \text{f64.convert\_u/i64} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|& + \text{f64.demote/f32} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|& + \text{i32.reinterpret/f32} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|& + \text{i64.reinterpret/f64} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|& + \text{f32.reinterpret/i32} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|& + \text{f64.reinterpret/i64} &\Rightarrow& \F64.\REINTERPRET\K{/}\I64 \\ + \end{array} + + +.. _text-foldedinstr: +.. index:: ! folded instruction, S-expression + +Folded Instructions +~~~~~~~~~~~~~~~~~~~ + +As a special abbreviation, instructions can be grouped into *folded* S-expression form. +The set of all phrases defined by the following abbreviations recursively forms the auxiliary syntactic class |Tfoldedinstr|. +Such a folded instruction can appear anywhere a regular instruction can. + +.. MathJax doesn't handle LaTex multicolumns, this the spacing hack in the following formula. + +.. math:: + \begin{array}{lllll} + \production{instruction} & + \text{(}~\Tplaininstr~~\Tfoldedinstr^\ast~\text{)} + &\equiv\quad \Tfoldedinstr^\ast~~\Tplaininstr \\ & + \text{(}~\text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~\text{)} + &\equiv\quad \text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ & + \text{(}~\text{loop}~~\Tresulttype~~\Tinstr^\ast~\text{)} + &\equiv\quad \text{loop}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ & + \text{(}~\text{if}~~\Tlabel~~\Tresulttype~~\Tfoldedinstr^\ast + &\hspace{-3ex} \text{(}~\text{then}~~\Tinstr_1^\ast~\text{)}~~\text{(}~\text{else}~~\Tinstr_2^\ast~\text{)}^?~~\text{)} + \quad\equiv \\ &\qquad + \Tfoldedinstr^\ast~~\text{if}~~\Tlabel~~\Tresulttype &\hspace{-1ex} \Tinstr_1^\ast~~\text{else}~~(\Tinstr_2^\ast)^?~\text{end} \\ + \end{array} + +.. note:: + Folded instructions are solely syntactic sugar, + no additional syntactic or type-based checking is implied. + + +.. _text-expr: +.. index:: expression + pair: text format; expression + single: expression; constant + +Expressions +~~~~~~~~~~~ + +Expressions are written as instruction sequences. +No explicit :math:`\text{end}` keyword is included, since they only occur in bracketed positions. + +.. math:: + \begin{array}{llclll} + \production{expression} & \Texpr &::=& + (\X{in}{:}\Tinstr)^\ast &\Rightarrow& \X{in}^\ast~\END \\ + \end{array} diff --git a/document/text/lexical.rst b/document/text/lexical.rst new file mode 100644 index 0000000000..abf6466e60 --- /dev/null +++ b/document/text/lexical.rst @@ -0,0 +1,111 @@ +.. _text-lexical: +.. index:: lexical format + +Lexical Format +-------------- + + +.. _text-char: +.. index:: ! character, Unicode, ASCII, code point, ! source text + pair: text format; character + +Characters +~~~~~~~~~~ + +The text format assigns meaning to *source text*, which consists of a sequence of *characters*. +Characters are assumed to be represented as valid `Unicode `_ *code points*. + +.. math:: + \begin{array}{llll} + \production{character} & \Tchar &::=& + \unicode{00} ~|~ \dots ~|~ \unicode{D7FF} ~|~ \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\ + \end{array} + +.. note:: + While source text may contain any Unicode character in :ref:`comments ` or :ref:`string ` literals, + the rest of the grammar is formed exclusively from the characters supported by the `7-bit ASCII `_ subset of Unicode. + + +.. _text-token: +.. _text-keyword: +.. index:: ! token, ! keyword, character, white space, comment, source text + single: text format; token + +Tokens +~~~~~~ + +The character stream in the source text is divided, from left to right, into a sequence of *tokens*, as defined by the following grammar. + +.. math:: + \begin{array}{llll} + \production{token} & \Ttoken &::=& + \Tkeyword ~|~ \TuN ~|~ \TsN ~|~ \TfN ~|~ \Tstring ~|~ \Tid ~|~ + \text{(} ~|~ \text{)} ~|~ \Treserved \\ + \production{keyword} & \Tkeyword &::=& + \mbox{(any terminal symbol in the grammar that is none of the above)} \\ + \production{reserved} & \Treserved &::=& + \Tidchar^+ \\ + \end{array} + +In this specification, the set of valid *keyword* tokens is defined implicitly, by their occurrence as a terminal symbols in literal form in the non-lexical grammar. +Any sequence of alphanumeric or symbolic characters that is not in the other classes is considered a *reserved word*. + +Tokens are formed from the input character stream according to the *longest match* rule. +That is, the next token always consists of the longest possible sequence of characters that is recognized by the above grammar. +Where necessary, tokens may be separated by :ref:`white space `. + + +.. _text-space: +.. index:: ! white space, character, ASCII + single: text format; white space + +White Space +~~~~~~~~~~~ + +*White space* is any sequence of literal space characters, formatting characters, or :ref:`comments `. +The allowed formatting characters correspond to a subset of the `ASCII `_ *format effectors*, namely, *horizontal tabulation* (:math:`\unicode{09}`), *line feed* (:math:`\unicode{0A}`), and *carriage return* (:math:`\unicode{0D}`). + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{white space} & \Tspace &::=& + (\text{~~} ~|~ \Tformat ~|~ \Tcomment)^\ast \\ + \production{format} & \Tformat &::=& + \unicode{09} ~|~ \unicode{0A} ~|~ \unicode{0D} \\ + \end{array} + +The only relevance of white space is to separate :ref:`tokens `, it is ignored otherwise. + + +.. _text-comment: +.. index:: ! comment, character + single: text format; comment + +Comments +~~~~~~~~ + +A *comment* can either be a *line comment*, started with a double semicolon :math:`\Tcommentd` and extending to the end of the line, +or a *block comment*, enclosed in delimiters :math:`\Tcommentl \dots \Tcommentr`. +Block comments can be nested. + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{comment} & \Tcomment &::=& + \Tlinecomment ~|~ \Tblockcomment \\ + \production{line comment} & \Tlinecomment &::=& + \Tcommentd~~\Tlinechar^\ast~~(\unicode{0A} ~|~ \T{eof}) \\ + \production{line character} & \Tlinechar &::=& + c{:}\Tchar & (c \neq \unicode{0A}) \\ + \production{block comment} & \Tblockcomment &::=& + \Tcommentl~~\Tblockchar^\ast~~\Tcommentr \\ + \production{block character} & \Tblockchar &::=& + c{:}\Tchar & (c \neq \text{;} \wedge c \neq \text{(}) \\ &&|& + \text{;} & (\mbox{the next character is not}~\text{)}) \\ &&|& + \text{(} & (\mbox{the next character is not}~\text{;}) \\ &&|& + \Tblockcomment \\ + \end{array} + +Here, the pseudo token :math:`\T{eof}` indicates the end of the input. +The *look-ahead* restrictions on the productions for |Tblockchar| disambiguate the grammar such that only well-bracketed uses of block comment delimiters are allowed. + +.. note:: + Any formatting and control characters are allowed inside comments. diff --git a/document/text/modules.rst b/document/text/modules.rst new file mode 100644 index 0000000000..8f769a6c56 --- /dev/null +++ b/document/text/modules.rst @@ -0,0 +1,598 @@ +Modules +------- + + +.. _text-type: +.. index:: type definition, identifier + pair: text format; type definition + +Types +~~~~~ + +Type definitions can bind a symbolic :ref:`type identifier `. + +.. math:: + \begin{array}{llclll} + \production{type definition} & \Ttype &::=& + \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype~\text{)} + &\Rightarrow& \X{ft} \\ + \end{array} + + +.. _text-typeuse: +.. index:: type use + pair: text format; type use + +Type Uses +~~~~~~~~~ + +A *type use* is a reference to a :ref:`type definition `. +It may optionally be augmented by explicit inlined :ref:`parameter ` and :ref:`result ` declarations. +That allows binding symbolic :ref:`identifiers ` to name the :ref:`local indices ` of parameters. +If inline declarations are given, then their types must match the referenced :ref:`function type `. + +.. math:: + \begin{array}{llcllll} + \production{type use} & \Ttypeuse_I &::=& + \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)} + &\Rightarrow& x, I' & + (\begin{array}[t]{@{}l@{}} + I.\TYPEDEFS[x] = [t_1^n] \to [t_2^\ast] \wedge + I' = \{\LOCALS~(\epsilon)^n\}) \\ + \end{array} \\ &&|& + \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)} + ~~(t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast + &\Rightarrow& x, I' & + (\begin{array}[t]{@{}l@{}} + I.\TYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge + I' = \{\LOCALS~\F{id}(\Tparam)\}^\ast \idcwellformed) \\ + \end{array} \\ + \end{array} + +The resulting attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index ` and the updated :ref:`identifier context ` including possible parameter identifiers. +The following auxiliary notation extracts optional identifiers from parameters: + +.. math:: + \begin{array}{lcl@{\qquad\qquad}l} + \F{id}(\text{(}~\text{param}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \end{array} + +.. note:: + Both productions overlap for the case that the function type is :math:`[] \to []`. + However, in that case, they also produce the same results, so that the choice is immaterial. + + The :ref:`well-formedness ` condition on :math:`I'` ensures that the parameters do not contain duplicate identifier. + + +.. _text-typeuse-abbrev: + +Abbreviations +............. + +A |Ttypeuse| may also be replaced entirely by inline :ref:`parameter ` and :ref:`result ` declarations. +In that case, a :ref:`type index ` is automatically inserted: + +.. math:: + \begin{array}{llclll} + \production{type use} & + (t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast &\equiv& + \text{(}~\text{type}~~x~\text{)}~~\Tparam^\ast~~\Tresult^\ast \\ + \end{array} + +where :math:`x` is the smallest existing :ref:`type index ` whose definition in the current module is the :ref:`function type ` :math:`[t_1^\ast] \to [t_2^\ast]`. +If no such index exists, then a new :ref:`type definition ` of the form + +.. math:: + \text{(}~\text{type}~~\text{(}~\text{func}~~\Tparam^\ast~~\Tresult~\text{)}~\text{)} + +is first inserted at the end of the module. + +.. note:: + Abbreviations are expanded in the order they appear, such that previously inserted type definitions are reused by consecutive expansions. + + +.. _text-import: +.. index:: import, name, function type, table type, memory type, global type + pair: text format; import + +Imports +~~~~~~~ + +The descriptors in imports can bind a symbolic function, table, memory, or global :ref:`identifier `. + +.. math:: + \begin{array}{llclll} + \production{import} & \Timport_I &::=& + \text{(}~\text{import}~~\X{mod}{:}\Tname~~\X{nm}{:}\Tname~~d{:}\Timportdesc_I~\text{)} + &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\ + \production{import description} & \Timportdesc_I &::=& + \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)} + &\Rightarrow& \FUNC~x \\ &&|& + \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)} + &\Rightarrow& \TABLE~\X{tt} \\ &&|& + \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)} + &\Rightarrow& \MEM~~\X{mt} \\ &&|& + \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~\text{)} + &\Rightarrow& \GLOBAL~\X{gt} \\ + \end{array} + + +Abbreviations +............. + +As an abbreviation, imports may also be specified inline with :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global ` definitions; see the respective sections. + + + +.. _text-func: +.. _text-local: +.. index:: function, type index, function type, identifier, local + pair: text format; function + pair: text format; local + +Functions +~~~~~~~~~ + +Function definitions can bind a symbolic :ref:`function identifier `, and :ref:`local identifiers ` for its :ref:`parameters ` and locals. + +.. math:: + \begin{array}{llclll} + \production{function} & \Tfunc_I &::=& + \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~ + (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} + &\Rightarrow& \{ \TYPE~x, \LOCALS~t^\ast, \BODY~\X{in}^\ast~\END \} \\ &&&&& \qquad + (I'' = I' \compose \{\LOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\ + \production{local} & \Tlocal &::=& + \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)} + &\Rightarrow& t \\ + \end{array} + +The definition of the local :ref:`identifier context ` :math:`I''` uses the following auxiliary notation to extract optional identifiers from locals: + +.. math:: + \begin{array}{lcl@{\qquad\qquad}l} + \F{id}(\text{(}~\text{local}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \end{array} + + +.. note:: + The :ref:`well-formedness ` condition on :math:`I''` ensures that parameters and locals do not contain duplicate identifiers. + + +.. _text-func-abbrev: +.. index:: import, name + pair: text format; import +.. index:: export, name, index, function index + pair: text format; export + +Abbreviations +............. + +Multiple anonymous locals may be combined into a single declaration: + +.. math:: + \begin{array}{llclll} + \production{local} & + \text{(}~~\text{local}~~\Tvaltype^\ast~~\text{)} &\equiv& + (\text{(}~~\text{local}~~\Tvaltype~~\text{)})^\ast \\ + \end{array} + +Moreover, functions can be defined as :ref:`imports ` or :ref:`exports ` inline: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttypeuse~\text{)} &\equiv& + \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{func}~~\Tid^?~~\Ttypeuse~\text{)}~\text{)} \\ & + \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv& + \text{(}~\text{export}~~\Tname~~\text{(}~\text{func}~~\Tid'~\text{)}~\text{)}~~ + \text{(}~\text{func}~~\Tid'~~\dots~\text{)} + \\&&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\ + \end{array} + +The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export. + + +.. _text-table: +.. index:: table, table type, identifier + pair: text format; table + +Tables +~~~~~~ + +Table definitions can bind a symbolic :ref:`table identifier `. + +.. math:: + \begin{array}{llclll} + \production{table} & \Ttable_I &::=& + \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)} + &\Rightarrow& \{ \TYPE~\X{tt} \} \\ + \end{array} + + +.. _text-table-abbrev: +.. index:: import, name + pair: text format; import +.. index:: export, name, index, table index + pair: text format; export +.. index:: element, table index, function index + pair: text format; element + single: table; element + single: element; segment + +Abbreviations +............. + +An :ref:`element segment ` can be given inline with a table definition, in which case the :ref:`limits ` of the :ref:`table type ` are inferred from the length of the given segment: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{table}~~\Tid^?~~\Telemtype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~~\text{)} &\equiv& + \text{(}~\text{table}~~\Tid'~~n~~n~~\Telemtype~\text{)}~~ + \text{(}~\text{elem}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)} + \\&&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\ + \end{array} + +Moreover, tables can be defined as :ref:`imports ` or :ref:`exports ` inline: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttabletype~\text{)} &\equiv& + \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{table}~~\Tid^?~~\Ttabletype~\text{)}~\text{)} \\ & + \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv& + \text{(}~\text{export}~~\Tname~~\text{(}~\text{table}~~\Tid'~\text{)}~\text{)}~~ + \text{(}~\text{table}~~\Tid'~~\dots~\text{)} + \\&&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\ + \end{array} + +The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment. + + +.. _text-mem: +.. index:: memory, memory type, identifier + pair: text format; memory + +Memories +~~~~~~~~ + +Memory definitions can bind a symbolic :ref:`memory identifier `. + +.. math:: + \begin{array}{llclll} + \production{memory} & \Tmem_I &::=& + \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)} + &\Rightarrow& \{ \TYPE~\X{mt} \} \\ + \end{array} + + +.. _text-mem-abbrev: +.. index:: import, name + pair: text format; import +.. index:: export, name, index, memory index + pair: text format; export +.. index:: data, memory, memory index, expression, byte, page size + pair: text format; data + single: memory; data + single: data; segment + +Abbreviations +............. + +A :ref:`data segment ` can be given inline with a memory definition, in which case the :ref:`limits ` of the :ref:`memory type ` are inferred from the length of the data, rounded up to :ref:`page size `: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{data}~~b^n{:}\Tdatastring~\text{)}~~\text{)} &\equiv& + \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)}~~ + \text{(}~\text{data}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)} + \\&&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\ + \end{array} + +Moreover, memories can be defined as :ref:`imports ` or :ref:`exports ` inline: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tmemtype~\text{)} &\equiv& + \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{memory}~~\Tid^?~~\Tmemtype~\text{)}~\text{)} + \\ & + \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv& + \text{(}~\text{export}~~\Tname~~\text{(}~\text{memory}~~\Tid'~\text{)}~\text{)}~~ + \text{(}~\text{memory}~~\Tid'~~\dots~\text{)} + \\ &&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\ + \end{array} + +The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment. + + +.. _text-global: +.. index:: global, global type, identifier, expression + pair: text format; global + +Globals +~~~~~~~ + +Global definitions can bind a symbolic :ref:`global identifier `. + +.. math:: + \begin{array}{llclll} + \production{global} & \Tglobal_I &::=& + \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~~e{:}\Texpr_I~\text{)} + &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\ + \end{array} + + +.. _text-global-abbrev: +.. index:: import, name + pair: text format; import +.. index:: export, name, index, global index + pair: text format; export + +Abbreviations +............. + +Globals can be defined as :ref:`imports ` or :ref:`exports ` inline: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tglobaltype~\text{)} &\equiv& + \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{global}~~\Tid^?~~\Tglobaltype~\text{)}~\text{)} + \\ & + \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv& + \text{(}~\text{export}~~\Tname~~\text{(}~\text{global}~~\Tid'~\text{)}~\text{)}~~ + \text{(}~\text{global}~~\Tid'~~\dots~\text{)} + \\ &&& \qquad + (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\ + \end{array} + +The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export. + + +.. _text-export: +.. index:: export, name, index, function index, table index, memory index, global index + pair: text format; export + +Exports +~~~~~~~ + +The syntax for exports mirrors their :ref:`abstract syntax ` directly. + +.. math:: + \begin{array}{llclll} + \production{export} & \Texport_I &::=& + \text{(}~\text{export}~~\X{nm}{:}\Tname~~d{:}\Texportdesc_I~\text{)} + &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\ + \production{export description} & \Texportdesc_I &::=& + \text{(}~\text{func}~~x{:}\Bfuncidx_I~\text{)} + &\Rightarrow& \FUNC~x \\ &&|& + \text{(}~\text{table}~~x{:}\Btableidx_I~\text{)} + &\Rightarrow& \TABLE~x \\ &&|& + \text{(}~\text{memory}~~x{:}\Bmemidx_I~\text{)} + &\Rightarrow& \MEM~x \\ &&|& + \text{(}~\text{global}~~x{:}\Bglobalidx_I~\text{)} + &\Rightarrow& \GLOBAL~x \\ + \end{array} + + +Abbreviations +............. + +As an abbreviation, exports may also be specified inline with :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global ` definitions; see the respective sections. + + +.. _text-start: +.. index:: start function, function index + pair: text format; start function + +Start Function +~~~~~~~~~~~~~~ + +A :ref:`start function ` is defined in terms of its index. + +.. math:: + \begin{array}{llclll} + \production{start function} & \Tstart_I &::=& + \text{(}~\text{start}~~x{:}\Tfuncidx_I~\text{)} + &\Rightarrow& \{ \FUNC~x \} \\ + \end{array} + +.. note:: + At most one start function may occur in a module, + which is ensured by a suitable side condition on the |Tmodule| grammar. + + + +.. _text-elem: +.. index:: element, table index, expression, function index + pair: text format; element + single: table; element + single: element; segment + +Element Segments +~~~~~~~~~~~~~~~~ + +Element segments allow for an optional :ref:`table index ` to identify the table to initialize. +When omitted, :math:`\T{0}` is assumed. + +.. math:: + \begin{array}{llclll} + \production{element segment} & \Telem_I &::=& + \text{(}~\text{elem}~~(x{:}\Ttableidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)} + &\Rightarrow& \{ \TABLE~x', \OFFSET~e, \INIT~y^\ast \} \\ + &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\ + \end{array} + +.. note:: + In the current version of WebAssembly, the only valid table index is 0 + or a symbolic :ref:`table identifier ` resolving to the same value. + + +Abbreviations +............. + +As an abbreviation, element segments may also be specified inline with :ref:`table ` definitions; see the respective section. + + +.. _text-data: +.. _text-datastring: +.. index:: data, memory, memory index, expression, byte + pair: text format; data + single: memory; data + single: data; segment + +Data Segments +~~~~~~~~~~~~~ + +Data segments allow for an optional :ref:`memory index ` to identify the memory to initialize. +When omitted, :math:`\T{0}` is assumed. +The data is written as a :ref:`string `, which may be split up into a possibly empty sequence of individual string literals. + +.. math:: + \begin{array}{llclll} + \production{data segment} & \Tdata_I &::=& + \text{(}~\text{data}~~(x{:}\Tmemidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)} + &\Rightarrow& \{ \MEM~x', \OFFSET~e, \INIT~b^\ast \} \\ + &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\ + \production{data string} & \Tdatastring &::=& + (b^\ast{:}\Tstring)^\ast &\Rightarrow& \concat((b^\ast)^\ast) \\ + \end{array} + +.. note:: + In the current version of WebAssembly, the only valid memory index is 0 + or a symbolic :ref:`memory identifier ` resolving to the same value. + + +Abbreviations +............. + +As an abbreviation, data segments may also be specified inline with :ref:`memory ` definitions; see the respective section. + + +.. _text-module: +.. _text-modulebody: +.. _text-modulefield: +.. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, identifier context, identifier, name section + pair: text format; module + single: section; name + +Modules +~~~~~~~ + +A module consists of a sequence of fields that can occur in any order. +All definitions and their respective bound :ref:`identifiers ` scope over the entire module, including the text preceding them. + +A module may optionally bind an :ref:`identifier ` that names the module. +The name serves a documentary role only. + +.. note:: + Tools may include the module name in the :ref:`name section ` of the :ref:`binary format `. + +.. math:: + \begin{array}{lll} + \production{module} & \Tmodule & + \begin{array}[t]{@{}cllll} + ::=& + \text{(}~\text{module}~~\Tid^?~~(m{:}\Tmodulefield_I)^\ast~\text{)} + &\Rightarrow& \bigcompose m^\ast + & (I = \bigcompose \F{idc}(\Tmodulefield)^\ast \idcwellformed) \\ + \end{array} \\ + \production{module field} & \Tmodulefield_I & + \begin{array}[t]{@{}clll} + ::=& + \X{ty}{:}\Ttype &\Rightarrow& \{\TYPES~\X{ty}\} \\ |& + \X{im}{:}\Timport_I &\Rightarrow& \{\IMPORTS~\X{im}\} \\ |& + \X{fn}{:}\Tfunc_I &\Rightarrow& \{\FUNCS~\X{fn}\} \\ |& + \X{ta}{:}\Ttable_I &\Rightarrow& \{\TABLES~\X{ta}\} \\ |& + \X{me}{:}\Tmem_I &\Rightarrow& \{\MEMS~\X{me}\} \\ |& + \X{gl}{:}\Tglobal_I &\Rightarrow& \{\GLOBALS~\X{gl}\} \\ |& + \X{ex}{:}\Texport_I &\Rightarrow& \{\EXPORTS~\X{ex}\} \\ |& + \X{st}{:}\Tstart_I &\Rightarrow& \{\START~\X{st}\} \\ |& + \X{el}{:}\Telem_I &\Rightarrow& \{\ELEM~\X{el}\} \\ |& + \X{da}{:}\Tdata_I &\Rightarrow& \{\DATA~\X{da}\} \\ + \end{array} + \end{array} + +The following restrictions are imposed on the composition of :ref:`modules `: :math:`m_1 \compose m_2` is defined if and only if + +* :math:`m_1.\START = \epsilon \vee m_2.\START = \epsilon` + +* :math:`m_2.\IMPORTS = \epsilon \vee m_1.\FUNCS = m_1.\TABLES = m_1.\MEMS = m_1.\GLOBALS = \epsilon` + +.. note:: + The first condition ensures that there is at most one start function. + The second condition enforces that all :ref:`imports ` must occur before any regular definition of a :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global `, + thereby maintaining the ordering of the respective :ref:`index spaces `. + + The :ref:`well-formedness ` condition on :math:`I` in the grammar for |Tmodule| ensures that no namespace contains duplicate identifiers. + +The definition of the initial :ref:`identifier context ` :math:`I` uses the following auxiliary definition which maps each relevant definition to a singular context with one (possibly empty) identifier: + +.. math:: + \begin{array}{@{}lcl@{\qquad\qquad}l} + \F{idc}(\text{(}~\text{type}~\Tid^?~\X{ft}{:}\Tfunctype~\text{)}) &=& + \{\TYPES~(\Tid^?), \TYPEDEFS~\X{ft}\} \\ + \F{idc}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=& + \{\FUNCS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=& + \{\TABLES~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=& + \{\MEMS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=& + \{\GLOBALS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{func}~\Tid^?~\dots~\text{)}~\text{)}) &=& + \{\FUNCS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{table}~\Tid^?~\dots~\text{)}~\text{)}) &=& + \{\TABLES~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{memory}~\Tid^?~\dots~\text{)}~\text{)}) &=& + \{\MEMS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{global}~\Tid^?~\dots~\text{)}~\text{)}) &=& + \{\GLOBALS~(\Tid^?)\} \\ + \F{idc}(\text{(}~\dots~\text{)}) &=& + \{\} \\ + \end{array} + + +.. math + \F{idc}(\epsilon) &=& + \{\} \\ + \F{idc}(\Tmodulebody~\Tmodulefield) &=& + \F{idc}(\Tmodulebody) \compose \F{idc}(\Tmodulefield) \\[1ex] + + The definition of the :ref:`identifier context ` :math:`I` uses the following auxiliary notation to filters out optional identifiers from definitions and imports in an order-preserving fashion: + + \begin{array}{@{}l@{}} + \begin{array}{@{}lcl@{\qquad\qquad}l} + \F{id}(\text{(}~\text{type}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \F{id}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \F{id}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \F{id}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\ + \F{id}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\[1ex] + \F{funcids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{func}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\ + \F{tableids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{table}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\ + \F{memids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{memory}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\ + \F{globalids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{global}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\ + \end{array} \\ + \F{desc}(\text{(}~\text{import}~\dots~\Timportdesc~\text{)}) \quad=\quad \Timportdesc + \end{array} + + +Abbreviations +............. + +In a source file, the toplevel :math:`\T{(module}~\dots\T{)}` surrounding the module body may be omitted. + +.. math:: + \begin{array}{llcll} + \production{module} & + \Tmodulefield^\ast &\equiv& + \text{(}~\text{module}~~\Tmodulefield^\ast~\text{)} + \end{array} diff --git a/document/text/types.rst b/document/text/types.rst new file mode 100644 index 0000000000..78b02183e4 --- /dev/null +++ b/document/text/types.rst @@ -0,0 +1,143 @@ +.. _text-type: +.. index:: type + pair: text format; type + +Types +----- + +.. _text-valtype: +.. index:: value type + pair: text format; value type + +Value Types +~~~~~~~~~~~ + +.. math:: + \begin{array}{llcll@{\qquad\qquad}l} + \production{value type} & \Tvaltype &::=& + \text{i32} &\Rightarrow& \I32 \\ &&|& + \text{i64} &\Rightarrow& \I64 \\ &&|& + \text{f32} &\Rightarrow& \F32 \\ &&|& + \text{f64} &\Rightarrow& \F64 \\ + \end{array} + + +.. _text-resulttype: +.. index:: result type, value type + pair: text format; result type + +Result Types +~~~~~~~~~~~~ + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{result type} & \Tresulttype &::=& + (t{:}\Tresult)^? &\Rightarrow& [t^?] \\ + \end{array} + +.. note:: + In future versions of WebAssembly, this scheme may be extended to support multiple results or more general result types. + + +.. _text-functype: +.. _text-param: +.. _text-result: +.. index:: function type, value type, result type + pair: text format; function type + +Function Types +~~~~~~~~~~~~~~ + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{function type} & \Tfunctype &::=& + \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam)~~t_2^\ast{:\,}\Tvec(\Tresult)~\text{)} + &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\ + \production{parameter} & \Tparam &::=& + \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype~\text{)} + &\Rightarrow& t \\ + \production{result} & \Tresult &::=& + \text{(}~\text{result}~~t{:}\Tvaltype~\text{)} + &\Rightarrow& t \\ + \end{array} + +Abbreviations +............. + +Multiple anonymous parameters or results may be combined into a single declaration: + +.. math:: + \begin{array}{llclll} + \production{parameter} & + \text{(}~~\text{param}~~\Tvaltype^\ast~~\text{)} &\equiv& + (\text{(}~~\text{param}~~\Tvaltype~~\text{)})^\ast \\ + \production{result} & + \text{(}~~\text{result}~~\Tvaltype^\ast~~\text{)} &\equiv& + (\text{(}~~\text{result}~~\Tvaltype~~\text{)})^\ast \\ + \end{array} + + +.. _text-limits: +.. index:: limits + pair: text format; limits + +Limits +~~~~~~ + +.. math:: + \begin{array}{llclll} + \production{limits} & \Tlimits &::=& + n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|& + n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\ + \end{array} + + +.. _text-memtype: +.. index:: memory type, limits, page size + pair: text format; memory type + +Memory Types +~~~~~~~~~~~~ + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{memory type} & \Tmemtype &::=& + \X{lim}{:}\Tlimits &\Rightarrow& \X{lim} \\ + \end{array} + + +.. _text-tabletype: +.. _text-elemtype: +.. index:: table type, element type, limits + pair: text format; table type + pair: text format; element type + +Table Types +~~~~~~~~~~~ + +.. math:: + \begin{array}{llclll} + \production{table type} & \Ttabletype &::=& + \X{lim}{:}\Tlimits~~\X{et}{:}\Telemtype &\Rightarrow& \X{lim}~\X{et} \\ + \production{element type} & \Telemtype &::=& + \text{anyfunc} &\Rightarrow& \ANYFUNC \\ + \end{array} + +.. note:: + Additional element types may be introduced in future versions of WebAssembly. + + +.. _text-globaltype: +.. index:: global type, mutability, value type + pair: text format; global type + pair: text format; mutability + +Global Types +~~~~~~~~~~~~ + +.. math:: + \begin{array}{llclll} + \production{global type} & \Tglobaltype &::=& + t{:}\Tvaltype &\Rightarrow& \MCONST~t \\ &&|& + \text{(}~\text{mut}~~t{:}\Tvaltype~\text{)} &\Rightarrow& \MVAR~t \\ + \end{array} diff --git a/document/text/values.rst b/document/text/values.rst new file mode 100644 index 0000000000..77ae23684a --- /dev/null +++ b/document/text/values.rst @@ -0,0 +1,259 @@ +.. _text-value: +.. index:: value + pair: text format; value + +Values +------ + +The grammar productions in this section define *lexical syntax*, +hence no :ref:`white space ` is allowed. + + +.. _text-sign: +.. _text-digit: +.. _text-hexdigit: +.. _text-int: +.. _text-sint: +.. _text-uint: +.. index:: integer, unsigned integer, signed integer, uninterpreted integer + pair: text format; integer + pair: text format; unsigned integer + pair: text format; signed integer + pair: text format; uninterpreted integer + +Integers +~~~~~~~~ + +All :ref:`integers ` can be written in either decimal or hexadecimal notation. + +.. math:: + \begin{array}{llclll@{\qquad}l} + \production{sign} & \Tsign &::=& + \epsilon \Rightarrow {+}1 ~~|~~ + \text{+} \Rightarrow {+}1 ~~|~~ + \text{-} \Rightarrow {-}1 \\ + \production{decimal digit} & \Tdigit &::=& + \text{0} \Rightarrow 0 ~~|~~ \dots ~~|~~ \text{9} \Rightarrow 9 \\ + \production{hexadecimal digit} & \Thexdigit &::=& + d{:}\Tdigit \Rightarrow d \\ &&|& + \text{A} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{F} \Rightarrow 15 \\ &&|& + \text{a} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{f} \Rightarrow 15 \\ + \end{array} + +.. math:: + \begin{array}{llclll@{\qquad}l} + \production{decimal number} & \Tnum &::=& + d{:}\Tdigit &\Rightarrow& d \\ &&|& + n{:}\Tnum~~d{:}\Tdigit &\Rightarrow& 10\cdot n + d \\ + \production{hexadecimal number} & \Thexnum &::=& + h{:}\Thexdigit &\Rightarrow& h \\ &&|& + n{:}\Thexnum~~h{:}\Thexdigit &\Rightarrow& 16\cdot n + h \\ + \end{array} + +The allowed syntax for integer literals depends on size and signedness. +Moreover, their value must lie within the range of the respective type. + +.. math:: + \begin{array}{llclll@{\qquad}l} + \production{unsigned integer} & \TuN &::=& + n{:}\Tnum &\Rightarrow& n & (n < 2^N) \\ &&|& + \text{0x}~~n{:}\Thexnum &\Rightarrow& n & (n < 2^N) \\ + \production{signed integer} & \TsN &::=& + s{:}\Tsign~~n{:}\Tnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\ &&|& + s{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\ + \end{array} + +:ref:`Uninterpreted integers ` can be written as either signed or unsigned, and are normalized to unsigned in the abstract syntax. + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{uninterpreted integers} & \TiN &::=& + n{:}\TuN &\Rightarrow& n \\ &&|& + i{:}\TsN &\Rightarrow& n & (i = \signed(n)) \\ + \end{array} + + +.. _text-frac: +.. _text-hexfrac: +.. _text-float: +.. _text-hexfloat: +.. index:: floating-point number + pair: text format; floating-point number + +Floating-Point +~~~~~~~~~~~~~~ + +:ref:`Floating point ` values can be represented in either decimal or hexadecimal notation. +The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 `_ type +(that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`), +but it may be rounded to the nearest representable value. + +.. note:: + Rounding can be prevented by using hexadecimal notation with no more significant bits than supported by the required type. + +Floating-point values may also be written as constants for *infinity* or *canonical NaN* (*not a number*). +Furthermore, arbitrary NaN values may be expressed by providing an explicit payload value. + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{decimal floating-point fraction} & \Tfrac &::=& + \epsilon &\Rightarrow& 0 \\ &&|& + d{:}\Tdigit~q{:}\Tfrac &\Rightarrow& (d+q)/10 \\ + \production{hexadecimal floating-point fraction} & \Thexfrac &::=& + \epsilon &\Rightarrow& 0 \\ &&|& + h{:}\Thexdigit~q{:}\Thexfrac &\Rightarrow& (h+q)/16 \\ + \production{decimal floating-point number} & \Tfloat &::=& + s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac + &\Rightarrow& s\cdot(p+q) \\ &&|& + s{:}\Tsign~p{:}\Tnum~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum + &\Rightarrow& s\cdot p\cdot 10^{t\cdot e} \\ &&|& + s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum + &\Rightarrow& s\cdot(p+q)\cdot 10^{t\cdot e} \\ + \production{hexadecimal floating-point number} & \Thexfloat &::=& + s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac + &\Rightarrow& s\cdot(p+q) \\ &&|& + s{:}\Tsign~\text{0x}~p{:}\Thexnum~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum + &\Rightarrow& s\cdot p\cdot 2^{t\cdot e} \\ &&|& + s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum + &\Rightarrow& s\cdot(p+q)\cdot 2^{t\cdot e} \\ + \production{floating-point value} & \TfN &::=& + z{:}\Tfloat &\Rightarrow& \ieee_N(z) \\ &&|& + z{:}\Thexfloat &\Rightarrow& \ieee_N(z) \\ &&|& + s{:}\Tsign~\text{inf} &\Rightarrow& \ieeeinf_N(s) \\ &&|& + s{:}\Tsign~\text{nan} &\Rightarrow& \ieeenan_N(s, 0) \\ &&|& + s{:}\Tsign~\text{nan{:}}~\text{0x}~n{:}\Thexnum &\Rightarrow& b^\ast & (\ieeenan_N(s, n) = b^\ast) \\ + \end{array} + +.. todo:: IEEE encoding helper functions + + +.. _text-vec: +.. index:: vector + pair: text format; vector + +Vectors +~~~~~~~ + +:ref:`Vectors ` are written as plain sequences, but with restricted length. + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{vector} & \Tvec(\T{A}) &::=& + (x{:}\T{A})^n &\Rightarrow& x^n & (n < 2^{32}) \\ + \end{array} + + +.. _text-byte: +.. _text-string: +.. index:: ! string, byte, character, ASCII, Unicode, UTF-8 + pair: text format; byte + pair: text format; string + +Strings +~~~~~~~ + +*Strings* denote sequences of bytes that can represent both textual and binary data. +They are enclosed in quotation marks +and may contain any character other than `ASCII `_ control characters, quotation marks (:math:`\text{"}`), or backslash (:math:`\text{\backslash}`), +except when expressed with an *escape sequence*. + +Each character in a string literal represents the byte sequence corresponding to its `Unicode `_ UTF-8 encoding, +except for hexadecimal escape sequences :math:`\text{\backslash}hh`, which represent raw bytes of the respective value. + +.. math:: + \begin{array}{llclll@{\qquad\qquad}l} + \production{string} & \Tstring &::=& + \text{"}~(b^\ast{:}\Tstringelem)^\ast~\text{"} + &\Rightarrow& \concat((b^\ast)^\ast) + & (|\concat((b^\ast)^\ast)| < 2^{32}) \\ + \production{string element} & \Tstringelem &::=& + c{:}\Tstringchar &\Rightarrow& \utf8(c) \\ &&|& + \text{\backslash}~n{:}\Thexdigit~m{:}\Thexdigit + &\Rightarrow& 16\cdot n+m \\ + \production{string character} & \Tstringchar &::=& + c{:}\Tchar &\Rightarrow& c \qquad + & (c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} c \neq \text{\backslash}) \\ &&|& + \text{\backslash t} &\Rightarrow& \unicode{09} \\ &&|& + \text{\backslash n} &\Rightarrow& \unicode{0A} \\ &&|& + \text{\backslash r} &\Rightarrow& \unicode{0D} \\ &&|& + \text{\backslash{"}} &\Rightarrow& \unicode{22} \\ &&|& + \text{\backslash{'}} &\Rightarrow& \unicode{27} \\ &&|& + \text{\backslash\backslash} &\Rightarrow& \unicode{5C} \\ &&|& + \text{\backslash u\{}~n{:}\Thexnum~\text{\}} + &\Rightarrow& \unicode{(n)} & (n < \hex{D800} \vee \hex{E000} \leq n < \hex{110000}) \\ + \end{array} + + +.. _text-name: +.. index:: name, byte, character, code point + pair: text format; name + +Names +~~~~~ + +:ref:`Names ` are strings denoting a literal character sequence. +A name string must form a valid `UTF-8 `_ encoding that is interpreted as a string of Unicode code points. + +.. math:: + \begin{array}{llclll@{\qquad}l} + \production{name} & \Tname &::=& + b^\ast{:}\Tstring &\Rightarrow& c^\ast & (b^\ast = \utf8(c^\ast)) \\ + \end{array} + +.. note:: + Presuming the source text is itself encoded correctly, + strings that do not contain any uses of hexadecimal byte escapes are always valid names. + + +.. _text-id: +.. index:: ! identifiers + pair: text format; identifiers + +Identifiers +~~~~~~~~~~~ + +:ref:`Indices ` can be given in both numeric and symbolic form. +Symbolic *identifiers* that stand in lieu of indices start with :math:`\text{\$}`, followed by any sequence of printable `ASCII `_ characters that does not contain a space, quotation mark, comma, semicolon, or bracket. + +.. math:: + \begin{array}{llclll@{\qquad}l} + \production{identifier} & \Tid &::=& + \text{\$}~\Tidchar^+ \\ + \production{identifier character} & \Tidchar &::=& + \text{0} ~~|~~ \dots ~~|~~ \text{9} \\ &&|& + \text{A} ~~|~~ \dots ~~|~~ \text{Z} \\ &&|& + \text{a} ~~|~~ \dots ~~|~~ \text{z} \\ &&|& + \text{!} ~~|~~ + \text{\#} ~~|~~ + \text{\$} ~~|~~ + \text{\%} ~~|~~ + \text{\&} ~~|~~ + \text{'} ~~|~~ + \text{*} ~~|~~ + \text{+} ~~|~~ + \text{-} ~~|~~ + \text{.} ~~|~~ + \text{/} \\ &&|& + \text{:} ~~|~~ + \text{<} ~~|~~ + \text{=} ~~|~~ + \text{>} ~~|~~ + \text{?} ~~|~~ + \text{@} ~~|~~ + \text{\backslash} ~~|~~ + \text{\hat{~~}} ~~|~~ + \text{\_} ~~|~~ + \text{\grave{~~}} ~~|~~ + \text{|} ~~|~~ + \text{\tilde{~~}} \\ + \end{array} + +.. bla + +.. _text-id-fresh: + +Conventions +........... + +The expansion rules of some abbreviations require insertion of a *fresh* identifier. +That may be any syntactically valid identifier that does not already occur in the given source text. diff --git a/document/validation/conventions.rst b/document/validation/conventions.rst index 34c561d677..72a808f7ba 100644 --- a/document/validation/conventions.rst +++ b/document/validation/conventions.rst @@ -41,7 +41,7 @@ which collects relevant information about the surrounding :ref:`module ` for each :ref:`index space `, +In other words, a context contains a sequence of suitable :ref:`types ` for each :ref:`index space `, describing each defined entry in that space. Locals, labels and return type are only used for validating :ref:`instructions ` in :ref:`function bodies `, and are left empty elsewhere. The label stack is the only part of the context that changes as validation of an instruction sequence proceeds. diff --git a/document/validation/modules.rst b/document/validation/modules.rst index 0fcab62e1d..bd2e1bc320 100644 --- a/document/validation/modules.rst +++ b/document/validation/modules.rst @@ -29,6 +29,7 @@ Limits :math:`\{ \MIN~n, \MAX~m^? \}` .. _valid-func: +.. _valid-local: .. index:: function, local, function index, local index, type index, function type, value type, expression, import pair: abstract syntax; function single: abstract syntax; function diff --git a/interpreter/Makefile b/interpreter/Makefile index 4aab91505e..e92c9e5a38 100644 --- a/interpreter/Makefile +++ b/interpreter/Makefile @@ -95,24 +95,35 @@ $(WINMAKE): clean >>$@ -# Miscellaneous targets +# Executing test suite -.PHONY: test clean +.PHONY: test debugtest -$(ZIP): $(WINMAKE) - git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD +test: $(OPT) + ../test/core/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) +debugtest: $(UNOPT) + ../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) -test: $(NAME) - ../test/core/run.py --wasm `pwd`/$(NAME) $(if $(JS),--js '$(JS)',) +test/%: $(OPT) + ../test/core/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast) +debugtest/%: $(UNOPT) + ../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast) -test/%: $(NAME) - ../test/core/run.py --wasm `pwd`/$(NAME) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast) +run/%: $(OPT) + ./$(OPT) $(@:run/%=../test/core/%.wast) +debugrun/%: $(UNOPT) + ./$(UNOPT) $(@:run/%=../test/core/%.wast) -run/%: $(NAME) - ./$(NAME) $(@:run/%=../test/core/%.wast) + +# Miscellaneous targets + +.PHONY: clean + +$(ZIP): $(WINMAKE) + git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD clean: - rm -rf _build/jslib + rm -rf _build/jslib wasm.mlpack $(OCB) -clean diff --git a/interpreter/README.md b/interpreter/README.md index c0b42b7754..4fbff9b60b 100644 --- a/interpreter/README.md +++ b/interpreter/README.md @@ -75,7 +75,7 @@ You can call the executable with wasm [option | file ...] ``` -where `file`, depending on its extension, either should be an S-expression script file (see below) to be run, or a binary module file to be loaded. +where `file`, depending on its extension, either should be a binary (`.wasm`) or textual (`.wat`) module file to be loaded, or a script file (`.wast`, see below) to be run. By default, the interpreter validates all modules. The `-u` option selects "unchecked mode", which skips validation and runs code as is. @@ -86,8 +86,8 @@ Runtime type errors will be captured and reported appropriately. A file prefixed by `-o` is taken to be an output file. Depending on its extension, this will write out the preceding module definition in either S-expression or binary format. This option can be used to convert between the two in both directions, e.g.: ``` -wasm -d module.wast -o module.wasm -wasm -d module.wasm -o module.wast +wasm -d module.wat -o module.wasm +wasm -d module.wasm -o module.wat ``` In the second case, the produced script contains exactly one module definition. @@ -119,10 +119,10 @@ wasm module.wasm -e '(invoke "foo")' #### Interactive Mode -If neither a file nor any of the previous options is given, you'll land in the REPL and can enter script commands interactively. You can also get into the REPL by explicitly passing `-` as a file name. You can do that in combination to giving a module file, so that you can then invoke its exports interactively, e.g.: +If neither a file nor any of the previous options is given, you'll land in the REPL and can enter script commands interactively. You can also get into the REPL by explicitly passing `-` as a file name. You can do that in combination to giving a module or script file, so that you can then invoke its exports interactively, e.g.: ``` -wasm module.wast - +wasm module.wat - ``` See `wasm -h` for (the few) additional options. @@ -167,7 +167,7 @@ The implementation consumes a WebAssembly AST given in S-expression syntax. Here value: | var: | name: $( | | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+ -string: "( | \n | \t | \\ | \' | \" | \)*" +string: "( | \n | \t | \\ | \' | \" | \ | \u{+})*" type: i32 | i64 | f32 | f64 elem_type: anyfunc @@ -180,7 +180,7 @@ offset: offset= align: align=(1|2|4|8|...) cvtop: trunc_s | trunc_u | extend_s | extend_u | ... -block_sig : * +block_sig : ( result * )* func_sig: ( type )? * * global_sig: | ( mut ) table_sig: ? @@ -188,20 +188,19 @@ memory_sig: ? expr: ( ) - ( + ) ;; = + () - ( block ? ? * ) - ( loop ? ? * ) - ( if ? ? ( then * ) ( else * )? ) - ( if ? ? ( then * ) ( else * )? ) ;; = (if ? ? (then *) (else *)?) - ( if ? ? ? ) ;; = (if ? ? (then ) (else ?)) + ( + ) ;; = + () + ( block ? * ) + ( loop ? * ) + ( if ? ( then * ) ( else * )? ) + ( if ? + ( then * ) ( else * )? ) ;; = + (if ? (then *) (else *)?) instr: - ;; = () - block ? ? * end ? ;; = (block ? ? *) - loop ? ? * end ? ;; = (loop ? ? *) - if ? ? * end ? ;; = (if ? ? (then *)) - if ? ? * else ? * end ? ;; = (if ? ? (then *) (else *)) + ;; = () + block ? * end ? ;; = (block ? *) + loop ? * end ? ;; = (loop ? *) + if ? * end ? ;; = (if ? (then *)) + if ? * else ? * end ? ;; = (if ? (then *) (else *)) op: unreachable @@ -231,25 +230,25 @@ op: ./ func: ( func ? * * ) - ( func ? ( export ) * * ) ;; = (export (func )) (func ? * *) + ( func ? ( export )+ * * ) ;; = (export (func ))+ (func ? * *) ( func ? ( import ) ) ;; = (import ? (func )) param: ( param * ) | ( param ) result: ( result ) local: ( local * ) | ( local ) global: ( global ? * ) - ( global ? ( export ) * ) ;; = (export (global )) (global ? *) + ( global ? ( export )+ * ) ;; = (export (global ))+ (global ? *) ( global ? ( import ) ) ;; = (import ? (global )) table: ( table ? ) - ( table ? ( export ) ) ;; = (export (table )) (table ? ) + ( table ? ( export )+ ) ;; = (export (table ))+ (table ? ) ( table ? ( import ) ) ;; = (import ? (table )) - ( table ? ( export )? ( elem * ) ) ;; = (table ? ( export )? ) (elem (i32.const 0) *) + ( table ? ( export )* ( elem * ) ) ;; = (table ? ( export )* ) (elem (i32.const 0) *) elem: ( elem ? (offset * ) * ) ( elem ? * ) ;; = (elem ? (offset ) *) memory: ( memory ? ) - ( memory ? ( export ) ) ;; = (export (memory )) (memory ? ) + ( memory ? ( export )+ ) ;; = (export (memory ))+ (memory ? ) ( memory ? ( import ) ) ;; = (import ? (memory )) - ( memory ? ( export )? ( data * ) ;; = (memory ? ( export )? ) (data (i32.const 0) *) + ( memory ? ( export )* ( data * ) ;; = (memory ? ( export )* ) (data (i32.const 0) *) data: ( data ? ( offset * ) * ) ( data ? * ) ;; = (data ? (offset ) *) @@ -270,6 +269,8 @@ exkind: ( func ) module: ( module ? * * * * ? ? * * * ? ) ( module ? + ) + * * * *
? ? * * * ? ;; = + ( module * * * *
? ? * * * ? ) ``` Here, productions marked with respective comments are abbreviation forms for equivalent expansions (see the explanation of the AST below). @@ -283,6 +284,8 @@ A module of the form `(module +)` is given in binary form and will be de The segment strings in the memory field are used to initialize the consecutive memory at the given offset. The `` in the expansion of the two short-hand forms for `table` and `memory` is the minimal size that can hold the segment: the number of ``s for tables, and the accumulative length of the strings rounded up to page size for memories. +In addition to the grammar rules above, the fields of a module may appear in any order, except that all imports must occur before the first proper definition of a function, table, memory, or global. + Comments can be written in one of two ways: ``` @@ -336,7 +339,7 @@ After a module is _registered_ under a string name it is available for importing There are also a number of meta commands. The `script` command is a simple mechanism to name sub-scripts themselves. This is mainly useful for converting scripts with the `output` command. Commands inside a `script` will be executed normally, but nested meta are expanded in place (`input`, recursively) or elided (`output`) in the named script. -The `input` and `output` meta commands determine the requested file format from the file name extension. They can handle both `.wast` and `.wasm` files. In the case of input, a `.wast` script will be recursively executed. Output additionally handles `.js` as a target, which will convert the referenced script to an equivalent, self-contained JavaScript runner. It also recognises `.bin.wast` specially, which creates a script where module definitions are in binary. +The `input` and `output` meta commands determine the requested file format from the file name extension. They can handle both `.wasm`, `.wat`, and `.wast` files. In the case of input, a `.wast` script will be recursively executed. Output additionally handles `.js` as a target, which will convert the referenced script to an equivalent, self-contained JavaScript runner. It also recognises `.bin.wast` specially, which creates a script where module definitions are in binary. The interpreter supports a "dry" mode (flag `-d`), in which modules are only validated. In this mode, all actions and assertions are ignored. It also supports an "unchecked" mode (flag `-u`), in which module definitions are not validated before use. diff --git a/interpreter/host/import.ml b/interpreter/host/import.ml index 0e658dc002..5c7051be27 100644 --- a/interpreter/host/import.ml +++ b/interpreter/host/import.ml @@ -14,7 +14,7 @@ let lookup (m : module_) (im : import) : Instance.extern = let t = import_type m im in try Registry.find module_name !registry item_name t with Not_found -> Unknown.error im.at - ("unknown import \"" ^ String.escaped (Utf8.encode module_name) ^ - "\".\"" ^ String.escaped (Utf8.encode item_name) ^ "\"") + ("unknown import \"" ^ string_of_name module_name ^ + "\".\"" ^ string_of_name item_name ^ "\"") let link m = List.map (lookup m) m.it.imports diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml index 1d66dc18d9..4db32b7ad0 100644 --- a/interpreter/host/js.ml +++ b/interpreter/host/js.ml @@ -170,7 +170,7 @@ let lookup (mods : modules) x_opt name at = else "unknown module " ^ of_var_opt mods x_opt ^ " within script")) in try ExportMap.find name exports with Not_found -> raise (Eval.Crash (at, "unknown export \"" ^ - String.escaped (Utf8.encode name) ^ "\" within module")) + string_of_name name ^ "\" within module")) (* Wrappers *) @@ -278,17 +278,22 @@ let add_char buf c = if c = '\"' || c = '\\' then Buffer.add_char buf '\\'; Buffer.add_char buf c end - -let of_string_with add_char s = - let buf = Buffer.create (4 * String.length s + 2) in +let add_unicode_char buf uc = + if uc < 0x20 || uc >= 0x7f then + Printf.bprintf buf "\\u{%02x}" uc + else + add_char buf (Char.chr uc) + +let of_string_with iter add_char s = + let buf = Buffer.create 256 in Buffer.add_char buf '\"'; - String.iter (add_char buf) s; + iter (add_char buf) s; Buffer.add_char buf '\"'; Buffer.contents buf -let of_bytes = of_string_with add_hex_char -let of_string = of_string_with add_char -let of_name n = of_string (Utf8.encode n) +let of_bytes = of_string_with String.iter add_hex_char +let of_string = of_string_with String.iter add_char +let of_name = of_string_with List.iter add_unicode_char let of_float z = match string_of_float z with diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml index 1f7a9c22c7..6e7faa03bd 100644 --- a/interpreter/host/run.ml +++ b/interpreter/host/run.ml @@ -18,17 +18,20 @@ let trace name = if !Flags.trace then print_endline ("-- " ^ name) (* File types *) let binary_ext = "wasm" -let binary_sexpr_ext = "bin.wast" -let sexpr_ext = "wast" +let sexpr_ext = "wat" +let script_binary_ext = "bin.wast" +let script_ext = "wast" let js_ext = "js" -let dispatch_file_ext on_binary on_binary_sexpr on_sexpr on_js file = +let dispatch_file_ext on_binary on_sexpr on_script_binary on_script on_js file = if Filename.check_suffix file binary_ext then on_binary file - else if Filename.check_suffix file binary_sexpr_ext then - on_binary_sexpr file else if Filename.check_suffix file sexpr_ext then on_sexpr file + else if Filename.check_suffix file script_binary_ext then + on_script_binary file + else if Filename.check_suffix file script_ext then + on_script file else if Filename.check_suffix file js_ext then on_js file else @@ -47,7 +50,15 @@ let create_binary_file file _ get_module = close_out oc with exn -> close_out oc; raise exn -let create_sexpr_file mode file get_script _ = +let create_sexpr_file file _ get_module = + trace ("Writing (" ^ file ^ ")..."); + let oc = open_out file in + try + Print.module_ oc !Flags.width (get_module ()); + close_out oc + with exn -> close_out oc; raise exn + +let create_script_file mode file get_script _ = trace ("Writing (" ^ file ^ ")..."); let oc = open_out file in try @@ -68,8 +79,9 @@ let create_js_file file get_script _ = let output_file = dispatch_file_ext create_binary_file - (create_sexpr_file `Binary) - (create_sexpr_file `Textual) + create_sexpr_file + (create_script_file `Binary) + (create_script_file `Textual) create_js_file let output_stdout get_module = @@ -104,21 +116,26 @@ let input_from get_script run = | Assert (at, msg) -> error at "assertion failure" msg | Abort _ -> false -let input_sexpr name lexbuf start run = +let input_script start name lexbuf run = input_from (fun _ -> Parse.parse name lexbuf start) run +let input_sexpr name lexbuf run = + input_from (fun _ -> + let var_opt, def = Parse.parse name lexbuf Parse.Module in + [Module (var_opt, def) @@ no_region]) run + let input_binary name buf run = let open Source in input_from (fun _ -> [Module (None, Encoded (name, buf) @@ no_region) @@ no_region]) run -let input_sexpr_file file run = +let input_sexpr_file input file run = trace ("Loading (" ^ file ^ ")..."); let ic = open_in file in try let lexbuf = Lexing.from_channel ic in trace "Parsing..."; - let success = input_sexpr file lexbuf Parse.Script run in + let success = input file lexbuf run in close_in ic; success with exn -> close_in ic; raise exn @@ -142,8 +159,9 @@ let input_js_file file run = let input_file file run = dispatch_file_ext input_binary_file - input_sexpr_file - input_sexpr_file + (input_sexpr_file input_sexpr) + (input_sexpr_file (input_script Parse.Script)) + (input_sexpr_file (input_script Parse.Script)) input_js_file file run @@ -151,7 +169,7 @@ let input_string string run = trace ("Running (\"" ^ String.escaped string ^ "\")..."); let lexbuf = Lexing.from_string string in trace "Parsing..."; - input_sexpr "string" lexbuf Parse.Script run + input_script Parse.Script "string" lexbuf run (* Interactive *) @@ -175,7 +193,7 @@ let lexbuf_stdin buf len = let input_stdin run = let lexbuf = Lexing.from_function lexbuf_stdin in let rec loop () = - let success = input_sexpr "stdin" lexbuf Parse.Script1 run in + let success = input_script Parse.Script1 "stdin" lexbuf run in if not success then Lexing.flush_input lexbuf; if Lexing.(lexbuf.lex_curr_pos >= lexbuf.lex_buffer_len - 1) then continuing := false; @@ -188,8 +206,6 @@ let input_stdin run = (* Printing *) -let string_of_name n = String.escaped (Utf8.encode n) - let print_import m im = let open Types in let category, annotation = @@ -199,9 +215,9 @@ let print_import m im = | ExternalMemoryType t -> "memory", string_of_memory_type t | ExternalGlobalType t -> "global", string_of_global_type t in - Printf.printf " import %s %S %S : %s\n" - category (string_of_name im.it.Ast.module_name) - (string_of_name im.it.Ast.item_name) annotation + Printf.printf " import %s \"%s\" \"%s\" : %s\n" + category (Ast.string_of_name im.it.Ast.module_name) + (Ast.string_of_name im.it.Ast.item_name) annotation let print_export m ex = let open Types in @@ -212,8 +228,8 @@ let print_export m ex = | ExternalMemoryType t -> "memory", string_of_memory_type t | ExternalGlobalType t -> "global", string_of_global_type t in - Printf.printf " export %s %S : %s\n" - category (string_of_name ex.it.Ast.name) annotation + Printf.printf " export %s \"%s\" : %s\n" + category (Ast.string_of_name ex.it.Ast.name) annotation let print_module x_opt m = Printf.printf "module%s :\n" @@ -275,7 +291,7 @@ let run_definition def = let run_action act = match act.it with | Invoke (x_opt, name, vs) -> - trace ("Invoking function \"" ^ string_of_name name ^ "\"..."); + trace ("Invoking function \"" ^ Ast.string_of_name name ^ "\"..."); let inst = lookup_instance x_opt act.at in (match Instance.export inst name with | Some (Instance.ExternalFunc f) -> @@ -285,7 +301,7 @@ let run_action act = ) | Get (x_opt, name) -> - trace ("Getting global \"" ^ string_of_name name ^ "\"..."); + trace ("Getting global \"" ^ Ast.string_of_name name ^ "\"..."); let inst = lookup_instance x_opt act.at in (match Instance.export inst name with | Some (Instance.ExternalGlobal v) -> [v] @@ -425,7 +441,7 @@ let rec run_command cmd = | Register (name, x_opt) -> quote := cmd :: !quote; if not !Flags.dry then begin - trace ("Registering module \"" ^ string_of_name name ^ "\"..."); + trace ("Registering module \"" ^ Ast.string_of_name name ^ "\"..."); let inst = lookup_instance x_opt cmd.at in registry := Map.add (Utf8.encode name) inst !registry; Import.register name (lookup_registry (Utf8.encode name)) diff --git a/interpreter/spec/ast.ml b/interpreter/spec/ast.ml index 3604bbc1e7..1d427b2c48 100644 --- a/interpreter/spec/ast.ml +++ b/interpreter/spec/ast.ml @@ -236,3 +236,17 @@ let export_type (m : module_) (ex : export) : external_type = | GlobalExport x -> let gts = globals its @ List.map (fun g -> g.it.gtype) m.it.globals in ExternalGlobalType (nth gts x.it) + +let string_of_name n = + let b = Buffer.create 16 in + let escape uc = + if uc < 0x20 || uc >= 0x7f then + Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc) + else begin + let c = Char.chr uc in + if c = '\"' || c = '\\' then Buffer.add_char b '\\'; + Buffer.add_char b c + end + in + List.iter escape n; + Buffer.contents b diff --git a/interpreter/spec/float.ml b/interpreter/spec/float.ml index a2f2f007a6..25572bfc42 100644 --- a/interpreter/spec/float.ml +++ b/interpreter/spec/float.ml @@ -226,4 +226,3 @@ struct (* TODO: use sprintf "%h" once we have upgraded to OCaml 4.03 *) string_of_float (to_float a) end - diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml index 3eb2a0661f..b23c414203 100644 --- a/interpreter/text/arrange.ml +++ b/interpreter/text/arrange.ml @@ -19,17 +19,22 @@ let add_char buf c = if c = '\"' || c = '\\' then Buffer.add_char buf '\\'; Buffer.add_char buf c end - -let string_with add_char s = - let buf = Buffer.create (3 * String.length s + 2) in +let add_unicode_char buf uc = + if uc < 0x20 || uc >= 0x7f then + Printf.bprintf buf "\\u{%02x}" uc + else + add_char buf (Char.chr uc) + +let string_with iter add_char s = + let buf = Buffer.create 256 in Buffer.add_char buf '\"'; - String.iter (add_char buf) s; + iter (add_char buf) s; Buffer.add_char buf '\"'; Buffer.contents buf -let bytes = string_with add_hex_char -let string = string_with add_char -let name n = string (Utf8.encode n) +let bytes = string_with String.iter add_hex_char +let string = string_with String.iter add_char +let name = string_with List.iter add_unicode_char let list_of_opt = function None -> [] | Some x -> [x] @@ -53,7 +58,7 @@ let elem_type t = string_of_elem_type t let decls kind ts = tab kind (atom value_type) ts -let stack_type ts = list (atom value_type) ts +let stack_type ts = decls "result" ts let func_type (FuncType (ins, out)) = Node ("func", decls "param" ins @ decls "result" out) diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll index 70f4a9c34e..47584f4f9b 100644 --- a/interpreter/text/lexer.mll +++ b/interpreter/text/lexer.mll @@ -18,20 +18,28 @@ let error_nest start lexbuf msg = lexbuf.Lexing.lex_start_p <- start; error lexbuf msg -let text s = +let string s = let b = Buffer.create (String.length s) in let i = ref 1 in while !i < String.length s - 1 do let c = if s.[!i] <> '\\' then s.[!i] else match (incr i; s.[!i]) with | 'n' -> '\n' + | 'r' -> '\r' | 't' -> '\t' | '\\' -> '\\' | '\'' -> '\'' | '\"' -> '\"' - | d -> + | 'u' -> + let j = !i + 2 in + i := String.index_from s j '}'; + let n = int_of_string ("0x" ^ String.sub s j (!i - j)) in + let bs = Utf8.encode [n] in + Buffer.add_substring b bs 0 (String.length bs - 1); + bs.[String.length bs - 1] + | h -> incr i; - Char.chr (int_of_string ("0x" ^ String.make 1 d ^ String.make 1 s.[!i])) + Char.chr (int_of_string ("0x" ^ String.make 1 h ^ String.make 1 s.[!i])) in Buffer.add_char b c; incr i done; @@ -80,31 +88,52 @@ let ext e s u = let opt = Lib.Option.get } -let space = [' ''\t'] +let sign = '+' | '-' let digit = ['0'-'9'] let hexdigit = ['0'-'9''a'-'f''A'-'F'] +let num = digit+ +let hexnum = hexdigit+ + let letter = ['a'-'z''A'-'Z'] -let symbol = ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.'] -let tick = '\'' -let escape = ['n''t''\\''\'''\"'] +let symbol = + ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.''\''] + +let space = [' ''\t''\n''\r'] +let ascii = ['\x00'-'\x7f'] +let ascii_no_nl = ['\x00'-'\x09''\x0b'-'\x7f'] +let utf8cont = ['\x80'-'\xbf'] +let utf8enc = + ['\xc2'-'\xdf'] utf8cont + | ['\xe0'] ['\xa0'-'\xbf'] utf8cont + | ['\xed'] ['\x80'-'\x9f'] utf8cont + | ['\xe1'-'\xec''\xee'-'\xef'] utf8cont utf8cont + | ['\xf0'] ['\x90'-'\xbf'] utf8cont utf8cont + | ['\xf4'] ['\x80'-'\x8f'] utf8cont utf8cont + | ['\xf1'-'\xf3'] utf8cont utf8cont utf8cont +let utf8 = ascii | utf8enc +let utf8_no_nl = ascii_no_nl | utf8enc + +let escape = ['n''r''t''\\''\'''\"'] let character = - [^'"''\\''\x00'-'\x1f''\x7f'] | '\\'escape | '\\'hexdigit hexdigit + [^'"''\\''\x00'-'\x1f''\x7f'-'\xff'] + | utf8enc + | '\\'escape + | '\\'hexdigit hexdigit + | "\\u{" hexnum '}' -let sign = ('+' | '-') -let num = digit+ -let hexnum = "0x" hexdigit+ -let nat = num | hexnum +let nat = num | "0x" hexnum let int = sign nat let float = sign? num '.' digit* | sign? num ('.' digit*)? ('e' | 'E') sign? num - | sign? "0x" hexdigit+ '.'? hexdigit* ('e' | 'E' | 'p') sign? digit+ + | sign? "0x" hexnum '.' hexdigit* + | sign? "0x" hexnum ('.' hexdigit*)? ('p' | 'P') sign? num | sign? "inf" - | sign? "infinity" | sign? "nan" - | sign? "nan:0x" hexdigit+ -let text = '"' character* '"' -let name = '$' (letter | digit | '_' | tick | symbol)+ + | sign? "nan:" "0x" hexnum +let string = '"' character* '"' +let name = '$' (letter | digit | '_' | symbol)+ +let reserved = ([^'\"''('')'';'] # space)+ (* hack for table size *) let ixx = "i" ("32" | "64") let fxx = "f" ("32" | "64") @@ -117,13 +146,15 @@ let mem_size = "8" | "16" | "32" rule token = parse | "(" { LPAR } | ")" { RPAR } + | nat as s { NAT s } | int as s { INT s } | float as s { FLOAT s } - | text as s { TEXT (text s) } - | '"'character*('\n'|eof) { error lexbuf "unclosed text literal" } + + | string as s { STRING (string s) } + | '"'character*('\n'|eof) { error lexbuf "unclosed string literal" } | '"'character*['\x00'-'\x09''\x0b'-'\x1f''\x7f'] - { error lexbuf "illegal control character in text literal" } + { error lexbuf "illegal control character in string literal" } | '"'character*'\\'_ { error_nest (Lexing.lexeme_end_p lexbuf) lexbuf "illegal escape" } @@ -317,17 +348,22 @@ rule token = parse | name as s { VAR s } - | ";;"[^'\n']*eof { EOF } - | ";;"[^'\n']*'\n' { Lexing.new_line lexbuf; token lexbuf } + | ";;"utf8_no_nl*eof { EOF } + | ";;"utf8_no_nl*'\n' { Lexing.new_line lexbuf; token lexbuf } + | ";;"utf8_no_nl* { token lexbuf (* causes error on following position *) } | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; token lexbuf } - | space { token lexbuf } + | space#'\n' { token lexbuf } | '\n' { Lexing.new_line lexbuf; token lexbuf } | eof { EOF } - | _ { error lexbuf "unknown operator" } + + | reserved { error lexbuf "unknown operator" } + | utf8 { error lexbuf "malformed operator" } + | _ { error lexbuf "malformed UTF-8 encoding" } and comment start = parse | ";)" { () } | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf } | '\n' { Lexing.new_line lexbuf; comment start lexbuf } | eof { error_nest start lexbuf "unclosed comment" } - | _ { comment start lexbuf } + | utf8 { comment start lexbuf } + | _ { error lexbuf "malformed UTF-8 encoding" } diff --git a/interpreter/text/parse.ml b/interpreter/text/parse.ml index f0be33701c..71c4cc4a9c 100644 --- a/interpreter/text/parse.ml +++ b/interpreter/text/parse.ml @@ -1,5 +1,5 @@ type 'a start = - | Module : Script.definition start + | Module : (Script.var option * Script.definition) start | Script : Script.script start | Script1 : Script.script start @@ -25,4 +25,4 @@ let string_to start s = parse "string" lexbuf start let string_to_script s = string_to Script s -let string_to_module s = string_to Module s +let string_to_module s = snd (string_to Module s) diff --git a/interpreter/text/parse.mli b/interpreter/text/parse.mli index 46e7e67c63..4530edfaed 100644 --- a/interpreter/text/parse.mli +++ b/interpreter/text/parse.mli @@ -1,5 +1,5 @@ type 'a start = - | Module : Script.definition start + | Module : (Script.var option * Script.definition) start | Script : Script.script start | Script1 : Script.script start diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly index 31db274ebd..417ff82981 100644 --- a/interpreter/text/parser.mly +++ b/interpreter/text/parser.mly @@ -137,25 +137,25 @@ let anon_label (c : context) = let empty_type = FuncType ([], []) -let explicit_sig (c : context) var_sem ty at = - let x = var_sem c type_ in - if - x.it < Lib.List32.length c.types.tlist && - ty <> empty_type && - ty <> Lib.List32.nth c.types.tlist x.it - then - error at "signature mismatch"; - x - let inline_type (c : context) ty at = match Lib.List.index_of ty c.types.tlist with | Some i -> Int32.of_int i @@ at | None -> let i = Lib.List32.length c.types.tlist in ignore (anon_type c ty); i @@ at +let inline_type_explicit (c : context) x ty at = + if + ty <> empty_type && + (x.it >= Lib.List32.length c.types.tlist || + ty <> Lib.List32.nth c.types.tlist x.it) + then + error at "inline function type does not match explicit type" + else + x + %} -%token NAT INT FLOAT TEXT VAR VALUE_TYPE ANYFUNC MUT LPAR RPAR +%token NAT INT FLOAT STRING VAR VALUE_TYPE ANYFUNC MUT LPAR RPAR %token NOP DROP BLOCK END IF THEN ELSE SELECT LOOP BR BR_IF BR_TABLE %token CALL CALL_INDIRECT RETURN %token GET_LOCAL SET_LOCAL TEE_LOCAL GET_GLOBAL SET_GLOBAL @@ -173,7 +173,7 @@ let inline_type (c : context) ty at = %token NAT %token INT %token FLOAT -%token TEXT +%token STRING %token VAR %token VALUE_TYPE %token Ast.instr' * Values.value> CONST @@ -193,18 +193,18 @@ let inline_type (c : context) ty at = %start script script1 module1 %type script %type script1 -%type module1 +%type module1 %% /* Auxiliaries */ name : - | TEXT { name $1 (at ()) } + | STRING { name $1 (at ()) } -text_list : +string_list : | /* empty */ { "" } - | text_list TEXT { $1 ^ $2 } + | string_list STRING { $1 ^ $2 } /* Types */ @@ -346,45 +346,48 @@ block_instr : { fun c -> let c' = $2 c ($5 @ $8) in let ts, es1 = $3 c' in if_ ts es1 ($6 c') } +block_sig : + | LPAR RESULT value_type_list RPAR { $3 } + block : - | value_type_list instr_list { fun c -> $1, $2 c } + | block_sig block + { fun c -> let ts, es = $2 c in $1 @ ts, es } + | instr_list { fun c -> [], $1 c } expr : /* Sugar */ | LPAR expr1 RPAR { let at = at () in fun c -> let es, e' = $2 c in es @ [e' @@ at] } expr1 : /* Sugar */ - | plain_instr expr_list { fun c -> snd ($2 c), $1 c } + | plain_instr expr_list { fun c -> $2 c, $1 c } | BLOCK labeling_opt block { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], block ts es } | LOOP labeling_opt block { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], loop ts es } - | IF labeling_opt value_type_list if_ + | IF labeling_opt if_block { fun c -> let c' = $2 c [] in - let es, es1, es2 = $4 c c' in es, if_ $3 es1 es2 } + let ts, (es, es1, es2) = $3 c c' in es, if_ ts es1 es2 } + +if_block : + | block_sig if_block { fun c c' -> let ts, ess = $2 c c' in $1 @ ts, ess } + | if_ { fun c c' -> [], $1 c c' } if_ : - | LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR + | expr if_ + { fun c c' -> let es = $1 c in let es0, es1, es2 = $2 c c' in + es @ es0, es1, es2 } + | LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR /* Sugar */ { fun c c' -> [], $3 c', $7 c' } | LPAR THEN instr_list RPAR /* Sugar */ { fun c c' -> [], $3 c', [] } - | expr LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR /* Sugar */ - { fun c c' -> $1 c, $4 c', $8 c' } - | expr LPAR THEN instr_list RPAR /* Sugar */ - { fun c c' -> $1 c, $4 c', [] } - | expr expr expr /* Sugar */ - { fun c c' -> $1 c, $2 c', $3 c' } - | expr expr /* Sugar */ - { fun c c' -> $1 c, $2 c', [] } instr_list : | /* empty */ { fun c -> [] } | instr instr_list { fun c -> $1 c @ $2 c } expr_list : - | /* empty */ { fun c -> 0, [] } - | expr expr_list - { fun c -> let es1 = $1 c and n, es2 = $2 c in n + 1, es1 @ es2 } + | /* empty */ { fun c -> [] } + | expr expr_list { fun c -> $1 c @ $2 c } const_expr : | instr_list { let at = at () in fun c -> $1 c @@ at } @@ -392,63 +395,68 @@ const_expr : /* Functions */ +func : + | LPAR FUNC bind_var_opt func_fields RPAR + { let at = at () in + fun c -> let x = $3 c anon_func bind_func @@ at in $4 c x at } + func_fields : - | func_body { $1 } + | type_use func_fields_body + { fun c x at -> + let t = inline_type_explicit c ($1 c type_) (fst $2) at in + (fun () -> [{(snd $2 (enter_func c)) with ftype = t} @@ at]), [], [] } + | func_fields_body /* Sugar */ + { fun c x at -> + let t = inline_type c (fst $1) at in + (fun () -> [{(snd $1 (enter_func c)) with ftype = t} @@ at]), [], [] } + | inline_import type_use func_fields_import /* Sugar */ + { fun c x at -> + let t = inline_type_explicit c ($2 c type_) $3 at in + (fun () -> []), + [{ module_name = fst $1; item_name = snd $1; + idesc = FuncImport t @@ at } @@ at ], [] } + | inline_import func_fields_import /* Sugar */ + { fun c x at -> + let t = inline_type c $2 at in + (fun () -> []), + [{ module_name = fst $1; item_name = snd $1; + idesc = FuncImport t @@ at } @@ at ], [] } + | inline_export func_fields /* Sugar */ + { fun c x at -> + let fns, ims, exs = $2 c x at in fns, ims, $1 (FuncExport x) c :: exs } + +func_fields_import : /* Sugar */ + | /* empty */ { empty_type } + | LPAR RESULT value_type_list RPAR + { FuncType ([], $3) } + | LPAR PARAM value_type_list RPAR func_fields_import + { let FuncType (ins, out) = $5 in FuncType ($3 @ ins, out) } + | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields_import /* Sugar */ + { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) } + +func_fields_body : + | func_body { empty_type, $1 } | LPAR RESULT value_type_list RPAR func_body - { let FuncType (ins, out) = fst $5 in - FuncType (ins, $3 @ out), fun c -> snd $5 c } - | LPAR PARAM value_type_list RPAR func_fields + { FuncType ([], $3), $5 } + | LPAR PARAM value_type_list RPAR func_fields_body { let FuncType (ins, out) = fst $5 in FuncType ($3 @ ins, out), - fun c -> ignore (anon_locals c $3); (snd $5) c } - | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields /* Sugar */ + fun c -> ignore (anon_locals c $3); snd $5 c } + | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields_body /* Sugar */ { let FuncType (ins, out) = fst $6 in FuncType ($4 :: ins, out), - fun c -> ignore (bind_local c $3); (snd $6) c } + fun c -> ignore (bind_local c $3); snd $6 c } func_body : | instr_list - { empty_type, - fun c -> let c' = anon_label c in + { fun c -> let c' = anon_label c in {ftype = -1l @@ at(); locals = []; body = $1 c'} } | LPAR LOCAL value_type_list RPAR func_body - { fst $5, - fun c -> ignore (anon_locals c $3); let f = (snd $5) c in - {f with locals = $3 @ f.locals} } + { fun c -> ignore (anon_locals c $3); let f = $5 c in + {f with locals = $3 @ f.locals} } | LPAR LOCAL bind_var VALUE_TYPE RPAR func_body /* Sugar */ - { fst $6, - fun c -> ignore (bind_local c $3); let f = (snd $6) c in - {f with locals = $4 :: f.locals} } - -func : - | LPAR FUNC bind_var_opt inline_export type_use func_fields RPAR - { let at = at () in - fun c -> - let x = $3 c anon_func bind_func @@ at in - let t = explicit_sig c $5 (fst $6) at in - (fun () -> {(snd $6 (enter_func c)) with ftype = t} @@ at), - $4 (FuncExport x) c } - /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */ - | LPAR FUNC bind_var_opt type_use func_fields RPAR - { let at = at () in - fun c -> ignore ($3 c anon_func bind_func); - let t = explicit_sig c $4 (fst $5) at in - (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at), - [] } - | LPAR FUNC bind_var_opt inline_export func_fields RPAR /* Sugar */ - { let at = at () in - fun c -> - let x = $3 c anon_func bind_func @@ at in - let t = inline_type c (fst $5) at in - (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at), - $4 (FuncExport x) c } - /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */ - | LPAR FUNC bind_var_opt func_fields RPAR /* Sugar */ - { let at = at () in - fun c -> ignore ($3 c anon_func bind_func); - let t = inline_type c (fst $4) at in - (fun () -> {(snd $4 (enter_func c)) with ftype = t} @@ at), - [] } + { fun c -> ignore (bind_local c $3); let f = $6 c in + {f with locals = $4 :: f.locals} } /* Tables, Memories & Globals */ @@ -466,63 +474,79 @@ elem : fun c -> {index = 0l @@ at; offset = $3 c; init = $4 c func} @@ at } table : - | LPAR TABLE bind_var_opt inline_export_opt table_sig RPAR + | LPAR TABLE bind_var_opt table_fields RPAR { let at = at () in fun c -> let x = $3 c anon_table bind_table @@ at in - fun () -> {ttype = $5} @@ at, [], $4 (TableExport x) c } - | LPAR TABLE bind_var_opt inline_export_opt elem_type - LPAR ELEM var_list RPAR RPAR /* Sugar */ - { let at = at () in - fun c -> let x = $3 c anon_table bind_table @@ at in - fun () -> - let init = $8 c func in let size = Int32.of_int (List.length init) in - {ttype = TableType ({min = size; max = Some size}, $5)} @@ at, + fun () -> $4 c x at } + +table_fields : + | table_sig + { fun c x at -> [{ttype = $1} @@ at], [], [], [] } + | inline_import table_sig + { fun c x at -> + [], [], + [{ module_name = fst $1; item_name = snd $1; + idesc = TableImport $2 @@ at } @@ at], [] } + | inline_export table_fields /* Sugar */ + { fun c x at -> let tabs, elems, ims, exs = $2 c x at in + tabs, elems, ims, $1 (TableExport x) c :: exs } + | elem_type LPAR ELEM var_list RPAR /* Sugar */ + { fun c x at -> + let init = $4 c func in let size = Int32.of_int (List.length init) in + [{ttype = TableType ({min = size; max = Some size}, $1)} @@ at], [{index = x; offset = [i32_const (0l @@ at) @@ at] @@ at; init} @@ at], - $4 (TableExport x) c } + [], [] } data : - | LPAR DATA var offset text_list RPAR + | LPAR DATA var offset string_list RPAR { let at = at () in fun c -> {index = $3 c memory; offset = $4 c; init = $5} @@ at } - | LPAR DATA offset text_list RPAR /* Sugar */ + | LPAR DATA offset string_list RPAR /* Sugar */ { let at = at () in fun c -> {index = 0l @@ at; offset = $3 c; init = $4} @@ at } memory : - | LPAR MEMORY bind_var_opt inline_export_opt memory_sig RPAR - { let at = at () in - fun c -> let x = $3 c anon_memory bind_memory @@ at in - {mtype = $5} @@ at, [], $4 (MemoryExport x) c } - | LPAR MEMORY bind_var_opt inline_export LPAR DATA text_list RPAR RPAR - /* Sugar */ - { let at = at () in - fun c -> let x = $3 c anon_memory bind_memory @@ at in - let size = Int32.(div (add (of_int (String.length $7)) 65535l) 65536l) in - {mtype = MemoryType {min = size; max = Some size}} @@ at, - [{index = x; - offset = [i32_const (0l @@ at) @@ at] @@ at; init = $7} @@ at], - $4 (MemoryExport x) c } - /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */ - | LPAR MEMORY bind_var_opt LPAR DATA text_list RPAR RPAR /* Sugar */ + | LPAR MEMORY bind_var_opt memory_fields RPAR { let at = at () in fun c -> let x = $3 c anon_memory bind_memory @@ at in - let size = Int32.(div (add (of_int (String.length $6)) 65535l) 65536l) in - {mtype = MemoryType {min = size; max = Some size}} @@ at, + fun () -> $4 c x at } + +memory_fields : + | memory_sig + { fun c x at -> [{mtype = $1} @@ at], [], [], [] } + | inline_import memory_sig + { fun c x at -> + [], [], + [{ module_name = fst $1; item_name = snd $1; + idesc = MemoryImport $2 @@ at } @@ at], [] } + | inline_export memory_fields /* Sugar */ + { fun c x at -> let mems, data, ims, exs = $2 c x at in + mems, data, ims, $1 (MemoryExport x) c :: exs } + | LPAR DATA string_list RPAR /* Sugar */ + { fun c x at -> + let size = Int32.(div (add (of_int (String.length $3)) 65535l) 65536l) in + [{mtype = MemoryType {min = size; max = Some size}} @@ at], [{index = x; - offset = [i32_const (0l @@ at) @@ at] @@ at; init = $6} @@ at], - [] } + offset = [i32_const (0l @@ at) @@ at] @@ at; init = $3} @@ at], + [], [] } global : - | LPAR GLOBAL bind_var_opt inline_export global_type const_expr RPAR + | LPAR GLOBAL bind_var_opt global_fields RPAR { let at = at () in fun c -> let x = $3 c anon_global bind_global @@ at in - (fun () -> {gtype = $5; value = $6 c} @@ at), - $4 (GlobalExport x) c } - /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */ - | LPAR GLOBAL bind_var_opt global_type const_expr RPAR - { let at = at () in - fun c -> ignore ($3 c anon_global bind_global); - (fun () -> {gtype = $4; value = $5 c} @@ at), [] } + fun () -> $4 c x at } + +global_fields : + | global_type const_expr + { fun c x at -> [{gtype = $1; value = $2 c} @@ at], [], [] } + | inline_import global_type + { fun c x at -> + [], + [{ module_name = fst $1; item_name = snd $1; + idesc = GlobalImport $2 @@ at } @@ at], [] } + | inline_export global_fields /* Sugar */ + { fun c x at -> let globs, ims, exs = $2 c x at in + globs, ims, $1 (GlobalExport x) c :: exs } /* Imports & Exports */ @@ -546,31 +570,6 @@ import : | LPAR IMPORT name name import_desc RPAR { let at = at () and at5 = ati 5 in fun c -> {module_name = $3; item_name = $4; idesc = $5 c @@ at5} @@ at } - | LPAR FUNC bind_var_opt inline_import type_use RPAR /* Sugar */ - { let at = at () in - fun c -> ignore ($3 c anon_func bind_func); - { module_name = fst $4; item_name = snd $4; - idesc = FuncImport ($5 c type_) @@ at } @@ at } - | LPAR FUNC bind_var_opt inline_import func_sig RPAR /* Sugar */ - { let at = at () and at5 = ati 5 in - fun c -> ignore ($3 c anon_func bind_func); - { module_name = fst $4; item_name = snd $4; - idesc = FuncImport (inline_type c $5 at5) @@ at } @@ at } - | LPAR TABLE bind_var_opt inline_import table_sig RPAR /* Sugar */ - { let at = at () in - fun c -> ignore ($3 c anon_table bind_table); - { module_name = fst $4; item_name = snd $4; - idesc = TableImport $5 @@ at } @@ at } - | LPAR MEMORY bind_var_opt inline_import memory_sig RPAR /* Sugar */ - { let at = at () in - fun c -> ignore ($3 c anon_memory bind_memory); - { module_name = fst $4; item_name = snd $4; - idesc = MemoryImport $5 @@ at } @@ at } - | LPAR GLOBAL bind_var_opt inline_import global_type RPAR /* Sugar */ - { let at = at () in - fun c -> ignore ($3 c anon_global bind_global); - { module_name = fst $4; item_name = snd $4; - idesc = GlobalImport $5 @@ at } @@ at } inline_import : | LPAR IMPORT name name RPAR { $3, $4 } @@ -586,13 +585,9 @@ export : { let at = at () and at4 = ati 4 in fun c -> {name = $3; edesc = $4 c @@ at4} @@ at } -inline_export_opt : - | /* empty */ { fun d c -> [] } - | inline_export { $1 } - inline_export : | LPAR EXPORT name RPAR - { let at = at () in fun d c -> [{name = $3; edesc = d @@ at} @@ at] } + { let at = at () in fun d c -> {name = $3; edesc = d @@ at} @@ at } /* Modules */ @@ -610,28 +605,38 @@ start : module_fields : | /* empty */ { fun (c : context) -> {empty_module with types = c.types.tlist} } + | module_fields1 { $1 } + +module_fields1 : | type_def module_fields { fun c -> $1 c; $2 c } | global module_fields - { fun c -> let g, exs = $1 c in let m = $2 c in - if m.imports <> [] then + { fun c -> let gf = $1 c in let m = $2 c in + let globs, ims, exs = gf () in + if globs <> [] && m.imports <> [] then error (List.hd m.imports).at "import after global definition"; - {m with globals = g () :: m.globals; exports = exs @ m.exports} } + { m with globals = globs @ m.globals; + imports = ims @ m.imports; exports = exs @ m.exports } } | table module_fields - { fun c -> let t = $1 c in let m = $2 c in let tab, elems, exs = t () in - if m.imports <> [] then + { fun c -> let tf = $1 c in let m = $2 c in + let tabs, elems, ims, exs = tf () in + if tabs <> [] && m.imports <> [] then error (List.hd m.imports).at "import after table definition"; - {m with tables = tab :: m.tables; elems = elems @ m.elems; exports = exs @ m.exports} } + { m with tables = tabs @ m.tables; elems = elems @ m.elems; + imports = ims @ m.imports; exports = exs @ m.exports } } | memory module_fields - { fun c -> let mem, data, exs = $1 c in let m = $2 c in - if m.imports <> [] then + { fun c -> let mf = $1 c in let m = $2 c in + let mems, data, ims, exs = mf () in + if mems <> [] && m.imports <> [] then error (List.hd m.imports).at "import after memory definition"; - {m with memories = mem :: m.memories; data = data @ m.data; exports = exs @ m.exports} } + { m with memories = mems @ m.memories; data = data @ m.data; + imports = ims @ m.imports; exports = exs @ m.exports } } | func module_fields - { fun c -> let f, exs = $1 c in let m = $2 c in let func = f () in - if m.imports <> [] then + { fun c -> let ff, ims, exs = $1 c in let m = $2 c in let funcs = ff () in + if funcs <> [] && m.imports <> [] then error (List.hd m.imports).at "import after function definition"; - {m with funcs = func :: m.funcs; exports = exs @ m.exports} } + { m with funcs = funcs @ m.funcs; + imports = ims @ m.imports; exports = exs @ m.exports } } | elem module_fields { fun c -> let m = $2 c in {m with elems = $1 c :: m.elems} } @@ -653,9 +658,15 @@ module_fields : module_ : | LPAR MODULE script_var_opt module_fields RPAR { $3, Textual ($4 (empty_context ()) @@ at ()) @@ at () } - | LPAR MODULE script_var_opt TEXT text_list RPAR + | LPAR MODULE script_var_opt STRING string_list RPAR { $3, Encoded ("binary", $4 ^ $5) @@ at() } +inline_module : /* Sugar */ + | module_fields { Textual ($1 (empty_context ()) @@ at ()) @@ at () } + +inline_module1 : /* Sugar */ + | module_fields1 { Textual ($1 (empty_context ()) @@ at ()) @@ at () } + /* Scripts */ @@ -670,19 +681,19 @@ action : { Get ($3, $4) @@ at() } assertion : - | LPAR ASSERT_MALFORMED module_ TEXT RPAR + | LPAR ASSERT_MALFORMED module_ STRING RPAR { AssertMalformed (snd $3, $4) @@ at () } - | LPAR ASSERT_INVALID module_ TEXT RPAR + | LPAR ASSERT_INVALID module_ STRING RPAR { AssertInvalid (snd $3, $4) @@ at () } - | LPAR ASSERT_UNLINKABLE module_ TEXT RPAR + | LPAR ASSERT_UNLINKABLE module_ STRING RPAR { AssertUnlinkable (snd $3, $4) @@ at () } - | LPAR ASSERT_TRAP module_ TEXT RPAR + | LPAR ASSERT_TRAP module_ STRING RPAR { AssertUninstantiable (snd $3, $4) @@ at () } | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () } | LPAR ASSERT_RETURN_CANONICAL_NAN action RPAR { AssertReturnCanonicalNaN $3 @@ at () } | LPAR ASSERT_RETURN_ARITHMETIC_NAN action RPAR { AssertReturnArithmeticNaN $3 @@ at () } - | LPAR ASSERT_TRAP action TEXT RPAR { AssertTrap ($3, $4) @@ at () } - | LPAR ASSERT_EXHAUSTION action TEXT RPAR { AssertExhaustion ($3, $4) @@ at () } + | LPAR ASSERT_TRAP action STRING RPAR { AssertTrap ($3, $4) @@ at () } + | LPAR ASSERT_EXHAUSTION action STRING RPAR { AssertExhaustion ($3, $4) @@ at () } cmd : | action { Action $1 @@ at () } @@ -697,8 +708,8 @@ cmd_list : meta : | LPAR SCRIPT script_var_opt cmd_list RPAR { Script ($3, $4) @@ at () } - | LPAR INPUT script_var_opt TEXT RPAR { Input ($3, $4) @@ at () } - | LPAR OUTPUT script_var_opt TEXT RPAR { Output ($3, Some $4) @@ at () } + | LPAR INPUT script_var_opt STRING RPAR { Input ($3, $4) @@ at () } + | LPAR OUTPUT script_var_opt STRING RPAR { Output ($3, Some $4) @@ at () } | LPAR OUTPUT script_var_opt RPAR { Output ($3, None) @@ at () } const : @@ -710,10 +721,12 @@ const_list : script : | cmd_list EOF { $1 } + | inline_module1 EOF { [Module (None, $1) @@ at ()] } /* Sugar */ script1 : | cmd { [$1] } module1 : - | module_ EOF { snd $1 } + | module_ EOF { $1 } + | inline_module EOF { None, $1 } /* Sugar */ %% diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml index 5140774952..818e025ed0 100644 --- a/interpreter/util/lib.ml +++ b/interpreter/util/lib.ml @@ -19,7 +19,7 @@ end module String = struct let implode cs = - let buf = Buffer.create (List.length cs) in + let buf = Buffer.create 80 in List.iter (Buffer.add_char buf) cs; Buffer.contents buf diff --git a/test/core/block.wast b/test/core/block.wast index cb7935c556..7d51859ca4 100644 --- a/test/core/block.wast +++ b/test/core/block.wast @@ -11,53 +11,79 @@ (func (export "singular") (result i32) (block (nop)) - (block i32 (i32.const 7)) + (block (result i32) (i32.const 7)) ) (func (export "multi") (result i32) (block (call $dummy) (call $dummy) (call $dummy) (call $dummy)) - (block i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8)) + (block (result i32) (call $dummy) (call $dummy) (call $dummy) (i32.const 8)) ) (func (export "nested") (result i32) - (block i32 + (block (result i32) (block (call $dummy) (block) (nop)) - (block i32 (call $dummy) (i32.const 9)) + (block (result i32) (call $dummy) (i32.const 9)) ) ) (func (export "deep") (result i32) - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (block i32 (block i32 (block i32 (block i32 - (block i32 (block i32 (call $dummy) (i32.const 150))) - )))))) - )))))) - )))))) - )))))) - )))))) - )))))) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (call $dummy) (i32.const 150) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) ) (func (export "as-unary-operand") (result i32) - (i32.ctz (block i32 (call $dummy) (i32.const 13))) + (i32.ctz (block (result i32) (call $dummy) (i32.const 13))) ) (func (export "as-binary-operand") (result i32) (i32.mul - (block i32 (call $dummy) (i32.const 3)) - (block i32 (call $dummy) (i32.const 4)) + (block (result i32) (call $dummy) (i32.const 3)) + (block (result i32) (call $dummy) (i32.const 4)) ) ) (func (export "as-test-operand") (result i32) - (i32.eqz (block i32 (call $dummy) (i32.const 13))) + (i32.eqz (block (result i32) (call $dummy) (i32.const 13))) ) (func (export "as-compare-operand") (result i32) (f32.gt - (block f32 (call $dummy) (f32.const 3)) - (block f32 (call $dummy) (f32.const 3)) + (block (result f32) (call $dummy) (f32.const 3)) + (block (result f32) (call $dummy) (f32.const 3)) ) ) @@ -69,10 +95,10 @@ (i32.const 19) ) (func (export "break-value") (result i32) - (block i32 (br 0 (i32.const 18)) (i32.const 19)) + (block (result i32) (br 0 (i32.const 18)) (i32.const 19)) ) (func (export "break-repeated") (result i32) - (block i32 + (block (result i32) (br 0 (i32.const 18)) (br 0 (i32.const 19)) (drop (br_if 0 (i32.const 20) (i32.const 0))) @@ -86,13 +112,13 @@ (func (export "break-inner") (result i32) (local i32) (set_local 0 (i32.const 0)) - (set_local 0 (i32.add (get_local 0) (block i32 (block i32 (br 1 (i32.const 0x1)))))) - (set_local 0 (i32.add (get_local 0) (block i32 (block (br 0)) (i32.const 0x2)))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1)))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (block (br 0)) (i32.const 0x2)))) (set_local 0 - (i32.add (get_local 0) (block i32 (i32.ctz (br 0 (i32.const 0x4))))) + (i32.add (get_local 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4))))) ) (set_local 0 - (i32.add (get_local 0) (block i32 (i32.ctz (block i32 (br 1 (i32.const 0x8)))))) + (i32.add (get_local 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8)))))) ) (get_local 0) ) @@ -154,89 +180,91 @@ ) (assert_invalid (module (func $type-value-empty-vs-num (result i32) - (block i32) + (block (result i32)) )) "type mismatch" ) (assert_invalid (module (func $type-value-void-vs-num (result i32) - (block i32 (nop)) + (block (result i32) (nop)) )) "type mismatch" ) (assert_invalid (module (func $type-value-num-vs-num (result i32) - (block i32 (f32.const 0)) + (block (result i32) (f32.const 0)) )) "type mismatch" ) (assert_invalid (module (func $type-value-unreached-select (result i32) - (block i64 (select (unreachable) (unreachable) (unreachable))) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) )) "type mismatch" ) (assert_invalid (module (func $type-break-last-void-vs-num (result i32) - (block i32 (br 0)) + (block (result i32) (br 0)) )) "type mismatch" ) (assert_invalid (module (func $type-break-empty-vs-num (result i32) - (block i32 (br 0) (i32.const 1)) + (block (result i32) (br 0) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-break-void-vs-num (result i32) - (block i32 (br 0 (nop)) (i32.const 1)) + (block (result i32) (br 0 (nop)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-break-num-vs-num (result i32) - (block i32 (br 0 (i64.const 1)) (i32.const 1)) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-break-first-void-vs-num (result i32) - (block i32 (br 0 (nop)) (br 0 (i32.const 1))) + (block (result i32) (br 0 (nop)) (br 0 (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-break-first-num-vs-num (result i32) - (block i32 (br 0 (i64.const 1)) (br 0 (i32.const 1))) + (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-break-nested-num-vs-void - (block i32 (block i32 (br 1 (i32.const 1))) (br 0)) + (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0)) )) "type mismatch" ) (assert_invalid (module (func $type-break-nested-empty-vs-num (result i32) - (block i32 (block (br 1)) (br 0 (i32.const 1))) + (block (result i32) (block (br 1)) (br 0 (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-break-nested-void-vs-num (result i32) - (block i32 (block i32 (br 1 (nop))) (br 0 (i32.const 1))) + (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-break-nested-num-vs-num (result i32) - (block i32 (block i32 (br 1 (i64.const 1))) (br 0 (i32.const 1))) + (block (result i32) + (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1)) + ) )) "type mismatch" ) diff --git a/test/core/br.wast b/test/core/br.wast index 8d1c7e1034..77f781d4de 100644 --- a/test/core/br.wast +++ b/test/core/br.wast @@ -10,16 +10,16 @@ (func (export "type-f64") (block (drop (f64.neg (br 0))))) (func (export "type-i32-value") (result i32) - (block i32 (i32.ctz (br 0 (i32.const 1)))) + (block (result i32) (i32.ctz (br 0 (i32.const 1)))) ) (func (export "type-i64-value") (result i64) - (block i64 (i64.ctz (br 0 (i64.const 2)))) + (block (result i64) (i64.ctz (br 0 (i64.const 2)))) ) (func (export "type-f32-value") (result f32) - (block f32 (f32.neg (br 0 (f32.const 3)))) + (block (result f32) (f32.neg (br 0 (f32.const 3)))) ) (func (export "type-f64-value") (result f64) - (block f64 (f64.neg (br 0 (f64.const 4)))) + (block (result f64) (f64.neg (br 0 (f64.const 4)))) ) (func (export "as-block-first") @@ -32,33 +32,37 @@ (block (nop) (call $dummy) (br 0)) ) (func (export "as-block-value") (result i32) - (block i32 (nop) (call $dummy) (br 0 (i32.const 2))) + (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2))) ) (func (export "as-loop-first") (result i32) - (block i32 (loop i32 (br 1 (i32.const 3)) (i32.const 2))) + (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2))) ) (func (export "as-loop-mid") (result i32) - (block i32 (loop i32 (call $dummy) (br 1 (i32.const 4)) (i32.const 2))) + (block (result i32) + (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2)) + ) ) (func (export "as-loop-last") (result i32) - (block i32 (loop i32 (nop) (call $dummy) (br 1 (i32.const 5)))) + (block (result i32) + (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5))) + ) ) (func (export "as-br-value") (result i32) - (block i32 (br 0 (br 0 (i32.const 9)))) + (block (result i32) (br 0 (br 0 (i32.const 9)))) ) (func (export "as-br_if-cond") (block (br_if 0 (br 0))) ) (func (export "as-br_if-value") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7) ) ) (func (export "as-br_if-value-cond") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7) ) ) @@ -67,55 +71,82 @@ (block (br_table 0 0 0 (br 0))) ) (func (export "as-br_table-value") (result i32) - (block i32 + (block (result i32) (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7) ) ) (func (export "as-br_table-value-index") (result i32) - (block i32 + (block (result i32) (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7) ) ) (func (export "as-return-value") (result i64) - (block i64 (return (br 0 (i64.const 7)))) + (block (result i64) (return (br 0 (i64.const 7)))) ) (func (export "as-if-cond") (result i32) - (block i32 (if i32 (br 0 (i32.const 2)) (i32.const 0) (i32.const 1))) + (block (result i32) + (if (result i32) (br 0 (i32.const 2)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) ) (func (export "as-if-then") (param i32 i32) (result i32) - (block i32 (if i32 (get_local 0) (br 1 (i32.const 3)) (get_local 1))) + (block (result i32) + (if (result i32) (get_local 0) + (then (br 1 (i32.const 3))) + (else (get_local 1)) + ) + ) ) (func (export "as-if-else") (param i32 i32) (result i32) - (block i32 (if i32 (get_local 0) (get_local 1) (br 1 (i32.const 4)))) + (block (result i32) + (if (result i32) (get_local 0) + (then (get_local 1)) + (else (br 1 (i32.const 4))) + ) + ) ) (func (export "as-select-first") (param i32 i32) (result i32) - (block i32 (select (br 0 (i32.const 5)) (get_local 0) (get_local 1))) + (block (result i32) + (select (br 0 (i32.const 5)) (get_local 0) (get_local 1)) + ) ) (func (export "as-select-second") (param i32 i32) (result i32) - (block i32 (select (get_local 0) (br 0 (i32.const 6)) (get_local 1))) + (block (result i32) + (select (get_local 0) (br 0 (i32.const 6)) (get_local 1)) + ) ) (func (export "as-select-cond") (result i32) - (block i32 (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7)))) + (block (result i32) + (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7))) + ) ) (func $f (param i32 i32 i32) (result i32) (i32.const -1)) (func (export "as-call-first") (result i32) - (block i32 (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))) + (block (result i32) + (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3)) + ) ) (func (export "as-call-mid") (result i32) - (block i32 (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))) + (block (result i32) + (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3)) + ) ) (func (export "as-call-last") (result i32) - (block i32 (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))) + (block (result i32) + (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14))) + ) ) (type $sig (func (param i32 i32 i32) (result i32))) (table anyfunc (elem $f)) (func (export "as-call_indirect-func") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (br 0 (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3) @@ -123,7 +154,7 @@ ) ) (func (export "as-call_indirect-first") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (br 0 (i32.const 21)) (i32.const 2) (i32.const 3) @@ -131,7 +162,7 @@ ) ) (func (export "as-call_indirect-mid") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (br 0 (i32.const 22)) (i32.const 3) @@ -139,7 +170,7 @@ ) ) (func (export "as-call_indirect-last") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (br 0 (i32.const 23)) @@ -148,65 +179,73 @@ ) (func (export "as-set_local-value") (result i32) (local f32) - (block i32 (set_local 0 (br 0 (i32.const 17))) (i32.const -1)) + (block (result i32) (set_local 0 (br 0 (i32.const 17))) (i32.const -1)) ) (memory 1) (func (export "as-load-address") (result f32) - (block f32 (f32.load (br 0 (f32.const 1.7)))) + (block (result f32) (f32.load (br 0 (f32.const 1.7)))) ) (func (export "as-loadN-address") (result i64) - (block i64 (i64.load8_s (br 0 (i64.const 30)))) + (block (result i64) (i64.load8_s (br 0 (i64.const 30)))) ) (func (export "as-store-address") (result i32) - (block i32 (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1)) + (block (result i32) + (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1) + ) ) (func (export "as-store-value") (result i32) - (block i32 (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1)) + (block (result i32) + (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1) + ) ) (func (export "as-storeN-address") (result i32) - (block i32 (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1)) + (block (result i32) + (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1) + ) ) (func (export "as-storeN-value") (result i32) - (block i32 (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1)) + (block (result i32) + (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1) + ) ) (func (export "as-unary-operand") (result f32) - (block f32 (f32.neg (br 0 (f32.const 3.4)))) + (block (result f32) (f32.neg (br 0 (f32.const 3.4)))) ) (func (export "as-binary-left") (result i32) - (block i32 (i32.add (br 0 (i32.const 3)) (i32.const 10))) + (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10))) ) (func (export "as-binary-right") (result i64) - (block i64 (i64.sub (i64.const 10) (br 0 (i64.const 45)))) + (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45)))) ) (func (export "as-test-operand") (result i32) - (block i32 (i32.eqz (br 0 (i32.const 44)))) + (block (result i32) (i32.eqz (br 0 (i32.const 44)))) ) (func (export "as-compare-left") (result i32) - (block i32 (f64.le (br 0 (i32.const 43)) (f64.const 10))) + (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10))) ) (func (export "as-compare-right") (result i32) - (block i32 (f32.ne (f32.const 10) (br 0 (i32.const 42)))) + (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42)))) ) (func (export "as-convert-operand") (result i32) - (block i32 (i32.wrap/i64 (br 0 (i32.const 41)))) + (block (result i32) (i32.wrap/i64 (br 0 (i32.const 41)))) ) (func (export "as-grow_memory-size") (result i32) - (block i32 (grow_memory (br 0 (i32.const 40)))) + (block (result i32) (grow_memory (br 0 (i32.const 40)))) ) (func (export "nested-block-value") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (call $dummy) (i32.add (i32.const 4) (br 0 (i32.const 8))) ) @@ -216,10 +255,10 @@ (func (export "nested-br-value") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (br 0 (br 1 (i32.const 8))) ) @@ -232,10 +271,10 @@ (func (export "nested-br_if-value") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1))) (i32.const 32) @@ -249,7 +288,7 @@ (func (export "nested-br_if-value-cond") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8)))) (i32.const 16) @@ -260,10 +299,10 @@ (func (export "nested-br_table-value") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (br_table 0 (br 1 (i32.const 8)) (i32.const 1)) ) @@ -276,7 +315,7 @@ (func (export "nested-br_table-value-index") (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (br_table 0 (i32.const 4) (br 0 (i32.const 8))) (i32.const 16) @@ -370,26 +409,26 @@ (assert_invalid (module (func $type-arg-empty-vs-num (result i32) - (block i32 (br 0) (i32.const 1)) + (block (result i32) (br 0) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-arg-void-vs-num (result i32) - (block i32 (br 0 (nop)) (i32.const 1)) + (block (result i32) (br 0 (nop)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-arg-void-vs-num-nested (result i32) - (block i32 (i32.const 0) (block (br 1))) + (block (result i32) (i32.const 0) (block (br 1))) )) "type mismatch" ) (assert_invalid (module (func $type-arg-num-vs-num (result i32) - (block i32 (br 0 (i64.const 1)) (i32.const 1)) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) )) "type mismatch" ) diff --git a/test/core/br_if.wast b/test/core/br_if.wast index 6fcfc649b6..0aa46d4712 100644 --- a/test/core/br_if.wast +++ b/test/core/br_if.wast @@ -14,13 +14,19 @@ (block (call $dummy) (call $dummy) (br_if 0 (get_local 0))) ) (func (export "as-block-first-value") (param i32) (result i32) - (block i32 (drop (br_if 0 (i32.const 10) (get_local 0))) (return (i32.const 11))) + (block (result i32) + (drop (br_if 0 (i32.const 10) (get_local 0))) (return (i32.const 11)) + ) ) (func (export "as-block-mid-value") (param i32) (result i32) - (block i32 (call $dummy) (drop (br_if 0 (i32.const 20) (get_local 0))) (return (i32.const 21))) + (block (result i32) + (call $dummy) + (drop (br_if 0 (i32.const 20) (get_local 0))) + (return (i32.const 21)) + ) ) (func (export "as-block-last-value") (param i32) (result i32) - (block i32 + (block (result i32) (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (get_local 0)) ) ) @@ -37,20 +43,24 @@ ) (func (export "as-if-then") (param i32 i32) - (block (if (get_local 0) (br_if 1 (get_local 1)) (call $dummy))) + (block + (if (get_local 0) (then (br_if 1 (get_local 1))) (else (call $dummy))) + ) ) (func (export "as-if-else") (param i32 i32) - (block (if (get_local 0) (call $dummy) (br_if 1 (get_local 1)))) + (block + (if (get_local 0) (then (call $dummy)) (else (br_if 1 (get_local 1)))) + ) ) (func (export "nested-block-value") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (i32.add (i32.const 4) - (block i32 + (block (result i32) (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 16) ) @@ -62,10 +72,12 @@ (func (export "nested-br-value") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (br 0 - (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)) + (block (result i32) + (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4) + ) ) (i32.const 16) ) @@ -75,10 +87,12 @@ (func (export "nested-br_if-value") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop (br_if 0 - (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)) + (block (result i32) + (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4) + ) (i32.const 1) )) (i32.const 16) @@ -89,11 +103,13 @@ (func (export "nested-br_if-value-cond") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop (br_if 0 (i32.const 4) - (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)) + (block (result i32) + (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1) + ) )) (i32.const 16) ) @@ -103,10 +119,12 @@ (func (export "nested-br_table-value") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (br_table 0 - (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)) + (block (result i32) + (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4) + ) (i32.const 1) ) (i32.const 16) @@ -117,11 +135,13 @@ (func (export "nested-br_table-value-index") (param i32) (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (br_table 0 (i32.const 4) - (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)) + (block (result i32) + (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1) + ) ) (i32.const 16) ) @@ -203,13 +223,13 @@ (assert_invalid (module (func $type-false-arg-void-vs-num (result i32) - (block i32 (br_if 0 (i32.const 0)) (i32.const 1)) + (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-true-arg-void-vs-num (result i32) - (block i32 (br_if 0 (i32.const 1)) (i32.const 1)) + (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1)) )) "type mismatch" ) @@ -228,25 +248,29 @@ (assert_invalid (module (func $type-false-arg-void-vs-num (result i32) - (block i32 (br_if 0 (nop) (i32.const 0)) (i32.const 1)) + (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-true-arg-void-vs-num (result i32) - (block i32 (br_if 0 (nop) (i32.const 1)) (i32.const 1)) + (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-false-arg-num-vs-num (result i32) - (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)) + (block (result i32) + (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1) + ) )) "type mismatch" ) (assert_invalid (module (func $type-true-arg-num-vs-num (result i32) - (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)) + (block (result i32) + (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1) + ) )) "type mismatch" ) @@ -265,19 +289,19 @@ ) (assert_invalid (module (func $type-arg-cond-void-vs-i32 (result i32) - (block i32 (br_if 0 (i32.const 0) (nop)) (i32.const 1)) + (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-arg-void-vs-num-nested (result i32) - (block i32 (i32.const 0) (block (br_if 1 (i32.const 1)))) + (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1)))) )) "type mismatch" ) (assert_invalid (module (func $type-arg-cond-num-vs-i32 (result i32) - (block i32 (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1)) + (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1)) )) "type mismatch" ) diff --git a/test/core/br_table.wast b/test/core/br_table.wast index 19a236f850..c8d6082d72 100644 --- a/test/core/br_table.wast +++ b/test/core/br_table.wast @@ -18,16 +18,16 @@ ) (func (export "type-i32-value") (result i32) - (block i32 (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0)))) + (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0)))) ) (func (export "type-i64-value") (result i64) - (block i64 (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0)))) + (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0)))) ) (func (export "type-f32-value") (result f32) - (block f32 (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0)))) + (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0)))) ) (func (export "type-f64-value") (result f64) - (block f64 (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0)))) + (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0)))) ) (func (export "empty") (param i32) (result i32) @@ -35,7 +35,9 @@ (i32.const 22) ) (func (export "empty-value") (param i32) (result i32) - (block i32 (br_table 0 (i32.const 33) (get_local 0)) (i32.const 31)) + (block (result i32) + (br_table 0 (i32.const 33) (get_local 0)) (i32.const 31) + ) ) (func (export "singleton") (param i32) (result i32) @@ -50,9 +52,9 @@ ) (func (export "singleton-value") (param i32) (result i32) - (block i32 + (block (result i32) (drop - (block i32 + (block (result i32) (br_table 0 1 (i32.const 33) (get_local 0)) (return (i32.const 31)) ) @@ -83,11 +85,11 @@ (func (export "multiple-value") (param i32) (result i32) (local i32) - (set_local 1 (block i32 - (set_local 1 (block i32 - (set_local 1 (block i32 - (set_local 1 (block i32 - (set_local 1 (block i32 + (set_local 1 (block (result i32) + (set_local 1 (block (result i32) + (set_local 1 (block (result i32) + (set_local 1 (block (result i32) + (set_local 1 (block (result i32) (br_table 3 2 1 0 4 (i32.const 200) (get_local 0)) (return (i32.add (get_local 1) (i32.const 99))) )) @@ -849,38 +851,42 @@ (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0))) ) (func (export "as-block-value") (result i32) - (block i32 (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0))) + (block (result i32) + (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0)) + ) ) (func (export "as-loop-first") (result i32) - (loop i32 (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1)) + (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1)) ) (func (export "as-loop-mid") (result i32) - (loop i32 + (loop (result i32) (call $dummy) (br_table 1 1 1 (i32.const 4) (i32.const -1)) (i32.const 2) ) ) (func (export "as-loop-last") (result i32) - (loop i32 (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1))) + (loop (result i32) + (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1)) + ) ) (func (export "as-br-value") (result i32) - (block i32 (br 0 (br 0 (i32.const 9)))) + (block (result i32) (br 0 (br 0 (i32.const 9)))) ) (func (export "as-br_if-cond") (block (br_if 0 (br_table 0 0 0 (i32.const 1)))) ) (func (export "as-br_if-value") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1))) (i32.const 7) ) ) (func (export "as-br_if-value-cond") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0)))) (i32.const 7) ) @@ -890,66 +896,66 @@ (block (br_table 0 0 0 (br_table 0 (i32.const 1)))) ) (func (export "as-br_table-value") (result i32) - (block i32 + (block (result i32) (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1)) (i32.const 7) ) ) (func (export "as-br_table-value-index") (result i32) - (block i32 + (block (result i32) (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1))) (i32.const 7) ) ) (func (export "as-return-value") (result i64) - (block i64 (return (br_table 0 (i64.const 7) (i32.const 0)))) + (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0)))) ) (func (export "as-if-cond") (result i32) - (block i32 - (if i32 + (block (result i32) + (if (result i32) (br_table 0 (i32.const 2) (i32.const 0)) - (i32.const 0) - (i32.const 1) + (then (i32.const 0)) + (else (i32.const 1)) ) ) ) (func (export "as-if-then") (param i32 i32) (result i32) - (block i32 - (if i32 + (block (result i32) + (if (result i32) (get_local 0) - (br_table 1 (i32.const 3) (i32.const 0)) - (get_local 1) + (then (br_table 1 (i32.const 3) (i32.const 0))) + (else (get_local 1)) ) ) ) (func (export "as-if-else") (param i32 i32) (result i32) - (block i32 - (if i32 + (block (result i32) + (if (result i32) (get_local 0) - (get_local 1) - (br_table 1 0 (i32.const 4) (i32.const 0)) + (then (get_local 1)) + (else (br_table 1 0 (i32.const 4) (i32.const 0))) ) ) ) (func (export "as-select-first") (param i32 i32) (result i32) - (block i32 + (block (result i32) (select (br_table 0 (i32.const 5) (i32.const 0)) (get_local 0) (get_local 1) ) ) ) (func (export "as-select-second") (param i32 i32) (result i32) - (block i32 + (block (result i32) (select (get_local 0) (br_table 0 (i32.const 6) (i32.const 1)) (get_local 1) ) ) ) (func (export "as-select-cond") (result i32) - (block i32 + (block (result i32) (select (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1)) ) @@ -958,21 +964,21 @@ (func $f (param i32 i32 i32) (result i32) (i32.const -1)) (func (export "as-call-first") (result i32) - (block i32 + (block (result i32) (call $f (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3) ) ) ) (func (export "as-call-mid") (result i32) - (block i32 + (block (result i32) (call $f (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3) ) ) ) (func (export "as-call-last") (result i32) - (block i32 + (block (result i32) (call $f (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1)) ) @@ -982,7 +988,7 @@ (type $sig (func (param i32 i32 i32) (result i32))) (table anyfunc (elem $f)) (func (export "as-call_indirect-first") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2) (i32.const 3) @@ -990,7 +996,7 @@ ) ) (func (export "as-call_indirect-mid") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2) (i32.const 3) @@ -998,7 +1004,7 @@ ) ) (func (export "as-call_indirect-last") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1)) (i32.const 3) @@ -1006,7 +1012,7 @@ ) ) (func (export "as-call_indirect-func") (result i32) - (block i32 + (block (result i32) (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (br_table 0 (i32.const 23) (i32.const 1)) @@ -1016,7 +1022,7 @@ (func (export "as-set_local-value") (result i32) (local f32) - (block i32 + (block (result i32) (set_local 0 (br_table 0 (i32.const 17) (i32.const 1))) (i32.const -1) ) @@ -1024,85 +1030,87 @@ (memory 1) (func (export "as-load-address") (result f32) - (block f32 (f32.load (br_table 0 (f32.const 1.7) (i32.const 1)))) + (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1)))) ) (func (export "as-loadN-address") (result i64) - (block i64 (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1)))) + (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1)))) ) (func (export "as-store-address") (result i32) - (block i32 + (block (result i32) (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7)) (i32.const -1) ) ) (func (export "as-store-value") (result i32) - (block i32 + (block (result i32) (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1))) (i32.const -1) ) ) (func (export "as-storeN-address") (result i32) - (block i32 + (block (result i32) (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7)) (i32.const -1) ) ) (func (export "as-storeN-value") (result i32) - (block i32 + (block (result i32) (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0))) (i32.const -1) ) ) (func (export "as-unary-operand") (result f32) - (block f32 (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0)))) + (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0)))) ) (func (export "as-binary-left") (result i32) - (block i32 + (block (result i32) (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10)) ) ) (func (export "as-binary-right") (result i64) - (block i64 + (block (result i64) (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0))) ) ) (func (export "as-test-operand") (result i32) - (block i32 (i32.eqz (br_table 0 (i32.const 44) (i32.const 0)))) + (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0)))) ) (func (export "as-compare-left") (result i32) - (block i32 + (block (result i32) (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10)) ) ) (func (export "as-compare-right") (result i32) - (block i32 + (block (result i32) (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0))) ) ) (func (export "as-convert-operand") (result i32) - (block i32 (i32.wrap/i64 (br_table 0 (i32.const 41) (i32.const 0)))) + (block (result i32) + (i32.wrap/i64 (br_table 0 (i32.const 41) (i32.const 0))) + ) ) (func (export "as-grow_memory-size") (result i32) - (block i32 (grow_memory (br_table 0 (i32.const 40) (i32.const 0)))) + (block (result i32) (grow_memory (br_table 0 (i32.const 40) (i32.const 0)))) ) (func (export "nested-block-value") (param i32) (result i32) - (block i32 + (block (result i32) (drop (i32.const -1)) (i32.add (i32.const 1) - (block i32 + (block (result i32) (i32.add (i32.const 2) - (block i32 + (block (result i32) (drop (i32.const 4)) (i32.add (i32.const 8) @@ -1116,13 +1124,13 @@ ) (func (export "nested-br-value") (param i32) (result i32) - (block i32 + (block (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (br 0 (br_table 2 1 0 (i32.const 8) (get_local 0))) ) @@ -1134,13 +1142,13 @@ ) (func (export "nested-br_if-value") (param i32) (result i32) - (block i32 + (block (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (drop (br_if 0 @@ -1158,10 +1166,10 @@ ) (func (export "nested-br_if-value-cond") (param i32) (result i32) - (block i32 + (block (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0))) @@ -1173,13 +1181,13 @@ ) (func (export "nested-br_table-value") (param i32) (result i32) - (block i32 + (block (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (drop - (block i32 + (block (result i32) (drop (i32.const 4)) (br_table 0 (br_table 0 1 2 (i32.const 8) (get_local 0)) (i32.const 1)) (i32.const 32) @@ -1192,10 +1200,10 @@ ) (func (export "nested-br_table-value-index") (param i32) (result i32) - (block i32 + (block (result i32) (i32.add (i32.const 1) - (block i32 + (block (result i32) (drop (i32.const 2)) (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0))) (i32.const 16) @@ -1206,14 +1214,14 @@ (func (export "nested-br_table-loop-block") (param i32) (result i32) (set_local 0 - (loop i32 + (loop (result i32) (block (br_table 1 0 0 (get_local 0)) ) (i32.const 0) ) ) - (loop i32 + (loop (result i32) (block (br_table 0 1 1 (get_local 0)) ) @@ -1410,20 +1418,22 @@ (assert_invalid (module (func $type-arg-void-vs-num (result i32) - (block i32 (br_table 0 (nop) (i32.const 1)) (i32.const 1)) + (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-arg-num-vs-num (result i32) - (block i32 (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1)) + (block (result i32) + (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1) + ) )) "type mismatch" ) (assert_invalid (module (func $type-arg-num-vs-arg-num (block - (block f32 + (block (result f32) (br_table 0 1 (f32.const 0) (i32.const 0)) ) (drop) @@ -1446,19 +1456,21 @@ ) (assert_invalid (module (func $type-arg-index-void-vs-i32 (result i32) - (block i32 (br_table 0 0 (i32.const 0) (nop)) (i32.const 1)) + (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1)) )) "type mismatch" ) (assert_invalid (module (func $type-arg-void-vs-num-nested (result i32) - (block i32 (i32.const 0) (block (br_table 1 (i32.const 0)))) + (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0)))) )) "type mismatch" ) (assert_invalid (module (func $type-arg-index-num-vs-i32 (result i32) - (block i32 (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1)) + (block (result i32) + (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1) + ) )) "type mismatch" ) diff --git a/test/core/call.wast b/test/core/call.wast index 612daf2064..3a89f23233 100644 --- a/test/core/call.wast +++ b/test/core/call.wast @@ -45,42 +45,51 @@ ;; Recursion (func $fac (export "fac") (param i64) (result i64) - (if i64 (i64.eqz (get_local 0)) - (i64.const 1) - (i64.mul (get_local 0) (call $fac (i64.sub (get_local 0) (i64.const 1)))) + (if (result i64) (i64.eqz (get_local 0)) + (then (i64.const 1)) + (else + (i64.mul + (get_local 0) + (call $fac (i64.sub (get_local 0) (i64.const 1))) + ) + ) ) ) (func $fac-acc (export "fac-acc") (param i64 i64) (result i64) - (if i64 (i64.eqz (get_local 0)) - (get_local 1) - (call $fac-acc - (i64.sub (get_local 0) (i64.const 1)) - (i64.mul (get_local 0) (get_local 1)) + (if (result i64) (i64.eqz (get_local 0)) + (then (get_local 1)) + (else + (call $fac-acc + (i64.sub (get_local 0) (i64.const 1)) + (i64.mul (get_local 0) (get_local 1)) + ) ) ) ) (func $fib (export "fib") (param i64) (result i64) - (if i64 (i64.le_u (get_local 0) (i64.const 1)) - (i64.const 1) - (i64.add - (call $fib (i64.sub (get_local 0) (i64.const 2))) - (call $fib (i64.sub (get_local 0) (i64.const 1))) + (if (result i64) (i64.le_u (get_local 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call $fib (i64.sub (get_local 0) (i64.const 2))) + (call $fib (i64.sub (get_local 0) (i64.const 1))) + ) ) ) ) (func $even (export "even") (param i64) (result i32) - (if i32 (i64.eqz (get_local 0)) - (i32.const 44) - (call $odd (i64.sub (get_local 0) (i64.const 1))) + (if (result i32) (i64.eqz (get_local 0)) + (then (i32.const 44)) + (else (call $odd (i64.sub (get_local 0) (i64.const 1)))) ) ) (func $odd (export "odd") (param i64) (result i32) - (if i32 (i64.eqz (get_local 0)) - (i32.const 99) - (call $even (i64.sub (get_local 0) (i64.const 1))) + (if (result i32) (i64.eqz (get_local 0)) + (then (i32.const 99)) + (else (call $even (i64.sub (get_local 0) (i64.const 1)))) ) ) diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast index f42ffeda51..3c27c53c69 100644 --- a/test/core/call_indirect.wast +++ b/test/core/call_indirect.wast @@ -102,49 +102,57 @@ ;; Recursion (func $fac (export "fac") (type $over-i64) - (if i64 (i64.eqz (get_local 0)) - (i64.const 1) - (i64.mul - (get_local 0) - (call_indirect $over-i64 - (i64.sub (get_local 0) (i64.const 1)) - (i32.const 12) + (if (result i64) (i64.eqz (get_local 0)) + (then (i64.const 1)) + (else + (i64.mul + (get_local 0) + (call_indirect $over-i64 + (i64.sub (get_local 0) (i64.const 1)) + (i32.const 12) + ) ) ) ) ) (func $fib (export "fib") (type $over-i64) - (if i64 (i64.le_u (get_local 0) (i64.const 1)) - (i64.const 1) - (i64.add - (call_indirect $over-i64 - (i64.sub (get_local 0) (i64.const 2)) - (i32.const 13) - ) - (call_indirect $over-i64 - (i64.sub (get_local 0) (i64.const 1)) - (i32.const 13) + (if (result i64) (i64.le_u (get_local 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call_indirect $over-i64 + (i64.sub (get_local 0) (i64.const 2)) + (i32.const 13) + ) + (call_indirect $over-i64 + (i64.sub (get_local 0) (i64.const 1)) + (i32.const 13) + ) ) ) ) ) (func $even (export "even") (param i32) (result i32) - (if i32 (i32.eqz (get_local 0)) - (i32.const 44) - (call_indirect $over-i32 - (i32.sub (get_local 0) (i32.const 1)) - (i32.const 15) + (if (result i32) (i32.eqz (get_local 0)) + (then (i32.const 44)) + (else + (call_indirect $over-i32 + (i32.sub (get_local 0) (i32.const 1)) + (i32.const 15) + ) ) ) ) (func $odd (export "odd") (param i32) (result i32) - (if i32 (i32.eqz (get_local 0)) - (i32.const 99) - (call_indirect $over-i32 - (i32.sub (get_local 0) (i32.const 1)) - (i32.const 14) + (if (result i32) (i32.eqz (get_local 0)) + (then (i32.const 99)) + (else + (call_indirect $over-i32 + (i32.sub (get_local 0) (i32.const 1)) + (i32.const 14) + ) ) ) ) diff --git a/test/core/comments.wast b/test/core/comments.wast index 07a6298c4fea799851e0b42c8f269a25aa678366..90a64b42d9ec854f6522e940c0466eb6c1ca6de9 100644 GIT binary patch delta 77 zcmeBS-OIXxkI~H9TEQ{c+0#?Oz(Ci~O-I4pjZ4Ftfsu)sg_Vt+gOiJ!hnJ6EKu}0n hL{v;%LQ+avMpjO~eli!MEbIFjv))hIY|0qU2mluF4zvIO delta 52 zcmdnX+QYhmk5OI2+9Ngd@cdMT@WXqGic69+QuC}exwtf}-!9nucE_x@JNiJ3O`Fpg G!x;f54;NVg diff --git a/test/core/conversions.wast b/test/core/conversions.wast index e3c49b5de1..e664e1a6e3 100644 --- a/test/core/conversions.wast +++ b/test/core/conversions.wast @@ -69,8 +69,8 @@ (assert_return (invoke "i32.trunc_s_f32" (f32.const -2147483648.0)) (i32.const -2147483648)) (assert_trap (invoke "i32.trunc_s_f32" (f32.const 2147483648.0)) "integer overflow") (assert_trap (invoke "i32.trunc_s_f32" (f32.const -2147483904.0)) "integer overflow") -(assert_trap (invoke "i32.trunc_s_f32" (f32.const infinity)) "integer overflow") -(assert_trap (invoke "i32.trunc_s_f32" (f32.const -infinity)) "integer overflow") +(assert_trap (invoke "i32.trunc_s_f32" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_s_f32" (f32.const -inf)) "integer overflow") (assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer") @@ -91,8 +91,8 @@ (assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i32.const 0)) (assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "integer overflow") (assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "integer overflow") -(assert_trap (invoke "i32.trunc_u_f32" (f32.const infinity)) "integer overflow") -(assert_trap (invoke "i32.trunc_u_f32" (f32.const -infinity)) "integer overflow") +(assert_trap (invoke "i32.trunc_u_f32" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_u_f32" (f32.const -inf)) "integer overflow") (assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer") @@ -114,8 +114,8 @@ (assert_return (invoke "i32.trunc_s_f64" (f64.const -2147483648.0)) (i32.const -2147483648)) (assert_trap (invoke "i32.trunc_s_f64" (f64.const 2147483648.0)) "integer overflow") (assert_trap (invoke "i32.trunc_s_f64" (f64.const -2147483649.0)) "integer overflow") -(assert_trap (invoke "i32.trunc_s_f64" (f64.const infinity)) "integer overflow") -(assert_trap (invoke "i32.trunc_s_f64" (f64.const -infinity)) "integer overflow") +(assert_trap (invoke "i32.trunc_s_f64" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_s_f64" (f64.const -inf)) "integer overflow") (assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer") @@ -140,8 +140,8 @@ (assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e16)) "integer overflow") (assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e30)) "integer overflow") (assert_trap (invoke "i32.trunc_u_f64" (f64.const 9223372036854775808)) "integer overflow") -(assert_trap (invoke "i32.trunc_u_f64" (f64.const infinity)) "integer overflow") -(assert_trap (invoke "i32.trunc_u_f64" (f64.const -infinity)) "integer overflow") +(assert_trap (invoke "i32.trunc_u_f64" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_u_f64" (f64.const -inf)) "integer overflow") (assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer") (assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer") @@ -165,8 +165,8 @@ (assert_return (invoke "i64.trunc_s_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808)) (assert_trap (invoke "i64.trunc_s_f32" (f32.const 9223372036854775808.0)) "integer overflow") (assert_trap (invoke "i64.trunc_s_f32" (f32.const -9223373136366403584.0)) "integer overflow") -(assert_trap (invoke "i64.trunc_s_f32" (f32.const infinity)) "integer overflow") -(assert_trap (invoke "i64.trunc_s_f32" (f32.const -infinity)) "integer overflow") +(assert_trap (invoke "i64.trunc_s_f32" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_s_f32" (f32.const -inf)) "integer overflow") (assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer") @@ -185,8 +185,8 @@ (assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i64.const 0)) (assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "integer overflow") (assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "integer overflow") -(assert_trap (invoke "i64.trunc_u_f32" (f32.const infinity)) "integer overflow") -(assert_trap (invoke "i64.trunc_u_f32" (f32.const -infinity)) "integer overflow") +(assert_trap (invoke "i64.trunc_u_f32" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_u_f32" (f32.const -inf)) "integer overflow") (assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer") @@ -210,8 +210,8 @@ (assert_return (invoke "i64.trunc_s_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808)) (assert_trap (invoke "i64.trunc_s_f64" (f64.const 9223372036854775808.0)) "integer overflow") (assert_trap (invoke "i64.trunc_s_f64" (f64.const -9223372036854777856.0)) "integer overflow") -(assert_trap (invoke "i64.trunc_s_f64" (f64.const infinity)) "integer overflow") -(assert_trap (invoke "i64.trunc_s_f64" (f64.const -infinity)) "integer overflow") +(assert_trap (invoke "i64.trunc_s_f64" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_s_f64" (f64.const -inf)) "integer overflow") (assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer") @@ -234,8 +234,8 @@ (assert_return (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808)) (assert_trap (invoke "i64.trunc_u_f64" (f64.const 18446744073709551616.0)) "integer overflow") (assert_trap (invoke "i64.trunc_u_f64" (f64.const -1.0)) "integer overflow") -(assert_trap (invoke "i64.trunc_u_f64" (f64.const infinity)) "integer overflow") -(assert_trap (invoke "i64.trunc_u_f64" (f64.const -infinity)) "integer overflow") +(assert_trap (invoke "i64.trunc_u_f64" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_u_f64" (f64.const -inf)) "integer overflow") (assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer") (assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer") @@ -342,8 +342,8 @@ (assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119)) ;; Generated randomly by picking a random float. (assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37)) -(assert_return (invoke "f64.promote_f32" (f32.const infinity)) (f64.const infinity)) -(assert_return (invoke "f64.promote_f32" (f32.const -infinity)) (f64.const -infinity)) +(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf)) +(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const nan))) (assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const -nan))) @@ -369,12 +369,12 @@ (assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const infinity)) -(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -infinity)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125)) -(assert_return (invoke "f32.demote_f64" (f64.const infinity)) (f32.const infinity)) -(assert_return (invoke "f32.demote_f64" (f64.const -infinity)) (f32.const -infinity)) +(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0)) (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0)) @@ -408,8 +408,8 @@ (assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff)) (assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113)) (assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149)) -(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const infinity)) -(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -infinity)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf)) (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan)) (assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan)) (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000)) @@ -421,8 +421,8 @@ (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0)) (assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022)) (assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const infinity)) -(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -infinity)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf)) (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan)) (assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan)) (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000)) @@ -437,8 +437,8 @@ (assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010)) (assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039)) (assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609)) -(assert_return (invoke "i32.reinterpret_f32" (f32.const infinity)) (i32.const 0x7f800000)) -(assert_return (invoke "i32.reinterpret_f32" (f32.const -infinity)) (i32.const 0xff800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000)) (assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000)) (assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000)) (assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000)) @@ -453,8 +453,8 @@ (assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841)) (assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311)) (assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497)) -(assert_return (invoke "i64.reinterpret_f64" (f64.const infinity)) (i64.const 0x7ff0000000000000)) -(assert_return (invoke "i64.reinterpret_f64" (f64.const -infinity)) (i64.const 0xfff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000)) (assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000)) (assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000)) (assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000)) diff --git a/test/core/exports.wast b/test/core/exports.wast index e3a0052a6d..6841aa873e 100644 --- a/test/core/exports.wast +++ b/test/core/exports.wast @@ -5,6 +5,8 @@ (module (func) (func) (export "a" (func 0)) (export "b" (func 1))) (module (func (export "a"))) +(module (func (export "a") (export "b") (export "c"))) +(module (func (export "a") (export "b") (param i32))) (module (func) (export "a" (func 0))) (module (func $a (export "a"))) (module (func $a) (export "a" (func $a))) diff --git a/test/core/f32.wast b/test/core/f32.wast index 672eca76ce..2595a4ac9a 100644 --- a/test/core/f32.wast +++ b/test/core/f32.wast @@ -44,10 +44,10 @@ (assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const nan))) @@ -84,10 +84,10 @@ (assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const nan))) @@ -124,10 +124,10 @@ (assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const nan))) @@ -164,10 +164,10 @@ (assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const nan))) @@ -204,10 +204,10 @@ (assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const nan))) @@ -244,10 +244,10 @@ (assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -280,14 +280,14 @@ (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf)) (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -296,46 +296,46 @@ (assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "add" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const infinity))) -(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -infinity))) -(assert_return (invoke "add" (f32.const infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const inf))) +(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -inf))) +(assert_return (invoke "add" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x0p+0))) @@ -392,14 +392,14 @@ (assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f32.const -nan) (f32.const -nan:0x200000))) @@ -444,10 +444,10 @@ (assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const nan))) @@ -484,10 +484,10 @@ (assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const nan))) @@ -524,10 +524,10 @@ (assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const nan))) @@ -564,10 +564,10 @@ (assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const nan))) @@ -604,10 +604,10 @@ (assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const nan))) @@ -644,10 +644,10 @@ (assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -681,13 +681,13 @@ (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const infinity)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf)) (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -696,46 +696,46 @@ (assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const -infinity))) -(assert_return (invoke "sub" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "sub" (f32.const infinity) (f32.const -infinity)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const infinity))) -(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -inf))) +(assert_return (invoke "sub" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -inf)) (f32.const inf)) +(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const inf))) +(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x0p+0))) @@ -792,14 +792,14 @@ (assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000))) @@ -844,10 +844,10 @@ (assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const infinity))) +(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const inf))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const nan))) @@ -884,10 +884,10 @@ (assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep-22)) (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep-22)) (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep-22)) -(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const nan))) @@ -924,10 +924,10 @@ (assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+1)) (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+1)) (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+1)) -(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const nan))) @@ -964,10 +964,10 @@ (assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+126)) (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+126)) (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+126)) -(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const nan))) @@ -1004,10 +1004,10 @@ (assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const nan))) @@ -1040,14 +1040,14 @@ (assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5)) (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5)) (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5)) -(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -1076,18 +1076,18 @@ (assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -1096,46 +1096,46 @@ (assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const 0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const 0x0p+0))) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "mul" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "mul" (f32.const infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const -0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const 0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const 0x0p+0))) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x0p+0))) @@ -1192,14 +1192,14 @@ (assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000))) @@ -1244,10 +1244,10 @@ (assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const nan))) @@ -1256,10 +1256,10 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p+0)) (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p+0)) (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p+0)) @@ -1284,10 +1284,10 @@ (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const nan))) @@ -1296,10 +1296,10 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p+23)) (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p+23)) (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p+23)) @@ -1324,10 +1324,10 @@ (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const nan))) @@ -1336,14 +1336,14 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p+125)) (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p+125)) (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p+125)) @@ -1364,10 +1364,10 @@ (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-129)) (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-129)) (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-129)) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const nan))) @@ -1376,14 +1376,14 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+126)) (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+126)) (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+126)) @@ -1404,10 +1404,10 @@ (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-128)) (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-128)) (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-128)) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const nan))) @@ -1416,18 +1416,18 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+3)) (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+3)) (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+3)) @@ -1444,10 +1444,10 @@ (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb8p-126)) (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb8p-126)) (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb8p-126)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -1456,22 +1456,22 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const infinity)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const inf)) (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) @@ -1484,10 +1484,10 @@ (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0)) (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -1496,46 +1496,46 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -inf))) +(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const inf))) +(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -inf))) +(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const inf))) +(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x0p+0))) @@ -1592,14 +1592,14 @@ (assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f32.const -nan) (f32.const -nan:0x200000))) @@ -1644,10 +1644,10 @@ (assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const nan))) @@ -1684,10 +1684,10 @@ (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-149)) (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) -(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -0x1p-149)) -(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const nan))) @@ -1724,10 +1724,10 @@ (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-126)) (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) -(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -0x1p-126)) -(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const nan))) @@ -1764,10 +1764,10 @@ (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-1)) (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) -(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -0x1p-1)) -(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const nan))) @@ -1804,10 +1804,10 @@ (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0)) (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) -(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -0x1p+0)) -(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const nan))) @@ -1844,10 +1844,10 @@ (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -1884,10 +1884,10 @@ (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -1896,46 +1896,46 @@ (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -0x0p+0)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x0p+0)) (f32.const 0x0p+0)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -0x1p-149)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-149)) (f32.const 0x1p-149)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -0x1p-126)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-126)) (f32.const 0x1p-126)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -0x1p-1)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-1)) (f32.const 0x1p-1)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -0x1p+0)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p+0)) (f32.const 0x1p+0)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "min" (f32.const infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x0p+0))) @@ -1992,14 +1992,14 @@ (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f32.const -nan) (f32.const -nan:0x200000))) @@ -2044,10 +2044,10 @@ (assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const nan))) @@ -2084,10 +2084,10 @@ (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-149)) (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149)) -(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const 0x1p-149)) -(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -inf)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const nan))) @@ -2124,10 +2124,10 @@ (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-126)) (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126)) -(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const 0x1p-126)) -(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -inf)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const nan))) @@ -2164,10 +2164,10 @@ (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-1)) (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1)) -(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const 0x1p-1)) -(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -inf)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const nan))) @@ -2204,10 +2204,10 @@ (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0)) (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0)) -(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const 0x1p+0)) -(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -inf)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const nan))) @@ -2244,10 +2244,10 @@ (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan))) @@ -2284,10 +2284,10 @@ (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan))) @@ -2296,46 +2296,46 @@ (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000))) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -0x0p+0)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const 0x0p+0)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -0x1p-149)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const 0x1p-149)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -0x1p-126)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const 0x1p-126)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -0x1p-1)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const 0x1p-1)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -0x1p+0)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const 0x1p+0)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "max" (f32.const -infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "max" (f32.const infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const nan:0x200000))) -(assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const -nan))) -(assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const -nan:0x200000))) -(assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const nan))) -(assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const nan:0x200000))) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const nan:0x200000))) +(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const -nan))) +(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (f32.const -nan:0x200000))) +(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const nan))) +(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0))) (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x0p+0))) @@ -2392,14 +2392,14 @@ (assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127))) (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127))) (assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127))) -(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const infinity))) -(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -infinity))) -(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -infinity))) -(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const infinity))) -(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const infinity))) +(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const inf))) +(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -inf))) +(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -inf))) +(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const inf))) +(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const inf))) (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f32.const -nan) (f32.const -nan:0x200000))) @@ -2430,8 +2430,8 @@ (assert_return (invoke "sqrt" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.40d932p+1)) (assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1.fffffep+127))) (assert_return (invoke "sqrt" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+63)) -(assert_return_canonical_nan (invoke "sqrt" (f32.const -infinity))) -(assert_return (invoke "sqrt" (f32.const infinity)) (f32.const infinity)) +(assert_return_canonical_nan (invoke "sqrt" (f32.const -inf))) +(assert_return (invoke "sqrt" (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "sqrt" (f32.const -nan))) (assert_return_arithmetic_nan (invoke "sqrt" (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "sqrt" (f32.const nan))) @@ -2450,8 +2450,8 @@ (assert_return (invoke "floor" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) (assert_return (invoke "floor" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "floor" (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "floor" (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "floor" (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "floor" (f32.const -nan))) (assert_return_arithmetic_nan (invoke "floor" (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "floor" (f32.const nan))) @@ -2470,8 +2470,8 @@ (assert_return (invoke "ceil" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.cp+2)) (assert_return (invoke "ceil" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "ceil" (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "ceil" (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "ceil" (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "ceil" (f32.const -nan))) (assert_return_arithmetic_nan (invoke "ceil" (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "ceil" (f32.const nan))) @@ -2490,8 +2490,8 @@ (assert_return (invoke "trunc" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) (assert_return (invoke "trunc" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "trunc" (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "trunc" (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "trunc" (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "trunc" (f32.const -nan))) (assert_return_arithmetic_nan (invoke "trunc" (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "trunc" (f32.const nan))) @@ -2510,8 +2510,8 @@ (assert_return (invoke "nearest" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) (assert_return (invoke "nearest" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "nearest" (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "nearest" (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "nearest" (f32.const inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "nearest" (f32.const -nan))) (assert_return_arithmetic_nan (invoke "nearest" (f32.const -nan:0x200000))) (assert_return_canonical_nan (invoke "nearest" (f32.const nan))) diff --git a/test/core/f32_bitwise.wast b/test/core/f32_bitwise.wast index 473dba83f3..12bdb866e0 100644 --- a/test/core/f32_bitwise.wast +++ b/test/core/f32_bitwise.wast @@ -35,10 +35,10 @@ (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) -(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const infinity)) (f32.const 0x0p+0)) -(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0)) -(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0)) (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0)) (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0)) @@ -71,10 +71,10 @@ (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149)) (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) -(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149)) -(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const infinity)) (f32.const 0x1p-149)) -(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149)) -(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149)) (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149)) (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149)) @@ -107,10 +107,10 @@ (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126)) (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) -(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126)) -(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const infinity)) (f32.const 0x1p-126)) -(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126)) -(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126)) (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126)) (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126)) @@ -143,10 +143,10 @@ (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1)) (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) -(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1)) -(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const infinity)) (f32.const 0x1p-1)) -(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1)) -(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1)) (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1)) (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1)) @@ -179,10 +179,10 @@ (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) -(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0)) -(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const infinity)) (f32.const 0x1p+0)) -(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0)) -(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0)) (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0)) (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0)) @@ -215,10 +215,10 @@ (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2)) -(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2)) -(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2)) (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2)) (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2)) @@ -251,50 +251,50 @@ (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127)) (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -nan)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const -infinity) (f32.const nan)) (f32.const infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const -nan)) (f32.const -infinity)) -(assert_return (invoke "copysign" (f32.const infinity) (f32.const nan)) (f32.const infinity)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -nan)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const nan)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -nan)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const nan)) (f32.const inf)) (assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan)) (assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan)) (assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan)) @@ -323,10 +323,10 @@ (assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan)) (assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan)) (assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan)) -(assert_return (invoke "copysign" (f32.const -nan) (f32.const -infinity)) (f32.const -nan)) -(assert_return (invoke "copysign" (f32.const -nan) (f32.const infinity)) (f32.const nan)) -(assert_return (invoke "copysign" (f32.const nan) (f32.const -infinity)) (f32.const -nan)) -(assert_return (invoke "copysign" (f32.const nan) (f32.const infinity)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -inf)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const inf)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -inf)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const inf)) (f32.const nan)) (assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan)) (assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan)) (assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan)) @@ -345,8 +345,8 @@ (assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) (assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "abs" (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "abs" (f32.const infinity)) (f32.const infinity)) +(assert_return (invoke "abs" (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "abs" (f32.const inf)) (f32.const inf)) (assert_return (invoke "abs" (f32.const -nan)) (f32.const nan)) (assert_return (invoke "abs" (f32.const nan)) (f32.const nan)) (assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0)) @@ -363,7 +363,7 @@ (assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) (assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "neg" (f32.const -infinity)) (f32.const infinity)) -(assert_return (invoke "neg" (f32.const infinity)) (f32.const -infinity)) +(assert_return (invoke "neg" (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "neg" (f32.const inf)) (f32.const -inf)) (assert_return (invoke "neg" (f32.const -nan)) (f32.const nan)) (assert_return (invoke "neg" (f32.const nan)) (f32.const -nan)) diff --git a/test/core/f32_cmp.wast b/test/core/f32_cmp.wast index 7ad68bfd07..5bae18bcd8 100644 --- a/test/core/f32_cmp.wast +++ b/test/core/f32_cmp.wast @@ -38,10 +38,10 @@ (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) @@ -78,10 +78,10 @@ (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) @@ -118,10 +118,10 @@ (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) @@ -158,10 +158,10 @@ (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) @@ -198,10 +198,10 @@ (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) @@ -238,10 +238,10 @@ (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) @@ -278,10 +278,10 @@ (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) @@ -290,46 +290,46 @@ (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) @@ -386,14 +386,14 @@ (assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) @@ -438,10 +438,10 @@ (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan)) (i32.const 1)) @@ -478,10 +478,10 @@ (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan)) (i32.const 1)) @@ -518,10 +518,10 @@ (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan)) (i32.const 1)) @@ -558,10 +558,10 @@ (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan)) (i32.const 1)) @@ -598,10 +598,10 @@ (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan)) (i32.const 1)) @@ -638,10 +638,10 @@ (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 1)) @@ -678,10 +678,10 @@ (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 1)) @@ -690,46 +690,46 @@ (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const nan)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -nan)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const nan)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const nan:0x200000)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 1)) @@ -786,14 +786,14 @@ (assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -nan) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -nan) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const nan) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const nan) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 1)) @@ -838,10 +838,10 @@ (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) @@ -878,10 +878,10 @@ (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) @@ -918,10 +918,10 @@ (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) @@ -958,10 +958,10 @@ (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) @@ -998,10 +998,10 @@ (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) @@ -1038,10 +1038,10 @@ (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) @@ -1078,10 +1078,10 @@ (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) @@ -1090,46 +1090,46 @@ (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) @@ -1186,14 +1186,14 @@ (assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) @@ -1238,10 +1238,10 @@ (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) @@ -1278,10 +1278,10 @@ (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) @@ -1318,10 +1318,10 @@ (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) @@ -1358,10 +1358,10 @@ (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) @@ -1398,10 +1398,10 @@ (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) @@ -1438,10 +1438,10 @@ (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) @@ -1478,10 +1478,10 @@ (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) @@ -1490,46 +1490,46 @@ (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "le" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) @@ -1586,14 +1586,14 @@ (assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) @@ -1638,10 +1638,10 @@ (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) @@ -1678,10 +1678,10 @@ (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) @@ -1718,10 +1718,10 @@ (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) @@ -1758,10 +1758,10 @@ (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) @@ -1798,10 +1798,10 @@ (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) @@ -1838,10 +1838,10 @@ (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) @@ -1878,10 +1878,10 @@ (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) @@ -1890,46 +1890,46 @@ (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) @@ -1986,14 +1986,14 @@ (assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) @@ -2038,10 +2038,10 @@ (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) @@ -2078,10 +2078,10 @@ (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) @@ -2118,10 +2118,10 @@ (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) @@ -2158,10 +2158,10 @@ (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) @@ -2198,10 +2198,10 @@ (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) @@ -2238,10 +2238,10 @@ (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) @@ -2278,10 +2278,10 @@ (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) @@ -2290,46 +2290,46 @@ (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -nan)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const nan)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) @@ -2386,14 +2386,14 @@ (assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) (assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const nan) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const nan) (f32.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) diff --git a/test/core/f64.wast b/test/core/f64.wast index fddd6b3c1d..50db4e708d 100644 --- a/test/core/f64.wast +++ b/test/core/f64.wast @@ -44,10 +44,10 @@ (assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const nan))) @@ -84,10 +84,10 @@ (assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -124,10 +124,10 @@ (assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const nan))) @@ -164,10 +164,10 @@ (assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const nan))) @@ -204,10 +204,10 @@ (assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const nan))) @@ -244,10 +244,10 @@ (assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -280,14 +280,14 @@ (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -296,46 +296,46 @@ (assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "add" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const infinity))) -(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -infinity))) -(assert_return (invoke "add" (f64.const infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const inf))) +(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -inf))) +(assert_return (invoke "add" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x0p+0))) @@ -392,14 +392,14 @@ (assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -444,10 +444,10 @@ (assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const nan))) @@ -484,10 +484,10 @@ (assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -524,10 +524,10 @@ (assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const nan))) @@ -564,10 +564,10 @@ (assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const nan))) @@ -604,10 +604,10 @@ (assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const nan))) @@ -644,10 +644,10 @@ (assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -681,13 +681,13 @@ (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -696,46 +696,46 @@ (assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const -infinity))) -(assert_return (invoke "sub" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "sub" (f64.const infinity) (f64.const -infinity)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const infinity))) -(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -inf))) +(assert_return (invoke "sub" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -inf)) (f64.const inf)) +(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const inf))) +(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x0p+0))) @@ -792,14 +792,14 @@ (assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -844,10 +844,10 @@ (assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const infinity))) +(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const inf))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const nan))) @@ -884,10 +884,10 @@ (assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51)) (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51)) (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51)) -(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -924,10 +924,10 @@ (assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1)) (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1)) (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1)) -(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const nan))) @@ -964,10 +964,10 @@ (assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022)) (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022)) (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022)) -(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const nan))) @@ -1004,10 +1004,10 @@ (assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const nan))) @@ -1040,14 +1040,14 @@ (assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5)) (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5)) (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5)) -(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -1076,18 +1076,18 @@ (assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -1096,46 +1096,46 @@ (assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const 0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -0x0p+0))) -(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const 0x0p+0))) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "mul" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "mul" (f64.const infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const -0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const 0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -0x0p+0))) +(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const 0x0p+0))) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x0p+0))) @@ -1192,14 +1192,14 @@ (assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -1244,10 +1244,10 @@ (assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const nan))) @@ -1256,10 +1256,10 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0)) (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0)) (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) @@ -1284,10 +1284,10 @@ (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -1296,10 +1296,10 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+52)) (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52)) (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52)) @@ -1324,10 +1324,10 @@ (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const nan))) @@ -1336,14 +1336,14 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021)) (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021)) (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021)) @@ -1364,10 +1364,10 @@ (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022)) (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022)) (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022)) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const nan))) @@ -1376,14 +1376,14 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022)) (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022)) (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022)) @@ -1404,10 +1404,10 @@ (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022)) (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022)) (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022)) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const nan))) @@ -1416,18 +1416,18 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3)) (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3)) (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3)) @@ -1444,10 +1444,10 @@ (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022)) (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022)) (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -1456,22 +1456,22 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const infinity)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf)) (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) @@ -1484,10 +1484,10 @@ (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -1496,46 +1496,46 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -inf))) +(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const inf))) +(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -inf))) +(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const inf))) +(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x0p+0))) @@ -1592,14 +1592,14 @@ (assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -1644,10 +1644,10 @@ (assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const nan))) @@ -1684,10 +1684,10 @@ (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -1724,10 +1724,10 @@ (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) -(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -0x1p-1022)) -(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const nan))) @@ -1764,10 +1764,10 @@ (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) -(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -0x1p-1)) -(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const nan))) @@ -1804,10 +1804,10 @@ (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) -(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -0x1p+0)) -(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const nan))) @@ -1844,10 +1844,10 @@ (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -1884,10 +1884,10 @@ (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -1896,46 +1896,46 @@ (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -0x0p+0)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x0p+0)) (f64.const 0x0p+0)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -0x1p-1)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p-1)) (f64.const 0x1p-1)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -0x1p+0)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p+0)) (f64.const 0x1p+0)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "min" (f64.const infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x0p+0))) @@ -1992,14 +1992,14 @@ (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -2044,10 +2044,10 @@ (assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const nan))) @@ -2084,10 +2084,10 @@ (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan))) @@ -2124,10 +2124,10 @@ (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022)) -(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const 0x1p-1022)) -(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const nan))) @@ -2164,10 +2164,10 @@ (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1)) -(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const 0x1p-1)) -(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -inf)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const nan))) @@ -2204,10 +2204,10 @@ (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0)) -(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const 0x1p+0)) -(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -inf)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const nan))) @@ -2244,10 +2244,10 @@ (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan))) @@ -2284,10 +2284,10 @@ (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan))) @@ -2296,46 +2296,46 @@ (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000))) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -0x0p+0)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const 0x0p+0)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -0x1p-1)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const 0x1p-1)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -0x1p+0)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const 0x1p+0)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "max" (f64.const -infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "max" (f64.const infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const -nan))) -(assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const -nan:0x4000000000000))) -(assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const nan))) -(assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const nan:0x4000000000000))) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const -nan))) +(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000))) +(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const nan))) +(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (f64.const nan:0x4000000000000))) (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x0p+0))) (assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0))) (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x0p+0))) @@ -2392,14 +2392,14 @@ (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023))) (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023))) (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023))) -(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const infinity))) -(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -infinity))) -(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -infinity))) -(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const infinity))) -(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const infinity))) +(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf))) +(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -inf))) +(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf))) +(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const inf))) +(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf))) (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan))) (assert_return_arithmetic_nan (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000))) @@ -2430,8 +2430,8 @@ (assert_return (invoke "sqrt" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.40d931ff62705p+1)) (assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023))) (assert_return (invoke "sqrt" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+511)) -(assert_return_canonical_nan (invoke "sqrt" (f64.const -infinity))) -(assert_return (invoke "sqrt" (f64.const infinity)) (f64.const infinity)) +(assert_return_canonical_nan (invoke "sqrt" (f64.const -inf))) +(assert_return (invoke "sqrt" (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "sqrt" (f64.const -nan))) (assert_return_arithmetic_nan (invoke "sqrt" (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "sqrt" (f64.const nan))) @@ -2450,8 +2450,8 @@ (assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) (assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "floor" (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "floor" (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "floor" (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "floor" (f64.const -nan))) (assert_return_arithmetic_nan (invoke "floor" (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "floor" (f64.const nan))) @@ -2470,8 +2470,8 @@ (assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2)) (assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "ceil" (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "ceil" (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "ceil" (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "ceil" (f64.const -nan))) (assert_return_arithmetic_nan (invoke "ceil" (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "ceil" (f64.const nan))) @@ -2490,8 +2490,8 @@ (assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) (assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "trunc" (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "trunc" (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "trunc" (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "trunc" (f64.const -nan))) (assert_return_arithmetic_nan (invoke "trunc" (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "trunc" (f64.const nan))) @@ -2510,8 +2510,8 @@ (assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) (assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "nearest" (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "nearest" (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "nearest" (f64.const inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "nearest" (f64.const -nan))) (assert_return_arithmetic_nan (invoke "nearest" (f64.const -nan:0x4000000000000))) (assert_return_canonical_nan (invoke "nearest" (f64.const nan))) diff --git a/test/core/f64_bitwise.wast b/test/core/f64_bitwise.wast index 5b719a6e6e..86c64b54de 100644 --- a/test/core/f64_bitwise.wast +++ b/test/core/f64_bitwise.wast @@ -35,10 +35,10 @@ (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) -(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const infinity)) (f64.const 0x0p+0)) -(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0)) -(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0)) (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0)) (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0)) @@ -71,10 +71,10 @@ (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022)) -(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022)) -(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022)) (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022)) (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022)) @@ -107,10 +107,10 @@ (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) -(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022)) -(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022)) -(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022)) -(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022)) (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022)) (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022)) @@ -143,10 +143,10 @@ (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) -(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1)) -(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const infinity)) (f64.const 0x1p-1)) -(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1)) -(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1)) (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1)) (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1)) @@ -179,10 +179,10 @@ (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) -(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0)) -(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const infinity)) (f64.const 0x1p+0)) -(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0)) -(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0)) (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0)) (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0)) @@ -215,10 +215,10 @@ (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2)) -(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2)) -(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2)) (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2)) (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2)) @@ -251,50 +251,50 @@ (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023)) (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -nan)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const -infinity) (f64.const nan)) (f64.const infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const -nan)) (f64.const -infinity)) -(assert_return (invoke "copysign" (f64.const infinity) (f64.const nan)) (f64.const infinity)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -nan)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const nan)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -nan)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const nan)) (f64.const inf)) (assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan)) (assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan)) (assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan)) @@ -323,10 +323,10 @@ (assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan)) (assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan)) (assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan)) -(assert_return (invoke "copysign" (f64.const -nan) (f64.const -infinity)) (f64.const -nan)) -(assert_return (invoke "copysign" (f64.const -nan) (f64.const infinity)) (f64.const nan)) -(assert_return (invoke "copysign" (f64.const nan) (f64.const -infinity)) (f64.const -nan)) -(assert_return (invoke "copysign" (f64.const nan) (f64.const infinity)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -inf)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const inf)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -inf)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const inf)) (f64.const nan)) (assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan)) (assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan)) (assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan)) @@ -345,8 +345,8 @@ (assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) (assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "abs" (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "abs" (f64.const infinity)) (f64.const infinity)) +(assert_return (invoke "abs" (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "abs" (f64.const inf)) (f64.const inf)) (assert_return (invoke "abs" (f64.const -nan)) (f64.const nan)) (assert_return (invoke "abs" (f64.const nan)) (f64.const nan)) (assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0)) @@ -363,7 +363,7 @@ (assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) (assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) (assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) -(assert_return (invoke "neg" (f64.const -infinity)) (f64.const infinity)) -(assert_return (invoke "neg" (f64.const infinity)) (f64.const -infinity)) +(assert_return (invoke "neg" (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "neg" (f64.const inf)) (f64.const -inf)) (assert_return (invoke "neg" (f64.const -nan)) (f64.const nan)) (assert_return (invoke "neg" (f64.const nan)) (f64.const -nan)) diff --git a/test/core/f64_cmp.wast b/test/core/f64_cmp.wast index 1c22dc4189..8fe9be4e5c 100644 --- a/test/core/f64_cmp.wast +++ b/test/core/f64_cmp.wast @@ -38,10 +38,10 @@ (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) @@ -78,10 +78,10 @@ (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) @@ -118,10 +118,10 @@ (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) @@ -158,10 +158,10 @@ (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) @@ -198,10 +198,10 @@ (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) @@ -238,10 +238,10 @@ (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) @@ -278,10 +278,10 @@ (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) @@ -290,46 +290,46 @@ (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) @@ -386,14 +386,14 @@ (assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "eq" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) @@ -438,10 +438,10 @@ (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan)) (i32.const 1)) @@ -478,10 +478,10 @@ (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1)) @@ -518,10 +518,10 @@ (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 1)) @@ -558,10 +558,10 @@ (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan)) (i32.const 1)) @@ -598,10 +598,10 @@ (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan)) (i32.const 1)) @@ -638,10 +638,10 @@ (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1)) @@ -678,10 +678,10 @@ (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1)) @@ -690,46 +690,46 @@ (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const nan)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -nan)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const nan)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 1)) @@ -786,14 +786,14 @@ (assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -nan) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -nan) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const nan) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const nan) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 1)) (assert_return (invoke "ne" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 1)) @@ -838,10 +838,10 @@ (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) @@ -878,10 +878,10 @@ (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) @@ -918,10 +918,10 @@ (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) @@ -958,10 +958,10 @@ (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) @@ -998,10 +998,10 @@ (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) @@ -1038,10 +1038,10 @@ (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) @@ -1078,10 +1078,10 @@ (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) @@ -1090,46 +1090,46 @@ (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) @@ -1186,14 +1186,14 @@ (assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "lt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) @@ -1238,10 +1238,10 @@ (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) @@ -1278,10 +1278,10 @@ (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) @@ -1318,10 +1318,10 @@ (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) @@ -1358,10 +1358,10 @@ (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) @@ -1398,10 +1398,10 @@ (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) @@ -1438,10 +1438,10 @@ (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) @@ -1478,10 +1478,10 @@ (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) @@ -1490,46 +1490,46 @@ (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "le" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) @@ -1586,14 +1586,14 @@ (assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "le" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) @@ -1638,10 +1638,10 @@ (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) @@ -1678,10 +1678,10 @@ (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) @@ -1718,10 +1718,10 @@ (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) @@ -1758,10 +1758,10 @@ (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) @@ -1798,10 +1798,10 @@ (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) @@ -1838,10 +1838,10 @@ (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) @@ -1878,10 +1878,10 @@ (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) @@ -1890,46 +1890,46 @@ (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) @@ -1986,14 +1986,14 @@ (assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "gt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) @@ -2038,10 +2038,10 @@ (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) @@ -2078,10 +2078,10 @@ (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) @@ -2118,10 +2118,10 @@ (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) @@ -2158,10 +2158,10 @@ (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) @@ -2198,10 +2198,10 @@ (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) @@ -2238,10 +2238,10 @@ (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) @@ -2278,10 +2278,10 @@ (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) @@ -2290,46 +2290,46 @@ (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const infinity)) (i32.const 1)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -nan)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const nan)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) @@ -2386,14 +2386,14 @@ (assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) (assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const nan) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const nan) (f64.const infinity)) (i32.const 0)) -(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) (assert_return (invoke "ge" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) diff --git a/test/core/fac.wast b/test/core/fac.wast index 3b388e2086..acc8962313 100644 --- a/test/core/fac.wast +++ b/test/core/fac.wast @@ -1,19 +1,23 @@ (module ;; Recursive factorial (func (export "fac-rec") (param i64) (result i64) - (if i64 (i64.eq (get_local 0) (i64.const 0)) - (i64.const 1) - (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1)))) + (if (result i64) (i64.eq (get_local 0) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1)))) + ) ) ) ;; Recursive factorial named (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64) - (if i64 (i64.eq (get_local $n) (i64.const 0)) - (i64.const 1) - (i64.mul - (get_local $n) - (call $fac-rec-named (i64.sub (get_local $n) (i64.const 1))) + (if (result i64) (i64.eq (get_local $n) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul + (get_local $n) + (call $fac-rec-named (i64.sub (get_local $n) (i64.const 1))) + ) ) ) ) @@ -27,8 +31,8 @@ (loop (if (i64.eq (get_local 1) (i64.const 0)) - (br 2) - (block + (then (br 2)) + (else (set_local 2 (i64.mul (get_local 1) (get_local 2))) (set_local 1 (i64.sub (get_local 1) (i64.const 1))) ) @@ -49,8 +53,8 @@ (loop $loop (if (i64.eq (get_local $i) (i64.const 0)) - (br $done) - (block + (then (br $done)) + (else (set_local $res (i64.mul (get_local $i) (get_local $res))) (set_local $i (i64.sub (get_local $i) (i64.const 1))) ) diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast index 3fb15b5915..5cee2d46cd 100644 --- a/test/core/float_exprs.wast +++ b/test/core/float_exprs.wast @@ -205,9 +205,9 @@ (f64.sub (get_local $x) (get_local $x))) ) -(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const infinity))) +(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const inf))) (assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const nan))) -(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const infinity))) +(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const inf))) (assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const nan))) ;; Test that x / x is not folded to 1.0. @@ -219,11 +219,11 @@ (f64.div (get_local $x) (get_local $x))) ) -(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const infinity))) +(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const inf))) (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const nan))) (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const 0.0))) (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const -0.0))) -(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const infinity))) +(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const inf))) (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const nan))) (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const 0.0))) (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const -0.0))) @@ -304,7 +304,7 @@ (assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66)) (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99)) (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0)) -(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const infinity)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const inf)) (assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255)) (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639)) @@ -321,11 +321,11 @@ (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96)) (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118)) (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89)) -(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -infinity)) +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -inf)) (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99)) (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907)) (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871)) -(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -infinity)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -inf)) (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0)) ;; Test that x+y+z+w is not reassociated. @@ -377,18 +377,18 @@ (f64.div (get_local $x) (f64.const 0.0))) ) -(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const infinity)) -(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -infinity)) -(assert_return (invoke "f32.no_fold_div_0" (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "f32.no_fold_div_0" (f32.const -infinity)) (f32.const -infinity)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf)) (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const 0))) (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const -0))) (assert_return_arithmetic_nan (invoke "f32.no_fold_div_0" (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const nan))) -(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const infinity)) -(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -infinity)) -(assert_return (invoke "f64.no_fold_div_0" (f64.const infinity)) (f64.const infinity)) -(assert_return (invoke "f64.no_fold_div_0" (f64.const -infinity)) (f64.const -infinity)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf)) (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const 0))) (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const -0))) (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const nan))) @@ -403,18 +403,18 @@ (f64.div (get_local $x) (f64.const -0.0))) ) -(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -infinity)) -(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const infinity)) -(assert_return (invoke "f32.no_fold_div_neg0" (f32.const infinity)) (f32.const -infinity)) -(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -infinity)) (f32.const infinity)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf)) (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const 0))) (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const -0))) (assert_return_arithmetic_nan (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000))) (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const nan))) -(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -infinity)) -(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const infinity)) -(assert_return (invoke "f64.no_fold_div_neg0" (f64.const infinity)) (f64.const -infinity)) -(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -infinity)) (f64.const infinity)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf)) (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const 0))) (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const -0))) (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const nan))) @@ -646,8 +646,8 @@ (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126)) (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) -(assert_return (invoke "no_fold_promote_demote" (f32.const infinity)) (f32.const infinity)) -(assert_return (invoke "no_fold_promote_demote" (f32.const -infinity)) (f32.const -infinity)) +(assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf)) ;; Test that demote(x+promote(y)) is not folded to demote(x)+y. @@ -927,15 +927,47 @@ ;; Test that x= y and friends. diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast index c69d81fb7d..1ab14f1a01 100644 --- a/test/core/float_literals.wast +++ b/test/core/float_literals.wast @@ -11,9 +11,9 @@ (func (export "f32.misc_nan") (result i32) (i32.reinterpret/f32 (f32.const nan:0x012345))) (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret/f32 (f32.const +nan:0x304050))) (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret/f32 (f32.const -nan:0x2abcde))) - (func (export "f32.infinity") (result i32) (i32.reinterpret/f32 (f32.const infinity))) - (func (export "f32.positive_infinity") (result i32) (i32.reinterpret/f32 (f32.const +infinity))) - (func (export "f32.negative_infinity") (result i32) (i32.reinterpret/f32 (f32.const -infinity))) + (func (export "f32.infinity") (result i32) (i32.reinterpret/f32 (f32.const inf))) + (func (export "f32.positive_infinity") (result i32) (i32.reinterpret/f32 (f32.const +inf))) + (func (export "f32.negative_infinity") (result i32) (i32.reinterpret/f32 (f32.const -inf))) ;; f32 numbers (func (export "f32.zero") (result i32) (i32.reinterpret/f32 (f32.const 0x0.0p0))) @@ -47,9 +47,9 @@ (func (export "f64.misc_nan") (result i64) (i64.reinterpret/f64 (f64.const nan:0x0123456789abc))) (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret/f64 (f64.const +nan:0x3040506070809))) (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret/f64 (f64.const -nan:0x2abcdef012345))) - (func (export "f64.infinity") (result i64) (i64.reinterpret/f64 (f64.const infinity))) - (func (export "f64.positive_infinity") (result i64) (i64.reinterpret/f64 (f64.const +infinity))) - (func (export "f64.negative_infinity") (result i64) (i64.reinterpret/f64 (f64.const -infinity))) + (func (export "f64.infinity") (result i64) (i64.reinterpret/f64 (f64.const inf))) + (func (export "f64.positive_infinity") (result i64) (i64.reinterpret/f64 (f64.const +inf))) + (func (export "f64.negative_infinity") (result i64) (i64.reinterpret/f64 (f64.const -inf))) ;; f64 numbers (func (export "f64.zero") (result i64) (i64.reinterpret/f64 (f64.const 0x0.0p0))) diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast index 1d67fdff56..095b8d8271 100644 --- a/test/core/float_misc.wast +++ b/test/core/float_misc.wast @@ -168,9 +168,9 @@ ;; Test rounding above the greatest finite value. (assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127)) -(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const infinity)) +(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf)) (assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023)) -(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const infinity)) +(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf)) ;; Test for a historic spreadsheet bug. ;; https://blogs.office.com/2007/09/25/calculation-issue-update/ @@ -272,8 +272,8 @@ ;; Miscellaneous values. (assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99)) -(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const infinity)) -(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const infinity)) +(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf)) +(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf)) (assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99)) (assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132)) (assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166)) @@ -295,7 +295,7 @@ (assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4)) (assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4)) (assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59)) -(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -infinity)) +(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf)) (assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0)) (assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713)) (assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270)) @@ -309,12 +309,12 @@ (assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97)) (assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952)) (assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911)) -(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const infinity)) +(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf)) (assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508)) (assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509)) ;; Computations that round differently in round-toward-zero mode. -(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const infinity)) +(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf)) (assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101)) (assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87)) (assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39)) @@ -322,7 +322,7 @@ (assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62)) (assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286)) (assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532)) -(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -infinity)) +(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf)) (assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151)) ;; Computations that round differently on x87. @@ -354,9 +354,9 @@ ;; Test the greatest positive value with a finite square. (assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127)) -(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const infinity)) +(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf)) (assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023)) -(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const infinity)) +(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf)) ;; Test the squares of values very close to 1. (assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0)) @@ -408,7 +408,7 @@ (assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86)) ;; Computations that round differently in round-downward mode. -(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const infinity)) +(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf)) (assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90)) (assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89)) (assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77)) @@ -420,13 +420,13 @@ (assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180)) ;; Computations that round differently in round-toward-zero mode. -(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const infinity)) +(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf)) (assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49)) (assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58)) (assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101)) (assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78)) (assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35)) -(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const infinity)) +(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf)) (assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682)) (assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905)) (assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34)) @@ -478,9 +478,9 @@ (assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) ;; Test the least positive value with a finite reciprocal. -(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const infinity)) +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf)) (assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127)) -(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const infinity)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf)) (assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023)) ;; Test the least positive value that has a subnormal reciprocal. diff --git a/test/core/forward.wast b/test/core/forward.wast index 43ab493485..7074ed7439 100644 --- a/test/core/forward.wast +++ b/test/core/forward.wast @@ -1,15 +1,15 @@ (module (func $even (export "even") (param $n i32) (result i32) - (if i32 (i32.eq (get_local $n) (i32.const 0)) - (i32.const 1) - (call $odd (i32.sub (get_local $n) (i32.const 1))) + (if (result i32) (i32.eq (get_local $n) (i32.const 0)) + (then (i32.const 1)) + (else (call $odd (i32.sub (get_local $n) (i32.const 1)))) ) ) (func $odd (export "odd") (param $n i32) (result i32) - (if i32 (i32.eq (get_local $n) (i32.const 0)) - (i32.const 0) - (call $even (i32.sub (get_local $n) (i32.const 1))) + (if (result i32) (i32.eq (get_local $n) (i32.const 0)) + (then (i32.const 0)) + (else (call $even (i32.sub (get_local $n) (i32.const 1)))) ) ) ) diff --git a/test/core/func.wast b/test/core/func.wast index a9c71db480..219095befe 100644 --- a/test/core/func.wast +++ b/test/core/func.wast @@ -97,7 +97,7 @@ (func (export "value-f64") (result f64) (f64.const 77.77)) (func (export "value-block-void") (block (call $dummy) (call $dummy))) (func (export "value-block-i32") (result i32) - (block i32 (call $dummy) (i32.const 77)) + (block (result i32) (call $dummy) (i32.const 77)) ) (func (export "return-empty") (return)) @@ -106,7 +106,7 @@ (func (export "return-f32") (result f32) (return (f32.const 78.7))) (func (export "return-f64") (result f64) (return (f64.const 78.78))) (func (export "return-block-i32") (result i32) - (return (block i32 (call $dummy) (i32.const 77))) + (return (block (result i32) (call $dummy) (i32.const 77))) ) (func (export "break-empty") (br 0)) @@ -115,7 +115,7 @@ (func (export "break-f32") (result f32) (br 0 (f32.const 79.9))) (func (export "break-f64") (result f64) (br 0 (f64.const 79.79))) (func (export "break-block-i32") (result i32) - (br 0 (block i32 (call $dummy) (i32.const 77))) + (br 0 (block (result i32) (call $dummy) (i32.const 77))) ) (func (export "break-br_if-empty") (param i32) @@ -136,7 +136,9 @@ ) (func (export "break-br_table-nested-num") (param i32) (result i32) (i32.add - (block i32 (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51)) + (block (result i32) + (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51) + ) (i32.const 2) ) ) diff --git a/test/core/if.wast b/test/core/if.wast index 7ec1f2b740..e80b38d43b 100644 --- a/test/core/if.wast +++ b/test/core/if.wast @@ -14,24 +14,24 @@ (func (export "singular") (param i32) (result i32) (if (get_local 0) (then (nop))) (if (get_local 0) (then (nop)) (else (nop))) - (if i32 (get_local 0) (then (i32.const 7)) (else (i32.const 8))) + (if (result i32) (get_local 0) (then (i32.const 7)) (else (i32.const 8))) ) (func (export "multi") (param i32) (result i32) (if (get_local 0) (then (call $dummy) (call $dummy) (call $dummy))) (if (get_local 0) (then) (else (call $dummy) (call $dummy) (call $dummy))) - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (call $dummy) (call $dummy) (i32.const 8)) (else (call $dummy) (call $dummy) (i32.const 9)) ) ) (func (export "nested") (param i32 i32) (result i32) - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (if (get_local 1) (then (call $dummy) (block) (nop))) (if (get_local 1) (then) (else (call $dummy) (block) (nop))) - (if i32 (get_local 1) + (if (result i32) (get_local 1) (then (call $dummy) (i32.const 9)) (else (call $dummy) (i32.const 10)) ) @@ -39,7 +39,7 @@ (else (if (get_local 1) (then (call $dummy) (block) (nop))) (if (get_local 1) (then) (else (call $dummy) (block) (nop))) - (if i32 (get_local 1) + (if (result i32) (get_local 1) (then (call $dummy) (i32.const 10)) (else (call $dummy) (i32.const 11)) ) @@ -49,7 +49,7 @@ (func (export "as-unary-operand") (param i32) (result i32) (i32.ctz - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (call $dummy) (i32.const 13)) (else (call $dummy) (i32.const -13)) ) @@ -57,11 +57,11 @@ ) (func (export "as-binary-operand") (param i32 i32) (result i32) (i32.mul - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (call $dummy) (i32.const 3)) (else (call $dummy) (i32.const -3)) ) - (if i32 (get_local 1) + (if (result i32) (get_local 1) (then (call $dummy) (i32.const 4)) (else (call $dummy) (i32.const -5)) ) @@ -69,7 +69,7 @@ ) (func (export "as-test-operand") (param i32) (result i32) (i32.eqz - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (call $dummy) (i32.const 13)) (else (call $dummy) (i32.const 0)) ) @@ -77,11 +77,11 @@ ) (func (export "as-compare-operand") (param i32 i32) (result i32) (f32.gt - (if f32 (get_local 0) + (if (result f32) (get_local 0) (then (call $dummy) (f32.const 3)) (else (call $dummy) (f32.const -3)) ) - (if f32 (get_local 1) + (if (result f32) (get_local 1) (then (call $dummy) (f32.const 4)) (else (call $dummy) (f32.const -4)) ) @@ -102,7 +102,7 @@ ) (func (export "break-value") (param i32) (result i32) - (if i32 (get_local 0) + (if (result i32) (get_local 0) (then (br 0 (i32.const 18)) (i32.const 19)) (else (br 0 (i32.const 21)) (i32.const 20)) ) @@ -111,7 +111,7 @@ (func (export "effects") (param i32) (result i32) (local i32) (if - (block i32 (set_local 1 (i32.const 1)) (get_local 0)) + (block (result i32) (set_local 1 (i32.const 1)) (get_local 0)) (then (set_local 1 (i32.mul (get_local 1) (i32.const 3))) (set_local 1 (i32.sub (get_local 1) (i32.const 5))) @@ -240,76 +240,76 @@ (assert_invalid (module (func $type-then-value-empty-vs-num (result i32) - (if i32 (i32.const 1) (then) (else (i32.const 0))) + (if (result i32) (i32.const 1) (then) (else (i32.const 0))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-empty-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 0)) (else)) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else)) )) "type mismatch" ) (assert_invalid (module (func $type-both-value-empty-vs-num (result i32) - (if i32 (i32.const 1) (then) (else)) + (if (result i32) (i32.const 1) (then) (else)) )) "type mismatch" ) (assert_invalid (module (func $type-no-else-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1))) + (if (result i32) (i32.const 1) (then (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-void-vs-num (result i32) - (if i32 (i32.const 1) (then (nop)) (else (i32.const 0))) + (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-void-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 0)) (else (nop))) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop))) )) "type mismatch" ) (assert_invalid (module (func $type-both-value-void-vs-num (result i32) - (if i32 (i32.const 1) (then (nop)) (else (nop))) + (if (result i32) (i32.const 1) (then (nop)) (else (nop))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-num-vs-num (result i32) - (if i32 (i32.const 1) (then (i64.const 1)) (else (i32.const 1))) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-num-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1)) (else (i64.const 1))) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-both-value-num-vs-num (result i32) - (if i32 (i32.const 1) (then (i64.const 1)) (else (i64.const 1))) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-both-different-value-num-vs-num (result i32) - (if i32 (i32.const 1) (then (i64.const 1)) (else (f64.const 1))) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-then-value-unreached-select (result i32) - (if i64 + (if (result i64) (i32.const 0) (then (select (unreachable) (unreachable) (unreachable))) (else (i64.const 0)) @@ -319,7 +319,7 @@ ) (assert_invalid (module (func $type-else-value-unreached-select (result i32) - (if i64 + (if (result i64) (i32.const 1) (then (i64.const 0)) (else (select (unreachable) (unreachable) (unreachable))) @@ -329,7 +329,7 @@ ) (assert_invalid (module (func $type-else-value-unreached-select (result i32) - (if i64 + (if (result i64) (i32.const 1) (then (select (unreachable) (unreachable) (unreachable))) (else (select (unreachable) (unreachable) (unreachable))) @@ -340,50 +340,68 @@ (assert_invalid (module (func $type-then-break-last-void-vs-num (result i32) - (if i32 (i32.const 1) (then (br 0)) (else (i32.const 1))) + (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-else-break-last-void-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0))) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0))) )) "type mismatch" ) (assert_invalid (module (func $type-then-break-empty-vs-num (result i32) - (if i32 (i32.const 1) (then (br 0) (i32.const 1)) (else (i32.const 1))) + (if (result i32) (i32.const 1) + (then (br 0) (i32.const 1)) + (else (i32.const 1)) + ) )) "type mismatch" ) (assert_invalid (module (func $type-else-break-empty-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0) (i32.const 1))) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0) (i32.const 1)) + ) )) "type mismatch" ) (assert_invalid (module (func $type-then-break-void-vs-num (result i32) - (if i32 (i32.const 1) (then (br 0 (nop)) (i32.const 1)) (else (i32.const 1))) + (if (result i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1)) + (else (i32.const 1)) + ) )) "type mismatch" ) (assert_invalid (module (func $type-else-break-void-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0 (nop)) (i32.const 1))) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (nop)) (i32.const 1)) + ) )) "type mismatch" ) (assert_invalid (module (func $type-then-break-num-vs-num (result i32) - (if i32 (i32.const 1) (then (br 0 (i64.const 1)) (i32.const 1)) (else (i32.const 1))) + (if (result i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) )) "type mismatch" ) (assert_invalid (module (func $type-else-break-num-vs-num (result i32) - (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0 (i64.const 1)) (i32.const 1))) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) )) "type mismatch" ) diff --git a/test/core/imports.wast b/test/core/imports.wast index 811095945b..029403bead 100644 --- a/test/core/imports.wast +++ b/test/core/imports.wast @@ -41,6 +41,12 @@ (func $print_f64-2 (import "spectest" "print") (param f64)) (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64))) + (func (export "p1") (import "spectest" "print") (param i32)) + (func $p (export "p2") (import "spectest" "print") (param i32)) + (func (export "p3") (export "p4") (import "spectest" "print") (param i32)) + (func (export "p5") (import "spectest" "print") (type 0)) + (func (export "p6") (import "spectest" "print") (type 0) (param i32) (result)) + (table anyfunc (elem $print_i32 $print_f64)) (func (export "print32") (param $i i32) diff --git a/test/core/inline-module.wast b/test/core/inline-module.wast new file mode 100644 index 0000000000..dc7ead7767 --- /dev/null +++ b/test/core/inline-module.wast @@ -0,0 +1 @@ +(func) (memory 0) (func (export "f")) diff --git a/test/core/labels.wast b/test/core/labels.wast index 03e5bf7227..02fea5f274 100644 --- a/test/core/labels.wast +++ b/test/core/labels.wast @@ -1,6 +1,6 @@ (module (func (export "block") (result i32) - (block $exit i32 + (block $exit (result i32) (br $exit (i32.const 1)) (i32.const 0) ) @@ -9,11 +9,11 @@ (func (export "loop1") (result i32) (local $i i32) (set_local $i (i32.const 0)) - (block $exit i32 - (loop $cont i32 + (block $exit (result i32) + (loop $cont (result i32) (set_local $i (i32.add (get_local $i) (i32.const 1))) (if (i32.eq (get_local $i) (i32.const 5)) - (br $exit (get_local $i)) + (then (br $exit (get_local $i))) ) (br $cont) ) @@ -23,14 +23,14 @@ (func (export "loop2") (result i32) (local $i i32) (set_local $i (i32.const 0)) - (block $exit i32 - (loop $cont i32 + (block $exit (result i32) + (loop $cont (result i32) (set_local $i (i32.add (get_local $i) (i32.const 1))) (if (i32.eq (get_local $i) (i32.const 5)) - (br $cont) + (then (br $cont)) ) (if (i32.eq (get_local $i) (i32.const 8)) - (br $exit (get_local $i)) + (then (br $exit (get_local $i))) ) (set_local $i (i32.add (get_local $i) (i32.const 1))) (br $cont) @@ -41,11 +41,11 @@ (func (export "loop3") (result i32) (local $i i32) (set_local $i (i32.const 0)) - (block $exit i32 - (loop $cont i32 + (block $exit (result i32) + (loop $cont (result i32) (set_local $i (i32.add (get_local $i) (i32.const 1))) (if (i32.eq (get_local $i) (i32.const 5)) - (br $exit (get_local $i)) + (then (br $exit (get_local $i))) ) (get_local $i) ) @@ -55,11 +55,11 @@ (func (export "loop4") (param $max i32) (result i32) (local $i i32) (set_local $i (i32.const 1)) - (block $exit i32 - (loop $cont i32 + (block $exit (result i32) + (loop $cont (result i32) (set_local $i (i32.add (get_local $i) (get_local $i))) (if (i32.gt_u (get_local $i) (get_local $max)) - (br $exit (get_local $i)) + (then (br $exit (get_local $i))) ) (br $cont) ) @@ -68,7 +68,7 @@ (func (export "loop5") (result i32) (i32.add - (loop $l i32 (i32.const 1)) + (loop $l (result i32) (i32.const 1)) (i32.const 1) ) ) @@ -148,9 +148,9 @@ ) (func (export "switch") (param i32) (result i32) - (block $ret i32 + (block $ret (result i32) (i32.mul (i32.const 10) - (block $exit i32 + (block $exit (result i32) (block $0 (block $default (block $3 @@ -186,7 +186,7 @@ (func (export "br_if0") (result i32) (local $i i32) (set_local $i (i32.const 0)) - (block $outer i32 + (block $outer (result i32) (block $inner (br_if $inner (i32.const 0)) (set_local $i (i32.or (get_local $i) (i32.const 0x1))) @@ -194,7 +194,7 @@ (set_local $i (i32.or (get_local $i) (i32.const 0x2))) ) (drop (br_if $outer - (block i32 + (block (result i32) (set_local $i (i32.or (get_local $i) (i32.const 0x4))) (get_local $i) ) @@ -202,7 +202,7 @@ )) (set_local $i (i32.or (get_local $i) (i32.const 0x8))) (drop (br_if $outer - (block i32 + (block (result i32) (set_local $i (i32.or (get_local $i) (i32.const 0x10))) (get_local $i) ) @@ -213,16 +213,21 @@ ) (func (export "br_if1") (result i32) - (block $l0 i32 - (drop (br_if $l0 (block $l1 i32 (br $l1 (i32.const 1))) (i32.const 1))) + (block $l0 (result i32) + (drop + (br_if $l0 + (block $l1 (result i32) (br $l1 (i32.const 1))) + (i32.const 1) + ) + ) (i32.const 1) ) ) (func (export "br_if2") (result i32) - (block $l0 i32 + (block $l0 (result i32) (if (i32.const 1) - (br $l0 (block $l1 i32 (br $l1 (i32.const 1)))) + (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1))))) ) (i32.const 1) ) @@ -232,10 +237,10 @@ (local $i1 i32) (drop (i32.add - (block $l0 i32 + (block $l0 (result i32) (drop (br_if $l0 - (block i32 (set_local $i1 (i32.const 1)) (get_local $i1)) - (block i32 (set_local $i1 (i32.const 2)) (get_local $i1)) + (block (result i32) (set_local $i1 (i32.const 1)) (get_local $i1)) + (block (result i32) (set_local $i1 (i32.const 2)) (get_local $i1)) )) (i32.const 0) ) @@ -246,24 +251,24 @@ ) (func (export "br") (result i32) - (block $l0 i32 + (block $l0 (result i32) (if (i32.const 1) - (br $l0 (block $l1 i32 (br $l1 (i32.const 1)))) - (block (drop (block $l1 i32 (br $l1 (i32.const 1))))) + (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1))))) + (else (block (drop (block $l1 (result i32) (br $l1 (i32.const 1)))))) ) (i32.const 1) ) ) (func (export "shadowing") (result i32) - (block $l1 i32 (i32.xor (br $l1 (i32.const 1)) (i32.const 2))) + (block $l1 (result i32) (i32.xor (br $l1 (i32.const 1)) (i32.const 2))) ) (func (export "redefinition") (result i32) - (block $l1 i32 + (block $l1 (result i32) (i32.add - (block $l1 i32 (i32.const 2)) - (block $l1 i32 (br $l1 (i32.const 3))) + (block $l1 (result i32) (i32.const 2)) + (block $l1 (result i32) (br $l1 (i32.const 3))) ) ) ) diff --git a/test/core/left-to-right.wast b/test/core/left-to-right.wast index 7eeda94a8d..6214d0d5ba 100644 --- a/test/core/left-to-right.wast +++ b/test/core/left-to-right.wast @@ -159,17 +159,17 @@ (func (export "f64_select") (result i32) (call $reset) (drop (select (call $f64_left) (call $f64_right) (call $f64_bool))) (call $get)) (func (export "br_if") (result i32) - (block i32 + (block (result i32) (call $reset) (drop (br_if 0 (call $i32_left) (i32.and (call $i32_right) (i32.const 0)))) (call $get) ) ) (func (export "br_table") (result i32) - (block $a i32 + (block $a (result i32) (call $reset) (drop - (block $b i32 + (block $b (result i32) (br_table $a $b (call $i32_left) (call $i32_right)) ) ) diff --git a/test/core/loop.wast b/test/core/loop.wast index 16f849b1bc..348061cbfb 100644 --- a/test/core/loop.wast +++ b/test/core/loop.wast @@ -10,55 +10,81 @@ (func (export "singular") (result i32) (loop (nop)) - (loop i32 (i32.const 7)) + (loop (result i32) (i32.const 7)) ) (func (export "multi") (result i32) (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy)) - (loop i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8)) + (loop (result i32) (call $dummy) (call $dummy) (call $dummy) (i32.const 8)) ) (func (export "nested") (result i32) - (loop i32 + (loop (result i32) (loop (call $dummy) (block) (nop)) - (loop i32 (call $dummy) (i32.const 9)) + (loop (result i32) (call $dummy) (i32.const 9)) ) ) (func (export "deep") (result i32) - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32 - (loop i32 (block i32 (call $dummy) (i32.const 150))) - )))))) - )))))) - )))))) - )))))) - )))))) - )))))) - )))))) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (call $dummy) (i32.const 150) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) ) (func (export "as-unary-operand") (result i32) - (i32.ctz (loop i32 (call $dummy) (i32.const 13))) + (i32.ctz (loop (result i32) (call $dummy) (i32.const 13))) ) (func (export "as-binary-operand") (result i32) (i32.mul - (loop i32 (call $dummy) (i32.const 3)) - (loop i32 (call $dummy) (i32.const 4)) + (loop (result i32) (call $dummy) (i32.const 3)) + (loop (result i32) (call $dummy) (i32.const 4)) ) ) (func (export "as-test-operand") (result i32) - (i32.eqz (loop i32 (call $dummy) (i32.const 13))) + (i32.eqz (loop (result i32) (call $dummy) (i32.const 13))) ) (func (export "as-compare-operand") (result i32) (f32.gt - (loop f32 (call $dummy) (f32.const 3)) - (loop f32 (call $dummy) (f32.const 3)) + (loop (result f32) (call $dummy) (f32.const 3)) + (loop (result f32) (call $dummy) (f32.const 3)) ) ) @@ -70,11 +96,13 @@ (i32.const 19) ) (func (export "break-value") (result i32) - (block i32 (loop i32 (br 1 (i32.const 18)) (br 0) (i32.const 19))) + (block (result i32) + (loop (result i32) (br 1 (i32.const 18)) (br 0) (i32.const 19)) + ) ) (func (export "break-repeated") (result i32) - (block i32 - (loop i32 + (block (result i32) + (loop (result i32) (br 1 (i32.const 18)) (br 1 (i32.const 19)) (drop (br_if 1 (i32.const 20) (i32.const 0))) @@ -89,19 +117,19 @@ (func (export "break-inner") (result i32) (local i32) (set_local 0 (i32.const 0)) - (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (block i32 (br 2 (i32.const 0x1))))))) - (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (loop i32 (br 2 (i32.const 0x2))))))) - (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (block i32 (loop i32 (br 1 (i32.const 0x4)))))))) - (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (i32.ctz (br 1 (i32.const 0x8))))))) - (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (i32.ctz (loop i32 (br 2 (i32.const 0x10)))))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1))))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2))))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4)))))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8))))))) + (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10)))))))) (get_local 0) ) (func (export "cont-inner") (result i32) (local i32) (set_local 0 (i32.const 0)) - (set_local 0 (i32.add (get_local 0) (loop i32 (loop i32 (br 1))))) - (set_local 0 (i32.add (get_local 0) (loop i32 (i32.ctz (br 0))))) - (set_local 0 (i32.add (get_local 0) (loop i32 (i32.ctz (loop i32 (br 1)))))) + (set_local 0 (i32.add (get_local 0) (loop (result i32) (loop (result i32) (br 1))))) + (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (br 0))))) + (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1)))))) (get_local 0) ) @@ -247,25 +275,25 @@ ) (assert_invalid (module (func $type-value-empty-vs-num (result i32) - (loop i32) + (loop (result i32)) )) "type mismatch" ) (assert_invalid (module (func $type-value-void-vs-num (result i32) - (loop i32 (nop)) + (loop (result i32) (nop)) )) "type mismatch" ) (assert_invalid (module (func $type-value-num-vs-num (result i32) - (loop i32 (f32.const 0)) + (loop (result i32) (f32.const 0)) )) "type mismatch" ) (assert_invalid (module (func $type-value-unreached-select (result i32) - (loop i64 (select (unreachable) (unreachable) (unreachable))) + (loop (result i64) (select (unreachable) (unreachable) (unreachable))) )) "type mismatch" ) diff --git a/test/core/memory.wast b/test/core/memory.wast index 4539970c6a..cf2de6abab 100644 --- a/test/core/memory.wast +++ b/test/core/memory.wast @@ -237,14 +237,14 @@ (loop (if (i32.eq (get_local 0) (i32.const 0)) - (br 2) + (then (br 2)) ) (set_local 2 (i32.mul (get_local 0) (i32.const 4))) (i32.store (get_local 2) (get_local 0)) (set_local 1 (i32.load (get_local 2))) (if (i32.ne (get_local 0) (get_local 1)) - (return (i32.const 0)) + (then (return (i32.const 0))) ) (set_local 0 (i32.sub (get_local 0) (i32.const 1))) (br 0) @@ -261,14 +261,14 @@ (loop (if (i32.eq (get_local 0) (i32.const 0)) - (br 2) + (then (br 2)) ) (set_local 2 (f64.convert_s/i32 (get_local 0))) (f64.store align=1 (get_local 0) (get_local 2)) (set_local 1 (f64.load align=1 (get_local 0))) (if (f64.ne (get_local 2) (get_local 1)) - (return (i32.const 0)) + (then (return (i32.const 0))) ) (set_local 0 (i32.sub (get_local 0) (i32.const 1))) (br 0) @@ -285,7 +285,7 @@ (f64.load (i32.const 8)) (f64.reinterpret/i64 (i64.const -12345)) ) - (return (f64.const 0)) + (then (return (f64.const 0))) ) (i64.store align=1 (i32.const 9) (i64.const 0)) (i32.store16 align=1 (i32.const 15) (i32.const 16453)) diff --git a/test/core/nop.wast b/test/core/nop.wast index ab83eede26..2862315587 100644 --- a/test/core/nop.wast +++ b/test/core/nop.wast @@ -43,69 +43,73 @@ ) (func (export "as-block-first") (result i32) - (block i32 (nop) (i32.const 2)) + (block (result i32) (nop) (i32.const 2)) ) (func (export "as-block-mid") (result i32) - (block i32 (call $dummy) (nop) (i32.const 2)) + (block (result i32) (call $dummy) (nop) (i32.const 2)) ) (func (export "as-block-last") (result i32) - (block i32 (nop) (call $dummy) (i32.const 3) (nop)) + (block (result i32) (nop) (call $dummy) (i32.const 3) (nop)) ) (func (export "as-block-everywhere") (result i32) - (block i32 (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)) + (block (result i32) + (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop) + ) ) (func (export "as-loop-first") (result i32) - (loop i32 (nop) (i32.const 2)) + (loop (result i32) (nop) (i32.const 2)) ) (func (export "as-loop-mid") (result i32) - (loop i32 (call $dummy) (nop) (i32.const 2)) + (loop (result i32) (call $dummy) (nop) (i32.const 2)) ) (func (export "as-loop-last") (result i32) - (loop i32 (call $dummy) (i32.const 3) (nop)) + (loop (result i32) (call $dummy) (i32.const 3) (nop)) ) (func (export "as-loop-everywhere") (result i32) - (loop i32 (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)) + (loop (result i32) + (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop) + ) ) (func (export "as-if-condition") (param i32) (get_local 0) (nop) (if (then (call $dummy))) ) (func (export "as-if-then") (param i32) - (if (get_local 0) (nop) (call $dummy)) + (if (get_local 0) (then (nop)) (else (call $dummy))) ) (func (export "as-if-else") (param i32) - (if (get_local 0) (call $dummy) (nop)) + (if (get_local 0) (then (call $dummy)) (else (nop))) ) (func (export "as-br-last") (param i32) (result i32) - (block i32 (get_local 0) (nop) (br 0)) + (block (result i32) (get_local 0) (nop) (br 0)) ) (func (export "as-br-everywhere") (param i32) (result i32) - (block i32 (nop) (nop) (get_local 0) (nop) (nop) (br 0)) + (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (br 0)) ) (func (export "as-br_if-mid") (param i32) (result i32) - (block i32 (get_local 0) (nop) (get_local 0) (br_if 0)) + (block (result i32) (get_local 0) (nop) (get_local 0) (br_if 0)) ) (func (export "as-br_if-last") (param i32) (result i32) - (block i32 (get_local 0) (get_local 0) (nop) (br_if 0)) + (block (result i32) (get_local 0) (get_local 0) (nop) (br_if 0)) ) (func (export "as-br_if-everywhere") (param i32) (result i32) - (block i32 + (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (br_if 0) ) ) (func (export "as-br_table-mid") (param i32) (result i32) - (block i32 (get_local 0) (nop) (get_local 0) (br_table 0 0)) + (block (result i32) (get_local 0) (nop) (get_local 0) (br_table 0 0)) ) (func (export "as-br_table-last") (param i32) (result i32) - (block i32 (get_local 0) (get_local 0) (nop) (br_table 0 0)) + (block (result i32) (get_local 0) (get_local 0) (nop) (br_table 0 0)) ) (func (export "as-br_table-everywhere") (param i32) (result i32) - (block i32 + (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (br_table 0 0) ) diff --git a/test/core/return.wast b/test/core/return.wast index 60db41c1f1..48964cffc2 100644 --- a/test/core/return.wast +++ b/test/core/return.wast @@ -35,33 +35,33 @@ (block (nop) (call $dummy) (return)) ) (func (export "as-block-value") (result i32) - (block i32 (nop) (call $dummy) (return (i32.const 2))) + (block (result i32) (nop) (call $dummy) (return (i32.const 2))) ) (func (export "as-loop-first") (result i32) - (loop i32 (return (i32.const 3)) (i32.const 2)) + (loop (result i32) (return (i32.const 3)) (i32.const 2)) ) (func (export "as-loop-mid") (result i32) - (loop i32 (call $dummy) (return (i32.const 4)) (i32.const 2)) + (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2)) ) (func (export "as-loop-last") (result i32) - (loop i32 (nop) (call $dummy) (return (i32.const 5))) + (loop (result i32) (nop) (call $dummy) (return (i32.const 5))) ) (func (export "as-br-value") (result i32) - (block i32 (br 0 (return (i32.const 9)))) + (block (result i32) (br 0 (return (i32.const 9)))) ) (func (export "as-br_if-cond") (block (br_if 0 (return))) ) (func (export "as-br_if-value") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (return (i32.const 8)) (i32.const 1))) (i32.const 7) ) ) (func (export "as-br_if-value-cond") (result i32) - (block i32 + (block (result i32) (drop (br_if 0 (i32.const 6) (return (i32.const 9)))) (i32.const 7) ) ) @@ -70,12 +70,12 @@ (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1) ) (func (export "as-br_table-value") (result i32) - (block i32 + (block (result i32) (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7) ) ) (func (export "as-br_table-value-index") (result i32) - (block i32 + (block (result i32) (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7) ) ) @@ -85,13 +85,19 @@ ) (func (export "as-if-cond") (result i32) - (if i32 (return (i32.const 2)) (i32.const 0) (i32.const 1)) + (if (result i32) + (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1)) + ) ) (func (export "as-if-then") (param i32 i32) (result i32) - (if i32 (get_local 0) (return (i32.const 3)) (get_local 1)) + (if (result i32) + (get_local 0) (then (return (i32.const 3))) (else (get_local 1)) + ) ) (func (export "as-if-else") (param i32 i32) (result i32) - (if i32 (get_local 0) (get_local 1) (return (i32.const 4))) + (if (result i32) + (get_local 0) (then (get_local 1)) (else (return (i32.const 4))) + ) ) (func (export "as-select-first") (param i32 i32) (result i32) diff --git a/test/core/stack.wast b/test/core/stack.wast index f685b17f8c..b3f321ecac 100644 --- a/test/core/stack.wast +++ b/test/core/stack.wast @@ -8,8 +8,8 @@ (loop $loop (if (i64.eq (get_local $i) (i64.const 0)) - (br $done) - (block + (then (br $done)) + (else (set_local $res (i64.mul (get_local $i) (get_local $res))) (set_local $i (i64.sub (get_local $i) (i64.const 1))) ) diff --git a/test/core/switch.wast b/test/core/switch.wast index 2d4565a5dd..829acc0240 100644 --- a/test/core/switch.wast +++ b/test/core/switch.wast @@ -47,7 +47,7 @@ (local $j i64) (set_local $j (i64.const 100)) (return - (block $switch i64 + (block $switch (result i64) (block $7 (block $default (block $4 @@ -87,13 +87,13 @@ ;; Argument switch (func (export "arg") (param $i i32) (result i32) (return - (block $2 i32 + (block $2 (result i32) (i32.add (i32.const 10) - (block $1 i32 + (block $1 (result i32) (i32.add (i32.const 100) - (block $0 i32 + (block $0 (result i32) (i32.add (i32.const 1000) - (block $default i32 + (block $default (result i32) (br_table $0 $1 $2 $default (i32.mul (i32.const 2) (get_local $i)) (i32.and (i32.const 3) (get_local $i)) diff --git a/test/core/token-keyword-separation.fail.wast b/test/core/token-keyword-separation.fail.wast new file mode 100644 index 0000000000..aa29b6d3e2 --- /dev/null +++ b/test/core/token-keyword-separation.fail.wast @@ -0,0 +1 @@ +(module (func (drop (i32.const0)))) diff --git a/test/core/token-number-separation.fail.wast b/test/core/token-number-separation.fail.wast new file mode 100644 index 0000000000..68fb517ce6 --- /dev/null +++ b/test/core/token-number-separation.fail.wast @@ -0,0 +1 @@ +(module (func br 0drop)) diff --git a/test/core/typecheck.wast b/test/core/typecheck.wast index 1d15cc5675..72f6f621f1 100644 --- a/test/core/typecheck.wast +++ b/test/core/typecheck.wast @@ -30,7 +30,7 @@ (assert_invalid (module (func $type-unary-operand-missing-in-else (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (i32.eqz))) (drop) + (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop) )) "type mismatch" ) @@ -78,21 +78,21 @@ (assert_invalid (module (func $type-binary-1st-operand-missing-in-if (i32.const 0) (i32.const 0) (i32.const 0) - (if (i32.add) (drop)) + (if (i32.add) (then (drop))) )) "type mismatch" ) (assert_invalid (module (func $type-binary-2nd-operand-missing-in-if (i32.const 0) (i32.const 0) - (if (i32.const 0) (i32.add) (drop)) + (if (i32.const 0) (then (i32.add)) (else (drop))) )) "type mismatch" ) (assert_invalid (module (func $type-binary-1st-operand-missing-in-else (i32.const 0) (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (i32.add) (i32.const 0))) + (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0))) (drop) (drop) )) "type mismatch" @@ -100,7 +100,7 @@ (assert_invalid (module (func $type-binary-2nd-operand-missing-in-else (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (i32.add))) + (if (result i32) (then (i32.const 0)) (else (i32.add))) (drop) )) "type mismatch" @@ -136,7 +136,7 @@ (assert_invalid (module (func $type-if-operand-missing-in-else (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (if (then)) (i32.const 0))) + (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0))) (drop) )) "type mismatch" @@ -144,7 +144,7 @@ (assert_invalid (module (func $type-br-operand-missing - (block i32 (br 0)) + (block (result i32) (br 0)) (i32.eqz) (drop) )) "type mismatch" @@ -152,7 +152,7 @@ (assert_invalid (module (func $type-br-operand-missing-in-block (i32.const 0) - (block i32 (br 0)) + (block (result i32) (br 0)) (i32.eqz) (drop) )) "type mismatch" @@ -161,7 +161,7 @@ (module (func $type-br-operand-missing-in-if (block (i32.const 0) (i32.const 0) - (if i32 (then (br 0))) + (if (result i32) (then (br 0))) ) (i32.eqz) (drop) )) @@ -171,7 +171,7 @@ (module (func $type-br-operand-missing-in-else (block (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (br 0))) + (if (result i32) (then (i32.const 0)) (else (br 0))) ) (i32.eqz) (drop) )) @@ -208,7 +208,7 @@ (assert_invalid (module (func $type-return-operand-missing-in-else (result i32) (i32.const 0) (i32.const 0) - (if i32 (then (i32.const 0)) (else (return))) (drop) + (if (result i32) (then (i32.const 0)) (else (return))) (drop) )) "type mismatch" ) @@ -216,7 +216,7 @@ ;; TODO(stack): more of the above ;; if condition -(assert_invalid (module (func (if (f32.const 0) (nop) (nop)))) "type mismatch") +(assert_invalid (module (func (if (f32.const 0) (then)))) "type mismatch") ;; br_if condition (assert_invalid (module (func (block (br_if 0 (f32.const 0))))) "type mismatch") diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast index f0d2c73908..30df789e21 100644 --- a/test/core/unreachable.wast +++ b/test/core/unreachable.wast @@ -24,62 +24,74 @@ ) (func (export "as-block-first") (result i32) - (block i32 (unreachable) (i32.const 2)) + (block (result i32) (unreachable) (i32.const 2)) ) (func (export "as-block-mid") (result i32) - (block i32 (call $dummy) (unreachable) (i32.const 2)) + (block (result i32) (call $dummy) (unreachable) (i32.const 2)) ) (func (export "as-block-last") (block (nop) (call $dummy) (unreachable)) ) (func (export "as-block-value") (result i32) - (block i32 (nop) (call $dummy) (unreachable)) + (block (result i32) (nop) (call $dummy) (unreachable)) ) (func (export "as-block-broke") (result i32) - (block i32 (call $dummy) (br 0 (i32.const 1)) (unreachable)) + (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable)) ) (func (export "as-loop-first") (result i32) - (loop i32 (unreachable) (i32.const 2)) + (loop (result i32) (unreachable) (i32.const 2)) ) (func (export "as-loop-mid") (result i32) - (loop i32 (call $dummy) (unreachable) (i32.const 2)) + (loop (result i32) (call $dummy) (unreachable) (i32.const 2)) ) (func (export "as-loop-last") (loop (nop) (call $dummy) (unreachable)) ) (func (export "as-loop-broke") (result i32) - (block i32 (loop i32 (call $dummy) (br 1 (i32.const 1)) (unreachable))) + (block (result i32) + (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable)) + ) ) (func (export "as-br-value") (result i32) - (block i32 (br 0 (unreachable))) + (block (result i32) (br 0 (unreachable))) ) (func (export "as-br_if-cond") (block (br_if 0 (unreachable))) ) (func (export "as-br_if-value") (result i32) - (block i32 (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7)) + (block (result i32) + (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7) + ) ) (func (export "as-br_if-value-cond") (result i32) - (block i32 (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7)) + (block (result i32) + (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7) + ) ) (func (export "as-br_table-index") (block (br_table 0 0 0 (unreachable))) ) (func (export "as-br_table-value") (result i32) - (block i32 (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7)) + (block (result i32) + (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7) + ) ) (func (export "as-br_table-value-2") (result i32) - (block i32 (block i32 (br_table 0 1 (unreachable) (i32.const 1)))) + (block (result i32) + (block (result i32) (br_table 0 1 (unreachable) (i32.const 1))) + ) ) (func (export "as-br_table-value-index") (result i32) - (block i32 (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7)) + (block (result i32) + (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7) + ) ) (func (export "as-br_table-value-and-index") (result i32) - (block i32 (br_table 0 0 (unreachable)) (i32.const 8)) + (block (result i32) (br_table 0 0 (unreachable)) (i32.const 8)) ) (func (export "as-return-value") (result i64) @@ -87,13 +99,13 @@ ) (func (export "as-if-cond") (result i32) - (if i32 (unreachable) (i32.const 0) (i32.const 1)) + (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1))) ) (func (export "as-if-then") (param i32 i32) (result i32) - (if i32 (get_local 0) (unreachable) (get_local 1)) + (if (result i32) (get_local 0) (then (unreachable)) (else (get_local 1))) ) (func (export "as-if-else") (param i32 i32) (result i32) - (if i32 (get_local 0) (get_local 1) (unreachable)) + (if (result i32) (get_local 0) (then (get_local 1)) (else (unreachable))) ) (func (export "as-select-first") (param i32 i32) (result i32) diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast index f0ad5ca7ff..8c73deb9c8 100644 --- a/test/core/unreached-invalid.wast +++ b/test/core/unreached-invalid.wast @@ -99,7 +99,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-after-break (result i32) - (block i32 (i32.const 1) (br 0) (f32.const 0)) + (block (result i32) (i32.const 1) (br 0) (f32.const 0)) )) "type mismatch" ) @@ -111,7 +111,7 @@ ) (assert_invalid (module (func $type-loop-value-num-vs-num-after-break (result i32) - (loop i32 (br 1 (i32.const 1)) (f32.const 0)) + (loop (result i32) (br 1 (i32.const 1)) (f32.const 0)) )) "type mismatch" ) @@ -160,7 +160,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-after-return (result i32) - (block i32 (i32.const 1) (return (i32.const 0)) (f32.const 0)) + (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0)) )) "type mismatch" ) @@ -172,7 +172,7 @@ ) (assert_invalid (module (func $type-loop-value-num-vs-num-after-return (result i32) - (loop i32 (return (i32.const 1)) (f32.const 0)) + (loop (result i32) (return (i32.const 1)) (f32.const 0)) )) "type mismatch" ) @@ -221,7 +221,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-after-unreachable (result i32) - (block i32 (i32.const 1) (unreachable) (f32.const 0)) + (block (result i32) (i32.const 1) (unreachable) (f32.const 0)) )) "type mismatch" ) @@ -233,7 +233,7 @@ ) (assert_invalid (module (func $type-loop-value-num-vs-num-after-unreachable (result i32) - (loop i32 (unreachable) (f32.const 0)) + (loop (result i32) (unreachable) (f32.const 0)) )) "type mismatch" ) @@ -283,7 +283,7 @@ (assert_invalid (module (func $type-block-value-num-vs-num-after-nested-unreachable (result i32) - (block i32 (i32.const 1) (block (unreachable)) (f32.const 0)) + (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0)) )) "type mismatch" ) @@ -296,7 +296,7 @@ (assert_invalid (module (func $type-loop-value-num-vs-num-after-nested-unreachable (result i32) - (loop i32 (block (unreachable)) (f32.const 0)) + (loop (result i32) (block (unreachable)) (f32.const 0)) )) "type mismatch" ) @@ -346,7 +346,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32) - (block i32 (i32.const 1) (loop (br 0)) (f32.const 0)) + (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0)) )) "type mismatch" ) @@ -358,7 +358,7 @@ ) (assert_invalid (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32) - (loop i32 (loop (br 0)) (f32.const 0)) + (loop (result i32) (loop (br 0)) (f32.const 0)) )) "type mismatch" ) @@ -407,7 +407,7 @@ ) (assert_invalid (module (func $type-if-value-num-vs-num-in-dead-body (result i32) - (if i32 (i32.const 0) (then (f32.const 0))) + (if (result i32) (i32.const 0) (then (f32.const 0))) )) "type mismatch" ) @@ -419,7 +419,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-in-dead-body (result i32) - (if i32 (i32.const 0) (then (block i32 (f32.const 0)))) + (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0)))) )) "type mismatch" ) @@ -431,7 +431,7 @@ ) (assert_invalid (module (func $type-block-value-num-vs-num-in-dead-body (result i32) - (if i32 (i32.const 0) (then (loop i32 (f32.const 0)))) + (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0)))) )) "type mismatch" ) @@ -445,7 +445,7 @@ (assert_invalid (module (func $type-br-second-num-vs-num (result i32) - (block i32 (br 0 (i32.const 1)) (br 0 (f64.const 1))) + (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1))) )) "type mismatch" ) @@ -464,14 +464,14 @@ ) (assert_invalid (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32) - (block i32 (unreachable) (br_table 0 (f32.const 0) (i32.const 1))) + (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1))) )) "type mismatch" ) (assert_invalid (module (func $type-br_table-label-num-vs-label-void-after-unreachable (block - (block f32 + (block (result f32) (unreachable) (br_table 0 1 0 (i32.const 1)) ) @@ -482,8 +482,8 @@ ) (assert_invalid (module (func $type-br_table-label-num-vs-label-num-after-unreachable - (block f64 - (block f32 + (block (result f64) + (block (result f32) (unreachable) (br_table 0 1 1 (i32.const 1)) ) @@ -509,7 +509,7 @@ ) (assert_invalid (module (func $type-block-value-nested-unreachable-num-vs-num (result i32) - (block i64 (i64.const 0) (block (unreachable))) + (block (result i64) (i64.const 0) (block (unreachable))) )) "type mismatch" ) @@ -528,13 +528,13 @@ ) (assert_invalid (module (func $type-block-value-nested-br-void-vs-num (result i32) - (block i32 (block (br 1 (i32.const 0)))) + (block (result i32) (block (br 1 (i32.const 0)))) )) "type mismatch" ) (assert_invalid (module (func $type-block-value-nested-br-num-vs-num (result i32) - (block i32 (i64.const 0) (block (br 1 (i32.const 0)))) + (block (result i32) (i64.const 0) (block (br 1 (i32.const 0)))) )) "type mismatch" ) @@ -547,13 +547,15 @@ ) (assert_invalid (module (func $type-block-value-nested2-br-void-vs-num (result i32) - (block i32 (block (block (br 2 (i32.const 0))))) + (block (result i32) (block (block (br 2 (i32.const 0))))) )) "type mismatch" ) (assert_invalid (module (func $type-block-value-nested2-br-num-vs-num (result i32) - (block i32 (block i64 (i64.const 0) (block (br 2 (i32.const 0))))) + (block (result i32) + (block (result i64) (i64.const 0) (block (br 2 (i32.const 0)))) + ) )) "type mismatch" ) @@ -578,7 +580,7 @@ ) (assert_invalid (module (func $type-block-value-nested-return-num-vs-num (result i32) - (block i64 (i64.const 0) (block (return (i32.const 0)))) + (block (result i64) (i64.const 0) (block (return (i32.const 0)))) )) "type mismatch" ) @@ -604,7 +606,7 @@ ) (assert_invalid (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32) - (loop i64 (i64.const 0) (block (unreachable))) + (loop (result i64) (i64.const 0) (block (unreachable))) )) "type mismatch" ) diff --git a/test/core/unwind.wast b/test/core/unwind.wast index b993f2a873..40b0dcf6f2 100644 --- a/test/core/unwind.wast +++ b/test/core/unwind.wast @@ -27,28 +27,30 @@ (block (i32.const 3) (i64.const 1) (br 0)) (i32.const 9) ) (func (export "block-unwind-by-br-value") (result i32) - (block i32 (i32.const 3) (i64.const 1) (br 0 (i32.const 9))) + (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9))) ) (func (export "block-unwind-by-br_table") (result i32) (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9) ) (func (export "block-unwind-by-br_table-value") (result i32) - (block i32 + (block (result i32) (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0)) ) ) (func (export "block-unwind-by-return") (result i32) - (block i32 (i32.const 3) (i64.const 1) (return (i32.const 9))) + (block (result i32) (i32.const 3) (i64.const 1) (return (i32.const 9))) ) (func (export "block-nested-unwind-by-unreachable") (result i32) - (block i32 (i32.const 3) (block (i64.const 1) (unreachable))) + (block (result i32) (i32.const 3) (block (i64.const 1) (unreachable))) ) (func (export "block-nested-unwind-by-br") (result i32) (block (i32.const 3) (block (i64.const 1) (br 1)) (drop)) (i32.const 9) ) (func (export "block-nested-unwind-by-br-value") (result i32) - (block i32 (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9)))) + (block (result i32) + (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9))) + ) ) (func (export "block-nested-unwind-by-br_table") (result i32) (block @@ -58,23 +60,25 @@ (i32.const 9) ) (func (export "block-nested-unwind-by-br_table-value") (result i32) - (block i32 + (block (result i32) (i32.const 3) (block (i64.const 1) (br_table 1 (i32.const 9) (i32.const 1))) ) ) (func (export "block-nested-unwind-by-return") (result i32) - (block i32 (i32.const 3) (block (i64.const 1) (return (i32.const 9)))) + (block (result i32) + (i32.const 3) (block (i64.const 1) (return (i32.const 9))) + ) ) (func (export "unary-after-unreachable") (result i32) (f32.const 0) (unreachable) (i64.eqz) ) (func (export "unary-after-br") (result i32) - (block i32 (f32.const 0) (br 0 (i32.const 9)) (i64.eqz)) + (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz)) ) (func (export "unary-after-br_table") (result i32) - (block i32 + (block (result i32) (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz) ) ) @@ -86,10 +90,12 @@ (f32.const 0) (f64.const 1) (unreachable) (i64.eq) ) (func (export "binary-after-br") (result i32) - (block i32 (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq)) + (block (result i32) + (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq) + ) ) (func (export "binary-after-br_table") (result i32) - (block i32 + (block (result i32) (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0)) (i64.eq) ) @@ -102,12 +108,12 @@ (f32.const 0) (f64.const 1) (i64.const 0) (unreachable) (select) ) (func (export "select-after-br") (result i32) - (block i32 + (block (result i32) (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select) ) ) (func (export "select-after-br_table") (result i32) - (block i32 + (block (result i32) (f32.const 0) (f64.const 1) (i64.const 0) (br_table 0 (i32.const 9) (i32.const 0)) (select) @@ -118,31 +124,35 @@ ) (func (export "block-value-after-unreachable") (result i32) - (block i32 (f32.const 0) (unreachable)) + (block (result i32) (f32.const 0) (unreachable)) ) (func (export "block-value-after-br") (result i32) - (block i32 (f32.const 0) (br 0 (i32.const 9))) + (block (result i32) (f32.const 0) (br 0 (i32.const 9))) ) (func (export "block-value-after-br_table") (result i32) - (block i32 (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0))) + (block (result i32) + (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) + ) ) (func (export "block-value-after-return") (result i32) - (block i32 (f32.const 0) (return (i32.const 9))) + (block (result i32) (f32.const 0) (return (i32.const 9))) ) (func (export "loop-value-after-unreachable") (result i32) - (loop i32 (f32.const 0) (unreachable)) + (loop (result i32) (f32.const 0) (unreachable)) ) (func (export "loop-value-after-br") (result i32) - (block i32 (loop i32 (f32.const 0) (br 1 (i32.const 9)))) + (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9)))) ) (func (export "loop-value-after-br_table") (result i32) - (block i32 - (loop i32 (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0))) + (block (result i32) + (loop (result i32) + (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0)) + ) ) ) (func (export "loop-value-after-return") (result i32) - (loop i32 (f32.const 0) (return (i32.const 9))) + (loop (result i32) (f32.const 0) (return (i32.const 9))) ) )