int main() {
BinaryenModuleRef module = BinaryenModuleCreate();
#if 1
#if 0
BinaryenType params[4] = { BinaryenInt32(), BinaryenInt64(), BinaryenFloat32(), BinaryenFloat64() };
BinaryenFunctionTypeRef iiIfF = BinaryenAddFunctionType(module, "iiIfF", BinaryenInt32(), params, 4);
BinaryenExpressionRef callOperands4[] = { makeInt32(module, 13), makeInt64(module, 37), makeFloat32(module, 1.3f), makeFloat64(module, 3.7) };
BinaryenExpressionRef c = BinaryenCallImport(module, "importname", callOperands4, 4, BinaryenInt32());
#else
BinaryenFunctionTypeRef i = BinaryenAddFunctionType(module, "i", BinaryenInt32(), 0, 0);
BinaryenAddImport(module, "importname", "WScript.Shell", "CurrentDirectory", i);
BinaryenExpressionRef c = BinaryenCallImport(module, "importname", 0, 0, BinaryenInt32());
#endif
#else
BinaryenExpressionRef b = BinaryenReturn(module, makeInt32(module, 123));
BinaryenFunctionRef fiiIfF = BinaryenAddFunction(module, "fiiIfF", iiIfF, NULL, 0, b);
BinaryenExpressionRef callOperands4[] = { makeInt32(module, 13), makeInt64(module, 37), makeFloat32(module, 1.3f), makeFloat64(module, 3.7) };
#if 0
BinaryenExpressionRef c = BinaryenCall(module, "fiiIfF", callOperands4, 4, BinaryenNop(module));
#else
BinaryenExpressionRef c = BinaryenCallIndirect(module, makeInt32(module, 123), callOperands4, 4, iiIfF);
#endif
#endif
BinaryenFunctionTypeRef v = BinaryenAddFunctionType(module, "v", BinaryenNone(), NULL, 0);
BinaryenFunctionRef f = BinaryenAddFunction(module, "f", v, NULL, 0, c);
BinaryenExpressionRef s = BinaryenCall(module, "f", NULL, 0, BinaryenNone());
BinaryenFunctionRef starter = BinaryenAddFunction(module, "starter", v, NULL, 0, s);
// BinaryenSetStart(module, starter);
BinaryenAddExport(module, "starter", "starter");
printf("validate module\n");
assert(BinaryenModuleValidate(module));
char buffer[1024];
size_t size;
printf("write module\n");
size = BinaryenModuleWrite(module, buffer, 1024);
assert(size > 0); // must have non-zero size
assert(size < 512); // must be very small
#if 1
// must Dispose, BinaryenModuleRead to populate unimplemented param properties, maybe others
printf("dispose module\n");
BinaryenModuleDispose(module);
printf("read module\n");
module = BinaryenModuleRead(buffer, size);
printf("validate module\n");
assert(BinaryenModuleValidate(module));
#endif
printf("print module\n");
BinaryenModulePrint(module);
struct BinaryenLiteral retVal;
BinaryenRun(module, "starter", &retVal);
char printbuf[64];
printf("retVal: %s\n", BinaryenLiteralPrint(printbuf, sizeof(printbuf), retVal));
printf("dispose module\n");
BinaryenModuleDispose(module);
}
int main() {
std::map<size_t, BinaryenFunctionTypeRef> functionTypes;
std::map<size_t, BinaryenExpressionRef> expressions;
std::map<size_t, BinaryenFunctionRef> functions;
std::map<size_t, RelooperBlockRef> relooperBlocks;
BinaryenModuleRef the_module = NULL;
RelooperRef the_relooper = NULL;
the_module = BinaryenModuleCreate();
expressions[size_t(NULL)] = BinaryenExpressionRef(NULL);
BinaryenModuleAutoDrop(the_module);
{
const char* segments[] = { 0 };
int8_t segmentPassive[] = { 0 };
BinaryenExpressionRef segmentOffsets[] = { 0 };
BinaryenIndex segmentSizes[] = { 0 };
BinaryenSetMemory(the_module, 256, 256, "memory", segments, segmentPassive, segmentOffsets, segmentSizes, 0, 0);
}
the_relooper = RelooperCreate(the_module);
{
BinaryenExpressionRef children[] = { 0 };
expressions[1] = BinaryenBlock(the_module, "bb0", children, 0, BinaryenTypeAuto());
}
relooperBlocks[0] = RelooperAddBlock(the_relooper, expressions[1]);
expressions[2] = BinaryenGetLocal(the_module, 0, 1);
expressions[3] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
expressions[4] = BinaryenStore(the_module, 4, 0, 0, expressions[3], expressions[2], 1);
expressions[5] = BinaryenReturn(the_module, expressions[0]);
{
BinaryenExpressionRef children[] = { expressions[4], expressions[5] };
expressions[6] = BinaryenBlock(the_module, "bb1", children, 2, BinaryenTypeAuto());
}
relooperBlocks[1] = RelooperAddBlock(the_relooper, expressions[6]);
RelooperAddBranch(relooperBlocks[0], relooperBlocks[1], expressions[0], expressions[0]);
{
BinaryenType paramTypes[] = { 0 };
functionTypes[0] = BinaryenAddFunctionType(the_module, "rustfn-0-3", 0, paramTypes, 0);
}
expressions[7] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
expressions[8] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[7]);
expressions[9] = BinaryenSetLocal(the_module, 0, expressions[8]);
relooperBlocks[2] = RelooperAddBlock(the_relooper, expressions[9]);
RelooperAddBranch(relooperBlocks[2], relooperBlocks[0], expressions[0], expressions[0]);
expressions[10] = RelooperRenderAndDispose(the_relooper, relooperBlocks[2], 1);
{
BinaryenType varTypes[] = { 1, 1, 2 };
functions[0] = BinaryenAddFunction(the_module, "main", functionTypes[0], varTypes, 3, expressions[10]);
}
BinaryenAddFunctionExport(the_module, "main", "main");
{
BinaryenType paramTypes[] = { 0 };
functionTypes[1] = BinaryenAddFunctionType(the_module, "__wasm_start", 0, paramTypes, 0);
}
{
const char* segments[] = { 0 };
int8_t segmentPassive[] = { 0 };
BinaryenExpressionRef segmentOffsets[] = { 0 };
BinaryenIndex segmentSizes[] = { 0 };
BinaryenSetMemory(the_module, 1024, 1024, NULL, segments, segmentPassive, segmentOffsets, segmentSizes, 0, 0);
}
expressions[11] = BinaryenConst(the_module, BinaryenLiteralInt32(65535));
expressions[12] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
expressions[13] = BinaryenStore(the_module, 4, 0, 0, expressions[12], expressions[11], 1);
{
BinaryenExpressionRef operands[] = { 0 };
expressions[14] = BinaryenCall(the_module, "main", operands, 0, 0);
}
{
BinaryenExpressionRef children[] = { expressions[13], expressions[14] };
expressions[15] = BinaryenBlock(the_module, NULL, children, 2, BinaryenTypeAuto());
}
BinaryenAddFunctionExport(the_module, "__wasm_start", "rust_entry");
{
BinaryenType varTypes[] = { 0 };
functions[1] = BinaryenAddFunction(the_module, "__wasm_start", functionTypes[1], varTypes, 0, expressions[15]);
}
BinaryenModuleValidate(the_module);
BinaryenModulePrint(the_module);
// check that binary read-write works
{
char buffer[1024];
BinaryenSetDebugInfo(1);
size_t size = BinaryenModuleWrite(the_module, buffer, 1024);
printf("%d\n", size);
BinaryenModuleRef copy = BinaryenModuleRead(buffer, size);
BinaryenModulePrint(copy);
BinaryenModuleDispose(copy);
}
BinaryenModuleDispose(the_module);
return 0;
}
