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 07a6298c4f..90a64b42d9 100644 Binary files a/test/core/comments.wast and b/test/core/comments.wast differ 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))) ) )