summaryrefslogtreecommitdiff
path: root/test/example
diff options
context:
space:
mode:
Diffstat (limited to 'test/example')
-rw-r--r--test/example/c-api-kitchen-sink.c16
-rw-r--r--test/example/c-api-kitchen-sink.txt42
-rw-r--r--test/example/relooper-fuzz.c267
-rw-r--r--test/example/relooper-fuzz.txt255
4 files changed, 557 insertions, 23 deletions
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index 4a63e931d..db1903cfd 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -165,9 +165,15 @@ void test_core() {
BinaryenBreak(module, "the-body", NULL, NULL),
BinaryenSwitch(module, switchValueNames, 1, "the-value", makeInt32(module, 0), makeInt32(module, 1)),
BinaryenSwitch(module, switchBodyNames, 1, "the-body", makeInt32(module, 2), NULL),
- BinaryenCall(module, "kitchen-sinker", callOperands4, 4),
- BinaryenCallImport(module, "an-imported", callOperands2, 2),
- BinaryenCallIndirect(module, makeInt32(module, 2449), callOperands4, 4, iiIfF),
+ BinaryenUnary(module, BinaryenEqZ(), // check the output type of the call node
+ BinaryenCall(module, "kitchen-sinker", callOperands4, 4, BinaryenInt32())
+ ),
+ BinaryenUnary(module, BinaryenEqZ(), // check the output type of the call node
+ BinaryenCallImport(module, "an-imported", callOperands2, 2, BinaryenFloat32())
+ ),
+ BinaryenUnary(module, BinaryenEqZ(), // check the output type of the call node
+ BinaryenCallIndirect(module, makeInt32(module, 2449), callOperands4, 4, iiIfF)
+ ),
BinaryenGetLocal(module, 0, BinaryenInt32()),
BinaryenSetLocal(module, 0, makeInt32(module, 101)),
BinaryenLoad(module, 4, 0, 0, 0, BinaryenInt32(), makeInt32(module, 1)),
@@ -195,8 +201,8 @@ void test_core() {
// Imports
BinaryenType iparams[2] = { BinaryenInt32(), BinaryenFloat64() };
- BinaryenFunctionTypeRef viF = BinaryenAddFunctionType(module, "viF", BinaryenNone(), iparams, 2);
- BinaryenAddImport(module, "an-imported", "module", "base", viF);
+ BinaryenFunctionTypeRef fiF = BinaryenAddFunctionType(module, "fiF", BinaryenFloat32(), iparams, 2);
+ BinaryenAddImport(module, "an-imported", "module", "base", fiF);
// Exports
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index cb037d80c..7a1366888 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -10,9 +10,9 @@ BinaryenFloat64: 4
(export "mem" memory)
(start $starter)
(type $iiIfF (func (param i32 i64 f32 f64) (result i32)))
- (type $viF (func (param i32 f64)))
+ (type $fiF (func (param i32 f64) (result f32)))
(type $v (func))
- (import $an-imported "module" "base" (param i32 f64))
+ (import $an-imported "module" "base" (param i32 f64) (result f32))
(export "kitchen_sinker" $kitchen-sinker)
(table $kitchen-sinker)
(func $kitchen-sinker (type $iiIfF) (param $0 i32) (param $1 i64) (param $2 f32) (param $3 f64) (result i32)
@@ -293,22 +293,28 @@ BinaryenFloat64: 4
(br_table $the-body $the-body
(i32.const 2)
)
- (call $kitchen-sinker
- (i32.const 13)
- (i64.const 37)
- (f32.const 1.2999999523162842)
- (f64.const 3.7)
- )
- (call_import $an-imported
- (i32.const 13)
- (f64.const 3.7)
- )
- (call_indirect $iiIfF
- (i32.const 2449)
- (i32.const 13)
- (i64.const 37)
- (f32.const 1.2999999523162842)
- (f64.const 3.7)
+ (i32.eqz
+ (call $kitchen-sinker
+ (i32.const 13)
+ (i64.const 37)
+ (f32.const 1.2999999523162842)
+ (f64.const 3.7)
+ )
+ )
+ (f32.eqz
+ (call_import $an-imported
+ (i32.const 13)
+ (f64.const 3.7)
+ )
+ )
+ (i32.eqz
+ (call_indirect $iiIfF
+ (i32.const 2449)
+ (i32.const 13)
+ (i64.const 37)
+ (f32.const 1.2999999523162842)
+ (f64.const 3.7)
+ )
)
(get_local $0)
(set_local $0
diff --git a/test/example/relooper-fuzz.c b/test/example/relooper-fuzz.c
new file mode 100644
index 000000000..ba9bcb3ed
--- /dev/null
+++ b/test/example/relooper-fuzz.c
@@ -0,0 +1,267 @@
+
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "binaryen-c.h"
+
+// globals: address 4 is index
+// decisions are at address 8+
+
+int main() {
+ BinaryenModuleRef module = BinaryenModuleCreate();
+
+ // check()
+
+ // if the end, halt
+ BinaryenExpressionRef halter = BinaryenIf(module,
+ BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenLoad(module, 4, 0, 0, 0, BinaryenInt32(), BinaryenConst(module, BinaryenLiteralInt32(4))),
+ BinaryenConst(module, BinaryenLiteralInt32(4 * 27)) // jumps of 4 bytes
+ ),
+ BinaryenUnreachable(module),
+ NULL
+ );
+ // increment index
+ BinaryenExpressionRef incer = BinaryenStore(module,
+ 4, 0, 0,
+ BinaryenConst(module, BinaryenLiteralInt32(4)),
+ BinaryenBinary(module,
+ BinaryenAdd(),
+ BinaryenLoad(module, 4, 0, 0, 0, BinaryenInt32(), BinaryenConst(module, BinaryenLiteralInt32(4))),
+ BinaryenConst(module, BinaryenLiteralInt32(4))
+ )
+ );
+
+ // optionally, print the return value
+ BinaryenExpressionRef args[] = {
+ BinaryenBinary(module,
+ BinaryenSub(),
+ BinaryenConst(module, BinaryenLiteralInt32(0)),
+ BinaryenLoad(module,
+ 4, 0, 4, 0, BinaryenInt32(),
+ BinaryenLoad(module, 4, 0, 0, 0, BinaryenInt32(), BinaryenConst(module, BinaryenLiteralInt32(4)))
+ )
+ )
+ };
+ BinaryenExpressionRef debugger;
+ if (1) debugger = BinaryenCallImport(module, "print", args, 1, BinaryenNone());
+ else debugger = BinaryenNop(module);
+
+ // return the decision. need to subtract 4 that we just added, and add 8 since that's where we start, so overall offset 4
+ BinaryenExpressionRef returner = BinaryenLoad(module,
+ 4, 0, 4, 0, BinaryenInt32(),
+ BinaryenLoad(module, 4, 0, 0, 0, BinaryenInt32(), BinaryenConst(module, BinaryenLiteralInt32(4)))
+ );
+ BinaryenExpressionRef checkBodyList[] = { halter, incer, debugger, returner };
+ BinaryenExpressionRef checkBody = BinaryenBlock(module, NULL, checkBodyList, sizeof(checkBodyList) / sizeof(BinaryenExpressionRef));
+ BinaryenFunctionTypeRef i = BinaryenAddFunctionType(module, "i", BinaryenInt32(), NULL, 0);
+ BinaryenAddFunction(module, "check", i, NULL, 0, checkBody);
+
+ // contents of main() begin here
+
+ RelooperRef relooper = RelooperCreate();
+
+
+ RelooperBlockRef b0;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(0)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b0 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b1;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(1)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b1 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b2;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(2)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b2 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b3;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(3)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b3 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b4;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(4)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b4 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b5;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(5)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b5 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b6;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(6)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b6 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b7;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(7)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b7 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperBlockRef b8;
+ {
+ BinaryenExpressionRef args[] = { BinaryenConst(module, BinaryenLiteralInt32(8)) };
+ BinaryenExpressionRef list[] = {
+ BinaryenCallImport(module, "print", args, 1, BinaryenNone()),
+ BinaryenSetLocal(module, 0, BinaryenCall(module, "check", NULL, 0, BinaryenInt32()))
+ };
+ b8 = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2));
+ }
+
+ RelooperAddBranch(b0, b5, BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenBinary(module,
+ BinaryenRemU(),
+ BinaryenGetLocal(module, 0, BinaryenInt32()),
+ BinaryenConst(module, BinaryenLiteralInt32(2))
+ ),
+ BinaryenConst(module, BinaryenLiteralInt32(0))
+ ), NULL);
+
+ RelooperAddBranch(b0, b8, NULL, NULL);
+
+ RelooperAddBranch(b1, b5, NULL, NULL);
+
+ RelooperAddBranch(b2, b5, NULL, NULL);
+
+ RelooperAddBranch(b3, b5, BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenBinary(module,
+ BinaryenRemU(),
+ BinaryenGetLocal(module, 0, BinaryenInt32()),
+ BinaryenConst(module, BinaryenLiteralInt32(2))
+ ),
+ BinaryenConst(module, BinaryenLiteralInt32(0))
+ ), NULL);
+
+ RelooperAddBranch(b3, b8, NULL, NULL);
+
+ RelooperAddBranch(b4, b4, BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenBinary(module,
+ BinaryenRemU(),
+ BinaryenGetLocal(module, 0, BinaryenInt32()),
+ BinaryenConst(module, BinaryenLiteralInt32(3))
+ ),
+ BinaryenConst(module, BinaryenLiteralInt32(0))
+ ), NULL);
+
+ RelooperAddBranch(b4, b5, BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenBinary(module,
+ BinaryenRemU(),
+ BinaryenGetLocal(module, 0, BinaryenInt32()),
+ BinaryenConst(module, BinaryenLiteralInt32(3))
+ ),
+ BinaryenConst(module, BinaryenLiteralInt32(1))
+ ), NULL);
+
+ RelooperAddBranch(b4, b2, NULL, NULL);
+
+ RelooperAddBranch(b5, b4, BinaryenBinary(module,
+ BinaryenEq(),
+ BinaryenBinary(module,
+ BinaryenRemU(),
+ BinaryenGetLocal(module, 0, BinaryenInt32()),
+ BinaryenConst(module, BinaryenLiteralInt32(2))
+ ),
+ BinaryenConst(module, BinaryenLiteralInt32(0))
+ ), NULL);
+
+ RelooperAddBranch(b5, b5, NULL, NULL);
+
+ RelooperAddBranch(b6, b6, NULL, NULL);
+
+ RelooperAddBranch(b7, b8, NULL, NULL);
+
+ RelooperAddBranch(b8, b4, NULL, NULL);
+
+ BinaryenExpressionRef body = RelooperRenderAndDispose(relooper, b0, 1, module);
+
+ int decisions[] = { 89, 12, 78, 149, 118, 179, 127, 80, 21, 34, 119, 98, 38, 29, 36, 147, 13, 55, 166, 16, 143, 52, 130, 150, 176, 91, 34 };
+ int numDecisions = sizeof(decisions)/sizeof(int);
+
+ BinaryenExpressionRef full[numDecisions + 1]; // write out all the decisions, then the body of the function
+
+ for (int i = 0; i < numDecisions; i++) {
+ full[i] = BinaryenStore(module,
+ 4, 0, 0,
+ BinaryenConst(module, BinaryenLiteralInt32(8 + 4 * i)),
+ BinaryenConst(module, BinaryenLiteralInt32(decisions[i]))
+ );
+ }
+ full[numDecisions] = body;
+ BinaryenExpressionRef all = BinaryenBlock(module, NULL, full, numDecisions + 1);
+
+ BinaryenFunctionTypeRef v = BinaryenAddFunctionType(module, "v", BinaryenNone(), NULL, 0);
+ BinaryenType localTypes[] = { BinaryenInt32(), BinaryenInt32() }; // state, free-for-label
+ BinaryenFunctionRef theMain = BinaryenAddFunction(module, "main", v, localTypes, 2, all);
+ BinaryenSetStart(module, theMain);
+
+ // import
+
+ BinaryenType iparams[] = { BinaryenInt32() };
+ BinaryenFunctionTypeRef vi = BinaryenAddFunctionType(module, "vi", BinaryenNone(), iparams, 1);
+ BinaryenAddImport(module, "print", "spectest", "print", vi);
+
+ // memory
+ BinaryenSetMemory(module, 1, 1, "mem", NULL, NULL, NULL, 0);
+
+ BinaryenModuleOptimize(module);
+
+ assert(BinaryenModuleValidate(module));
+
+ // write it out
+
+ BinaryenModulePrint(module);
+
+ BinaryenModuleDispose(module);
+
+ return 0;
+}
diff --git a/test/example/relooper-fuzz.txt b/test/example/relooper-fuzz.txt
new file mode 100644
index 000000000..7dab4c5be
--- /dev/null
+++ b/test/example/relooper-fuzz.txt
@@ -0,0 +1,255 @@
+(module
+ (memory 1 1)
+ (export "mem" memory)
+ (start $main)
+ (type $i (func (result i32)))
+ (type $v (func))
+ (type $vi (func (param i32)))
+ (import $print "spectest" "print" (param i32))
+ (func $check (type $i) (result i32)
+ (if
+ (i32.eq
+ (i32.load
+ (i32.const 4)
+ )
+ (i32.const 108)
+ )
+ (unreachable)
+ )
+ (i32.store
+ (i32.const 4)
+ (i32.add
+ (i32.load
+ (i32.const 4)
+ )
+ (i32.const 4)
+ )
+ )
+ (call_import $print
+ (i32.sub
+ (i32.const 0)
+ (i32.load offset=4
+ (i32.load
+ (i32.const 4)
+ )
+ )
+ )
+ )
+ (i32.load offset=4
+ (i32.load
+ (i32.const 4)
+ )
+ )
+ )
+ (func $main (type $v)
+ (local $0 i32)
+ (local $1 i32)
+ (i32.store
+ (i32.const 8)
+ (i32.const 89)
+ )
+ (i32.store
+ (i32.const 12)
+ (i32.const 12)
+ )
+ (i32.store
+ (i32.const 16)
+ (i32.const 78)
+ )
+ (i32.store
+ (i32.const 20)
+ (i32.const 149)
+ )
+ (i32.store
+ (i32.const 24)
+ (i32.const 118)
+ )
+ (i32.store
+ (i32.const 28)
+ (i32.const 179)
+ )
+ (i32.store
+ (i32.const 32)
+ (i32.const 127)
+ )
+ (i32.store
+ (i32.const 36)
+ (i32.const 80)
+ )
+ (i32.store
+ (i32.const 40)
+ (i32.const 21)
+ )
+ (i32.store
+ (i32.const 44)
+ (i32.const 34)
+ )
+ (i32.store
+ (i32.const 48)
+ (i32.const 119)
+ )
+ (i32.store
+ (i32.const 52)
+ (i32.const 98)
+ )
+ (i32.store
+ (i32.const 56)
+ (i32.const 38)
+ )
+ (i32.store
+ (i32.const 60)
+ (i32.const 29)
+ )
+ (i32.store
+ (i32.const 64)
+ (i32.const 36)
+ )
+ (i32.store
+ (i32.const 68)
+ (i32.const 147)
+ )
+ (i32.store
+ (i32.const 72)
+ (i32.const 13)
+ )
+ (i32.store
+ (i32.const 76)
+ (i32.const 55)
+ )
+ (i32.store
+ (i32.const 80)
+ (i32.const 166)
+ )
+ (i32.store
+ (i32.const 84)
+ (i32.const 16)
+ )
+ (i32.store
+ (i32.const 88)
+ (i32.const 143)
+ )
+ (i32.store
+ (i32.const 92)
+ (i32.const 52)
+ )
+ (i32.store
+ (i32.const 96)
+ (i32.const 130)
+ )
+ (i32.store
+ (i32.const 100)
+ (i32.const 150)
+ )
+ (i32.store
+ (i32.const 104)
+ (i32.const 176)
+ )
+ (i32.store
+ (i32.const 108)
+ (i32.const 91)
+ )
+ (i32.store
+ (i32.const 112)
+ (i32.const 34)
+ )
+ (call_import $print
+ (i32.const 0)
+ )
+ (if
+ (i32.eq
+ (i32.rem_u
+ (set_local $0
+ (call $check)
+ )
+ (i32.const 2)
+ )
+ (i32.const 0)
+ )
+ (set_local $1
+ (i32.const 6)
+ )
+ (block
+ (call_import $print
+ (i32.const 8)
+ )
+ (set_local $0
+ (call $check)
+ )
+ )
+ )
+ (loop $shape$3$break $shape$3$continue
+ (if
+ (i32.eq
+ (get_local $1)
+ (i32.const 6)
+ )
+ (block
+ (set_local $1
+ (i32.const 0)
+ )
+ (call_import $print
+ (i32.const 5)
+ )
+ (if
+ (i32.eq
+ (i32.rem_u
+ (set_local $0
+ (call $check)
+ )
+ (i32.const 2)
+ )
+ (i32.const 0)
+ )
+ (br $shape$3$continue)
+ (block
+ (set_local $1
+ (i32.const 6)
+ )
+ (br $shape$3$continue)
+ )
+ )
+ )
+ )
+ (call_import $print
+ (i32.const 4)
+ )
+ (if
+ (i32.eq
+ (i32.rem_u
+ (set_local $0
+ (call $check)
+ )
+ (i32.const 3)
+ )
+ (i32.const 0)
+ )
+ (br $shape$3$continue)
+ (if
+ (i32.eq
+ (i32.rem_u
+ (get_local $0)
+ (i32.const 3)
+ )
+ (i32.const 1)
+ )
+ (block
+ (set_local $1
+ (i32.const 6)
+ )
+ (br $shape$3$continue)
+ )
+ )
+ )
+ (call_import $print
+ (i32.const 2)
+ )
+ (set_local $0
+ (call $check)
+ )
+ (set_local $1
+ (i32.const 6)
+ )
+ (br $shape$3$continue)
+ )
+ )
+)
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-08 04:18:36 +0000