v.gen.wasm.binaryen #

fn absfloat32 #

fn absfloat32() Op

fn absfloat64 #

fn absfloat64() Op

fn absvecf32x4 #

fn absvecf32x4() Op

fn absvecf64x2 #

fn absvecf64x2() Op

fn absveci16x8 #

fn absveci16x8() Op

fn absveci32x4 #

fn absveci32x4() Op

fn absveci64x2 #

fn absveci64x2() Op

fn absveci8x16 #

fn absveci8x16() Op

fn addactiveelementsegment #

fn addactiveelementsegment(module_ Module, table &i8, name &i8, funcnames &&u8, numfuncnames Index, offset Expression) ElementSegment

fn addcustomsection #

fn addcustomsection(module_ Module, name &i8, contents &i8, contentssize Index)

fn addexport #

fn addexport(module_ Module, internalname &i8, externalname &i8) Export

fn addfloat32 #

fn addfloat32() Op

fn addfloat64 #

fn addfloat64() Op

fn addfunction #

fn addfunction(module_ Module, name &i8, params Type, results Type, vartypes &Type, numvartypes Index, body Expression) Function

fn addfunctionexport #

fn addfunctionexport(module_ Module, internalname &i8, externalname &i8) Export

fn addfunctionimport #

fn addfunctionimport(module_ Module, internalname &i8, externalmodulename &i8, externalbasename &i8, params Type, results Type)

fn addglobal #

fn addglobal(module_ Module, name &i8, type_ Type, mutable_ bool, init Expression) Global

fn addglobalexport #

fn addglobalexport(module_ Module, internalname &i8, externalname &i8) Export

fn addglobalimport #

fn addglobalimport(module_ Module, internalname &i8, externalmodulename &i8, externalbasename &i8, globaltype Type, mutable_ bool)

fn addint32 #

fn addint32() Op

fn addint64 #

fn addint64() Op

fn addmemoryexport #

fn addmemoryexport(module_ Module, internalname &i8, externalname &i8) Export

fn addmemoryimport #

fn addmemoryimport(module_ Module, internalname &i8, externalmodulename &i8, externalbasename &i8, shared_ u8)

fn addpassiveelementsegment #

fn addpassiveelementsegment(module_ Module, name &i8, funcnames &&u8, numfuncnames Index) ElementSegment

fn addsatsveci16x8 #

fn addsatsveci16x8() Op

fn addsatsveci8x16 #

fn addsatsveci8x16() Op

fn addsatuveci16x8 #

fn addsatuveci16x8() Op

fn addsatuveci8x16 #

fn addsatuveci8x16() Op

fn addtable #

fn addtable(module_ Module, table &i8, initial Index, maximum Index, tabletype Type) Table

fn addtableexport #

fn addtableexport(module_ Module, internalname &i8, externalname &i8) Export

fn addtableimport #

fn addtableimport(module_ Module, internalname &i8, externalmodulename &i8, externalbasename &i8)

fn addtag #

fn addtag(module_ Module, name &i8, params Type, results Type) Tag

fn addtagexport #

fn addtagexport(module_ Module, internalname &i8, externalname &i8) Export

fn addtagimport #

fn addtagimport(module_ Module, internalname &i8, externalmodulename &i8, externalbasename &i8, params Type, results Type)

fn addvecf32x4 #

fn addvecf32x4() Op

fn addvecf64x2 #

fn addvecf64x2() Op

fn addveci16x8 #

fn addveci16x8() Op

fn addveci32x4 #

fn addveci32x4() Op

fn addveci64x2 #

fn addveci64x2() Op

fn addveci8x16 #

fn addveci8x16() Op

fn alltrueveci16x8 #

fn alltrueveci16x8() Op

fn alltrueveci32x4 #

fn alltrueveci32x4() Op

fn alltrueveci64x2 #

fn alltrueveci64x2() Op

fn alltrueveci8x16 #

fn alltrueveci8x16() Op

fn andint32 #

fn andint32() Op

fn andint64 #

fn andint64() Op

fn andnotvec128 #

fn andnotvec128() Op

fn andvec128 #

fn andvec128() Op

fn anytruevec128 #

fn anytruevec128() Op

fn arecolorsenabled #

fn arecolorsenabled() bool

fn arraycopy #

fn arraycopy(module_ Module, destref Expression, destindex Expression, srcref Expression, srcindex Expression, length Expression) Expression

fn arraycopygetdestindex #

fn arraycopygetdestindex(expr Expression) Expression

fn arraycopygetdestref #

fn arraycopygetdestref(expr Expression) Expression

fn arraycopygetlength #

fn arraycopygetlength(expr Expression) Expression

fn arraycopygetsrcindex #

fn arraycopygetsrcindex(expr Expression) Expression

fn arraycopygetsrcref #

fn arraycopygetsrcref(expr Expression) Expression

fn arraycopysetdestindex #

fn arraycopysetdestindex(expr Expression, destindexexpr Expression)

fn arraycopysetdestref #

fn arraycopysetdestref(expr Expression, destrefexpr Expression)

fn arraycopysetlength #

fn arraycopysetlength(expr Expression, lengthexpr Expression)

fn arraycopysetsrcindex #

fn arraycopysetsrcindex(expr Expression, srcindexexpr Expression)

fn arraycopysetsrcref #

fn arraycopysetsrcref(expr Expression, srcrefexpr Expression)

fn arrayget #

fn arrayget(module_ Module, ref Expression, index Expression, type_ Type, signed_ bool) Expression

fn arraygetgetindex #

fn arraygetgetindex(expr Expression) Expression

fn arraygetgetref #

fn arraygetgetref(expr Expression) Expression

fn arraygetissigned #

fn arraygetissigned(expr Expression) bool

fn arraygetsetindex #

fn arraygetsetindex(expr Expression, indexexpr Expression)

fn arraygetsetref #

fn arraygetsetref(expr Expression, refexpr Expression)

fn arraygetsetsigned #

fn arraygetsetsigned(expr Expression, signed_ bool)

fn arrayinit #

fn arrayinit(module_ Module, type_ HeapType, values &Expression, numvalues Index) Expression

fn arrayinitappendvalue #

fn arrayinitappendvalue(expr Expression, valueexpr Expression) Index

fn arrayinitgetnumvalues #

fn arrayinitgetnumvalues(expr Expression) Index

fn arrayinitgetvalueat #

fn arrayinitgetvalueat(expr Expression, index Index) Expression

fn arrayinitinsertvalueat #

fn arrayinitinsertvalueat(expr Expression, index Index, valueexpr Expression)

fn arrayinitremovevalueat #

fn arrayinitremovevalueat(expr Expression, index Index) Expression

fn arrayinitsetvalueat #

fn arrayinitsetvalueat(expr Expression, index Index, valueexpr Expression)

fn arraylen #

fn arraylen(module_ Module, ref Expression) Expression

fn arraylengetref #

fn arraylengetref(expr Expression) Expression

fn arraylensetref #

fn arraylensetref(expr Expression, refexpr Expression)

fn arraynew #

fn arraynew(module_ Module, type_ HeapType, size Expression, init Expression) Expression

fn arraynewgetinit #

fn arraynewgetinit(expr Expression) Expression

fn arraynewgetsize #

fn arraynewgetsize(expr Expression) Expression

fn arraynewsetinit #

fn arraynewsetinit(expr Expression, initexpr Expression)

fn arraynewsetsize #

fn arraynewsetsize(expr Expression, sizeexpr Expression)

fn arrayset #

fn arrayset(module_ Module, ref Expression, index Expression, value Expression) Expression

fn arraysetgetindex #

fn arraysetgetindex(expr Expression) Expression

fn arraysetgetref #

fn arraysetgetref(expr Expression) Expression

fn arraysetgetvalue #

fn arraysetgetvalue(expr Expression) Expression

fn arraysetsetindex #

fn arraysetsetindex(expr Expression, indexexpr Expression)

fn arraysetsetref #

fn arraysetsetref(expr Expression, refexpr Expression)

fn arraysetsetvalue #

fn arraysetsetvalue(expr Expression, valueexpr Expression)

fn arraytypegetelementpackedtype #

fn arraytypegetelementpackedtype(heaptype HeapType) PackedType

fn arraytypegetelementtype #

fn arraytypegetelementtype(heaptype HeapType) Type

fn arraytypeiselementmutable #

fn arraytypeiselementmutable(heaptype HeapType) bool

fn atomiccmpxchg #

fn atomiccmpxchg(module_ Module, bytes Index, offset Index, ptr Expression, expected Expression, replacement Expression, type_ Type, memoryname &i8) Expression

fn atomiccmpxchggetbytes #

fn atomiccmpxchggetbytes(expr Expression) u32

fn atomiccmpxchggetexpected #

fn atomiccmpxchggetexpected(expr Expression) Expression

fn atomiccmpxchggetoffset #

fn atomiccmpxchggetoffset(expr Expression) u32

fn atomiccmpxchggetptr #

fn atomiccmpxchggetptr(expr Expression) Expression

fn atomiccmpxchggetreplacement #

fn atomiccmpxchggetreplacement(expr Expression) Expression

fn atomiccmpxchgsetbytes #

fn atomiccmpxchgsetbytes(expr Expression, bytes u32)

fn atomiccmpxchgsetexpected #

fn atomiccmpxchgsetexpected(expr Expression, expectedexpr Expression)

fn atomiccmpxchgsetoffset #

fn atomiccmpxchgsetoffset(expr Expression, offset u32)

fn atomiccmpxchgsetptr #

fn atomiccmpxchgsetptr(expr Expression, ptrexpr Expression)

fn atomiccmpxchgsetreplacement #

fn atomiccmpxchgsetreplacement(expr Expression, replacementexpr Expression)

fn atomicfence #

fn atomicfence(module_ Module) Expression

fn atomicfencegetorder #

fn atomicfencegetorder(expr Expression) u8

fn atomicfencesetorder #

fn atomicfencesetorder(expr Expression, order u8)

fn atomicload #

fn atomicload(module_ Module, bytes u32, offset u32, type_ Type, ptr Expression, memoryname &i8) Expression

fn atomicnotify #

fn atomicnotify(module_ Module, ptr Expression, notifycount Expression, memoryname &i8) Expression

fn atomicnotifygetnotifycount #

fn atomicnotifygetnotifycount(expr Expression) Expression

fn atomicnotifygetptr #

fn atomicnotifygetptr(expr Expression) Expression

fn atomicnotifysetnotifycount #

fn atomicnotifysetnotifycount(expr Expression, notifycountexpr Expression)

fn atomicnotifysetptr #

fn atomicnotifysetptr(expr Expression, ptrexpr Expression)

fn atomicrmw #

fn atomicrmw(module_ Module, op Op, bytes Index, offset Index, ptr Expression, value Expression, type_ Type, memoryname &i8) Expression

fn atomicrmwadd #

fn atomicrmwadd() Op

fn atomicrmwand #

fn atomicrmwand() Op

fn atomicrmwgetbytes #

fn atomicrmwgetbytes(expr Expression) u32

fn atomicrmwgetoffset #

fn atomicrmwgetoffset(expr Expression) u32

fn atomicrmwgetop #

fn atomicrmwgetop(expr Expression) Op

fn atomicrmwgetptr #

fn atomicrmwgetptr(expr Expression) Expression

fn atomicrmwgetvalue #

fn atomicrmwgetvalue(expr Expression) Expression

fn atomicrmwor #

fn atomicrmwor() Op

fn atomicrmwsetbytes #

fn atomicrmwsetbytes(expr Expression, bytes u32)

fn atomicrmwsetoffset #

fn atomicrmwsetoffset(expr Expression, offset u32)

fn atomicrmwsetop #

fn atomicrmwsetop(expr Expression, op Op)

fn atomicrmwsetptr #

fn atomicrmwsetptr(expr Expression, ptrexpr Expression)

fn atomicrmwsetvalue #

fn atomicrmwsetvalue(expr Expression, valueexpr Expression)

fn atomicrmwsub #

fn atomicrmwsub() Op

fn atomicrmwxchg #

fn atomicrmwxchg() Op

fn atomicrmwxor #

fn atomicrmwxor() Op

fn atomicstore #

fn atomicstore(module_ Module, bytes u32, offset u32, ptr Expression, value Expression, type_ Type, memoryname &i8) Expression

fn atomicwait #

fn atomicwait(module_ Module, ptr Expression, expected Expression, timeout Expression, type_ Type, memoryname &i8) Expression

fn atomicwaitgetexpected #

fn atomicwaitgetexpected(expr Expression) Expression

fn atomicwaitgetexpectedtype #

fn atomicwaitgetexpectedtype(expr Expression) Type

fn atomicwaitgetptr #

fn atomicwaitgetptr(expr Expression) Expression

fn atomicwaitgettimeout #

fn atomicwaitgettimeout(expr Expression) Expression

fn atomicwaitsetexpected #

fn atomicwaitsetexpected(expr Expression, expectedexpr Expression)

fn atomicwaitsetexpectedtype #

fn atomicwaitsetexpectedtype(expr Expression, expectedtype Type)

fn atomicwaitsetptr #

fn atomicwaitsetptr(expr Expression, ptrexpr Expression)

fn atomicwaitsettimeout #

fn atomicwaitsettimeout(expr Expression, timeoutexpr Expression)

fn avgruveci16x8 #

fn avgruveci16x8() Op

fn avgruveci8x16 #

fn avgruveci8x16() Op

fn bif #

fn bif(module_ Module, condition Expression, iftrue Expression, iffalse Expression) Expression

fn binary #

fn binary(module_ Module, op Op, left Expression, right Expression) Expression

fn binarygetleft #

fn binarygetleft(expr Expression) Expression

fn binarygetop #

fn binarygetop(expr Expression) Op

fn binarygetright #

fn binarygetright(expr Expression) Expression

fn binarysetleft #

fn binarysetleft(expr Expression, leftexpr Expression)

fn binarysetop #

fn binarysetop(expr Expression, op Op)

fn binarysetright #

fn binarysetright(expr Expression, rightexpr Expression)

fn bitmaskveci16x8 #

fn bitmaskveci16x8() Op

fn bitmaskveci32x4 #

fn bitmaskveci32x4() Op

fn bitmaskveci64x2 #

fn bitmaskveci64x2() Op

fn bitmaskveci8x16 #

fn bitmaskveci8x16() Op

fn bitselectvec128 #

fn bitselectvec128() Op

fn block #

fn block(module_ Module, name &i8, children &Expression, numchildren Index, type_ Type) Expression

fn blockappendchild #

fn blockappendchild(expr Expression, childexpr Expression) Index

fn blockgetchildat #

fn blockgetchildat(expr Expression, index Index) Expression

fn blockgetname #

fn blockgetname(expr Expression) &i8

fn blockgetnumchildren #

fn blockgetnumchildren(expr Expression) Index

fn blockinsertchildat #

fn blockinsertchildat(expr Expression, index Index, childexpr Expression)

fn blockremovechildat #

fn blockremovechildat(expr Expression, index Index) Expression

fn blocksetchildat #

fn blocksetchildat(expr Expression, index Index, childexpr Expression)

fn blocksetname #

fn blocksetname(expr Expression, name &i8)

fn br #

fn br(module_ Module, name &i8, condition Expression, value Expression) Expression

fn breakgetcondition #

fn breakgetcondition(expr Expression) Expression

fn breakgetname #

fn breakgetname(expr Expression) &i8

fn breakgetvalue #

fn breakgetvalue(expr Expression) Expression

fn breaksetcondition #

fn breaksetcondition(expr Expression, condexpr Expression)

fn breaksetname #

fn breaksetname(expr Expression, name &i8)

fn breaksetvalue #

fn breaksetvalue(expr Expression, valueexpr Expression)

fn bron #

fn bron(module_ Module, op Op, name &i8, ref Expression, intendedtype HeapType) Expression

fn broncast #

fn broncast() Op

fn broncastfail #

fn broncastfail() Op

fn brondata #

fn brondata() Op

fn bronfunc #

fn bronfunc() Op

fn brongetintendedtype #

fn brongetintendedtype(expr Expression) HeapType

fn brongetname #

fn brongetname(expr Expression) &i8

fn brongetop #

fn brongetop(expr Expression) Op

fn brongetref #

fn brongetref(expr Expression) Expression

fn broni31 #

fn broni31() Op

fn bronnondata #

fn bronnondata() Op

fn bronnonfunc #

fn bronnonfunc() Op

fn bronnoni31 #

fn bronnoni31() Op

fn bronnonnull #

fn bronnonnull() Op

fn bronnull #

fn bronnull() Op

fn bronsetintendedtype #

fn bronsetintendedtype(expr Expression, intendedtype HeapType)

fn bronsetname #

fn bronsetname(expr Expression, namestr &i8)

fn bronsetop #

fn bronsetop(expr Expression, op Op)

fn bronsetref #

fn bronsetref(expr Expression, refexpr Expression)

fn bselect #

fn bselect(module_ Module, condition Expression, iftrue Expression, iffalse Expression, type_ Type) Expression

fn call #

fn call(module_ Module, target &i8, operands &Expression, numoperands Index, returntype Type) Expression

fn callappendoperand #

fn callappendoperand(expr Expression, operandexpr Expression) Index

fn callgetnumoperands #

fn callgetnumoperands(expr Expression) Index

fn callgetoperandat #

fn callgetoperandat(expr Expression, index Index) Expression

fn callgettarget #

fn callgettarget(expr Expression) &i8

fn callindirect #

fn callindirect(module_ Module, table &i8, target Expression, operands &Expression, numoperands Index, params Type, results Type) Expression

fn callindirectappendoperand #

fn callindirectappendoperand(expr Expression, operandexpr Expression) Index

fn callindirectgetnumoperands #

fn callindirectgetnumoperands(expr Expression) Index

fn callindirectgetoperandat #

fn callindirectgetoperandat(expr Expression, index Index) Expression

fn callindirectgetparams #

fn callindirectgetparams(expr Expression) Type

fn callindirectgetresults #

fn callindirectgetresults(expr Expression) Type

fn callindirectgettable #

fn callindirectgettable(expr Expression) &i8

fn callindirectgettarget #

fn callindirectgettarget(expr Expression) Expression

fn callindirectinsertoperandat #

fn callindirectinsertoperandat(expr Expression, index Index, operandexpr Expression)

fn callindirectisreturn #

fn callindirectisreturn(expr Expression) bool

fn callindirectremoveoperandat #

fn callindirectremoveoperandat(expr Expression, index Index) Expression

fn callindirectsetoperandat #

fn callindirectsetoperandat(expr Expression, index Index, operandexpr Expression)

fn callindirectsetparams #

fn callindirectsetparams(expr Expression, params Type)

fn callindirectsetresults #

fn callindirectsetresults(expr Expression, params Type)

fn callindirectsetreturn #

fn callindirectsetreturn(expr Expression, isreturn bool)

fn callindirectsettable #

fn callindirectsettable(expr Expression, table &i8)

fn callindirectsettarget #

fn callindirectsettarget(expr Expression, targetexpr Expression)

fn callinsertoperandat #

fn callinsertoperandat(expr Expression, index Index, operandexpr Expression)

fn callisreturn #

fn callisreturn(expr Expression) bool

fn callref #

fn callref(module_ Module, target Expression, operands &Expression, numoperands Index, type_ Type, isreturn bool) Expression

fn callrefappendoperand #

fn callrefappendoperand(expr Expression, operandexpr Expression) Index

fn callrefgetnumoperands #

fn callrefgetnumoperands(expr Expression) Index

fn callrefgetoperandat #

fn callrefgetoperandat(expr Expression, index Index) Expression

fn callrefgettarget #

fn callrefgettarget(expr Expression) Expression

fn callrefinsertoperandat #

fn callrefinsertoperandat(expr Expression, index Index, operandexpr Expression)

fn callrefisreturn #

fn callrefisreturn(expr Expression) bool

fn callrefremoveoperandat #

fn callrefremoveoperandat(expr Expression, index Index) Expression

fn callrefsetoperandat #

fn callrefsetoperandat(expr Expression, index Index, operandexpr Expression)

fn callrefsetreturn #

fn callrefsetreturn(expr Expression, isreturn bool)

fn callrefsettarget #

fn callrefsettarget(expr Expression, targetexpr Expression)

fn callremoveoperandat #

fn callremoveoperandat(expr Expression, index Index) Expression

fn callsetoperandat #

fn callsetoperandat(expr Expression, index Index, operandexpr Expression)

fn callsetreturn #

fn callsetreturn(expr Expression, isreturn bool)

fn callsettarget #

fn callsettarget(expr Expression, target &i8)

fn ceilfloat32 #

fn ceilfloat32() Op

fn ceilfloat64 #

fn ceilfloat64() Op

fn ceilvecf32x4 #

fn ceilvecf32x4() Op

fn ceilvecf64x2 #

fn ceilvecf64x2() Op

fn clearpassarguments #

fn clearpassarguments()

fn clzint32 #

fn clzint32() Op

fn clzint64 #

fn clzint64() Op

fn constant #

fn constant(module_ Module, value Literal) Expression

fn constgetvaluef32 #

fn constgetvaluef32(expr Expression) f32

fn constgetvaluef64 #

fn constgetvaluef64(expr Expression) f64

fn constgetvaluei32 #

fn constgetvaluei32(expr Expression) int

fn constgetvaluei64 #

fn constgetvaluei64(expr Expression) i64

fn constgetvaluei64high #

fn constgetvaluei64high(expr Expression) int

fn constgetvaluei64low #

fn constgetvaluei64low(expr Expression) int

fn constgetvaluev128 #

fn constgetvaluev128(expr Expression, out &u8)

fn constsetvaluef32 #

fn constsetvaluef32(expr Expression, value f32)

fn constsetvaluef64 #

fn constsetvaluef64(expr Expression, value f64)

fn constsetvaluei32 #

fn constsetvaluei32(expr Expression, value int)

fn constsetvaluei64 #

fn constsetvaluei64(expr Expression, value i64)

fn constsetvaluei64high #

fn constsetvaluei64high(expr Expression, valuehigh int)

fn constsetvaluei64low #

fn constsetvaluei64low(expr Expression, valuelow int)

fn constsetvaluev128 #

fn constsetvaluev128(expr Expression, value &u8)

fn convertlowsveci32x4tovecf64x2 #

fn convertlowsveci32x4tovecf64x2() Op

fn convertlowuveci32x4tovecf64x2 #

fn convertlowuveci32x4tovecf64x2() Op

fn convertsint32tofloat32 #

fn convertsint32tofloat32() Op

fn convertsint32tofloat64 #

fn convertsint32tofloat64() Op

fn convertsint64tofloat32 #

fn convertsint64tofloat32() Op

fn convertsint64tofloat64 #

fn convertsint64tofloat64() Op

fn convertsveci32x4tovecf32x4 #

fn convertsveci32x4tovecf32x4() Op

fn convertuint32tofloat32 #

fn convertuint32tofloat32() Op

fn convertuint32tofloat64 #

fn convertuint32tofloat64() Op

fn convertuint64tofloat32 #

fn convertuint64tofloat32() Op

fn convertuint64tofloat64 #

fn convertuint64tofloat64() Op

fn convertuveci32x4tovecf32x4 #

fn convertuveci32x4tovecf32x4() Op

fn copymemorysegmentdata #

fn copymemorysegmentdata(module_ Module, id Index, buffer &i8)

fn copysignfloat32 #

fn copysignfloat32() Op

fn copysignfloat64 #

fn copysignfloat64() Op

fn ctzint32 #

fn ctzint32() Op

fn ctzint64 #

fn ctzint64() Op

fn datadrop #

fn datadrop(module_ Module, segment u32) Expression

fn datadropgetsegment #

fn datadropgetsegment(expr Expression) u32

fn datadropsetsegment #

fn datadropsetsegment(expr Expression, segmentindex u32)

fn demotefloat64 #

fn demotefloat64() Op

fn demotezerovecf64x2tovecf32x4 #

fn demotezerovecf64x2tovecf32x4() Op

fn divfloat32 #

fn divfloat32() Op

fn divfloat64 #

fn divfloat64() Op

fn divsint32 #

fn divsint32() Op

fn divsint64 #

fn divsint64() Op

fn divuint32 #

fn divuint32() Op

fn divuint64 #

fn divuint64() Op

fn divvecf32x4 #

fn divvecf32x4() Op

fn divvecf64x2 #

fn divvecf64x2() Op

fn dotsveci16x8toveci32x4 #

fn dotsveci16x8toveci32x4() Op

fn drop #

fn drop(module_ Module, value Expression) Expression

fn dropgetvalue #

fn dropgetvalue(expr Expression) Expression

fn dropsetvalue #

fn dropsetvalue(expr Expression, valueexpr Expression)

fn elementsegmentgetdata #

fn elementsegmentgetdata(elem ElementSegment, dataid Index) &i8

fn elementsegmentgetlength #

fn elementsegmentgetlength(elem ElementSegment) Index

fn elementsegmentgetname #

fn elementsegmentgetname(elem ElementSegment) &i8

fn elementsegmentgetoffset #

fn elementsegmentgetoffset(elem ElementSegment) Expression

fn elementsegmentgettable #

fn elementsegmentgettable(elem ElementSegment) &i8

fn elementsegmentispassive #

fn elementsegmentispassive(elem ElementSegment) bool

fn elementsegmentsetname #

fn elementsegmentsetname(elem ElementSegment, name &i8)

fn elementsegmentsettable #

fn elementsegmentsettable(elem ElementSegment, table &i8)

fn eqfloat32 #

fn eqfloat32() Op

fn eqfloat64 #

fn eqfloat64() Op

fn eqint32 #

fn eqint32() Op

fn eqint64 #

fn eqint64() Op

fn eqvecf32x4 #

fn eqvecf32x4() Op

fn eqvecf64x2 #

fn eqvecf64x2() Op

fn eqveci16x8 #

fn eqveci16x8() Op

fn eqveci32x4 #

fn eqveci32x4() Op

fn eqveci64x2 #

fn eqveci64x2() Op

fn eqveci8x16 #

fn eqveci8x16() Op

fn eqzint32 #

fn eqzint32() Op

fn eqzint64 #

fn eqzint64() Op

fn exportgetkind #

fn exportgetkind(export_ Export) ExternalKind

fn exportgetname #

fn exportgetname(export_ Export) &i8

fn exportgetvalue #

fn exportgetvalue(export_ Export) &i8

fn expressioncopy #

fn expressioncopy(expr Expression, module_ Module) Expression

fn expressionfinalize #

fn expressionfinalize(expr Expression)

fn expressiongetid #

fn expressiongetid(expr Expression) ExpressionId

fn expressiongetsideeffects #

fn expressiongetsideeffects(expr Expression, module_ Module) SideEffects

fn expressiongettype #

fn expressiongettype(expr Expression) Type

fn expressionprint #

fn expressionprint(expr Expression)

fn expressionrunnercreate #

fn expressionrunnercreate(module_ Module, flags ExpressionRunnerFlags, maxdepth Index, maxloopiterations Index) ExpressionRunner

fn expressionrunnerflagsdefault #

fn expressionrunnerflagsdefault() ExpressionRunnerFlags

fn expressionrunnerflagspreservesideeffects #

fn expressionrunnerflagspreservesideeffects() ExpressionRunnerFlags

fn expressionrunnerflagstraversecalls #

fn expressionrunnerflagstraversecalls() ExpressionRunnerFlags

fn expressionrunnerrunanddispose #

fn expressionrunnerrunanddispose(runner ExpressionRunner, expr Expression) Expression

fn expressionrunnersetglobalvalue #

fn expressionrunnersetglobalvalue(runner ExpressionRunner, name &i8, value Expression) bool

fn expressionrunnersetlocalvalue #

fn expressionrunnersetlocalvalue(runner ExpressionRunner, index Index, value Expression) bool

fn expressionsettype #

fn expressionsettype(expr Expression, type_ Type)

fn extaddpairwisesveci16x8toi32x4 #

fn extaddpairwisesveci16x8toi32x4() Op

fn extaddpairwisesveci8x16toi16x8 #

fn extaddpairwisesveci8x16toi16x8() Op

fn extaddpairwiseuveci16x8toi32x4 #

fn extaddpairwiseuveci16x8toi32x4() Op

fn extaddpairwiseuveci8x16toi16x8 #

fn extaddpairwiseuveci8x16toi16x8() Op

fn extendhighsveci16x8toveci32x4 #

fn extendhighsveci16x8toveci32x4() Op

fn extendhighsveci32x4toveci64x2 #

fn extendhighsveci32x4toveci64x2() Op

fn extendhighsveci8x16toveci16x8 #

fn extendhighsveci8x16toveci16x8() Op

fn extendhighuveci16x8toveci32x4 #

fn extendhighuveci16x8toveci32x4() Op

fn extendhighuveci32x4toveci64x2 #

fn extendhighuveci32x4toveci64x2() Op

fn extendhighuveci8x16toveci16x8 #

fn extendhighuveci8x16toveci16x8() Op

fn extendlowsveci16x8toveci32x4 #

fn extendlowsveci16x8toveci32x4() Op

fn extendlowsveci32x4toveci64x2 #

fn extendlowsveci32x4toveci64x2() Op

fn extendlowsveci8x16toveci16x8 #

fn extendlowsveci8x16toveci16x8() Op

fn extendlowuveci16x8toveci32x4 #

fn extendlowuveci16x8toveci32x4() Op

fn extendlowuveci32x4toveci64x2 #

fn extendlowuveci32x4toveci64x2() Op

fn extendlowuveci8x16toveci16x8 #

fn extendlowuveci8x16toveci16x8() Op

fn extends16int32 #

fn extends16int32() Op

fn extends16int64 #

fn extends16int64() Op

fn extends32int64 #

fn extends32int64() Op

fn extends8int32 #

fn extends8int32() Op

fn extends8int64 #

fn extends8int64() Op

fn extendsint32 #

fn extendsint32() Op

fn extenduint32 #

fn extenduint32() Op

fn externalfunction #

fn externalfunction() ExternalKind

fn externalglobal #

fn externalglobal() ExternalKind

fn externalmemory #

fn externalmemory() ExternalKind

fn externaltable #

fn externaltable() ExternalKind

fn externaltag #

fn externaltag() ExternalKind

fn extmulhighsveci16x8 #

fn extmulhighsveci16x8() Op

fn extmulhighsveci32x4 #

fn extmulhighsveci32x4() Op

fn extmulhighsveci64x2 #

fn extmulhighsveci64x2() Op

fn extmulhighuveci16x8 #

fn extmulhighuveci16x8() Op

fn extmulhighuveci32x4 #

fn extmulhighuveci32x4() Op

fn extmulhighuveci64x2 #

fn extmulhighuveci64x2() Op

fn extmullowsveci16x8 #

fn extmullowsveci16x8() Op

fn extmullowsveci32x4 #

fn extmullowsveci32x4() Op

fn extmullowsveci64x2 #

fn extmullowsveci64x2() Op

fn extmullowuveci16x8 #

fn extmullowuveci16x8() Op

fn extmullowuveci32x4 #

fn extmullowuveci32x4() Op

fn extmullowuveci64x2 #

fn extmullowuveci64x2() Op

fn extractlanesveci16x8 #

fn extractlanesveci16x8() Op

fn extractlanesveci8x16 #

fn extractlanesveci8x16() Op

fn extractlaneuveci16x8 #

fn extractlaneuveci16x8() Op

fn extractlaneuveci8x16 #

fn extractlaneuveci8x16() Op

fn extractlanevecf32x4 #

fn extractlanevecf32x4() Op

fn extractlanevecf64x2 #

fn extractlanevecf64x2() Op

fn extractlaneveci32x4 #

fn extractlaneveci32x4() Op

fn extractlaneveci64x2 #

fn extractlaneveci64x2() Op

fn featureall #

fn featureall() Features

fn featureatomics #

fn featureatomics() Features

fn featurebulkmemory #

fn featurebulkmemory() Features

fn featureexceptionhandling #

fn featureexceptionhandling() Features

fn featureextendedconst #

fn featureextendedconst() Features

fn featuregc #

fn featuregc() Features

fn featurememory64 #

fn featurememory64() Features

fn featuremultimemories #

fn featuremultimemories() Features

fn featuremultivalue #

fn featuremultivalue() Features

fn featuremutableglobals #

fn featuremutableglobals() Features

fn featuremvp #

fn featuremvp() Features

fn featurenontrappingfptoint #

fn featurenontrappingfptoint() Features

fn featurereferencetypes #

fn featurereferencetypes() Features

fn featurerelaxedsimd #

fn featurerelaxedsimd() Features

fn featuresignext #

fn featuresignext() Features

fn featuresimd128 #

fn featuresimd128() Features

fn featurestrings #

fn featurestrings() Features

fn featuretailcall #

fn featuretailcall() Features

fn floorfloat32 #

fn floorfloat32() Op

fn floorfloat64 #

fn floorfloat64() Op

fn floorvecf32x4 #

fn floorvecf32x4() Op

fn floorvecf64x2 #

fn floorvecf64x2() Op

fn functiongetbody #

fn functiongetbody(func Function) Expression

fn functiongetlocalname #

fn functiongetlocalname(func Function, index Index) &i8

fn functiongetname #

fn functiongetname(func Function) &i8

fn functiongetnumlocals #

fn functiongetnumlocals(func Function) Index

fn functiongetnumvars #

fn functiongetnumvars(func Function) Index

fn functiongetparams #

fn functiongetparams(func Function) Type

fn functiongetresults #

fn functiongetresults(func Function) Type

fn functiongetvar #

fn functiongetvar(func Function, index Index) Type

fn functionhaslocalname #

fn functionhaslocalname(func Function, index Index) bool

fn functionimportgetbase #

fn functionimportgetbase(import_ Function) &i8

fn functionimportgetmodule #

fn functionimportgetmodule(import_ Function) &i8

fn functionoptimize #

fn functionoptimize(func Function, module_ Module)

fn functionrunpasses #

fn functionrunpasses(func Function, module_ Module, passes &&u8, numpasses Index)

fn functionsetbody #

fn functionsetbody(func Function, body Expression)

fn functionsetdebuglocation #

fn functionsetdebuglocation(func Function, expr Expression, fileindex Index, linenumber Index, columnnumber Index)

fn functionsetlocalname #

fn functionsetlocalname(func Function, index Index, name &i8)

fn gefloat32 #

fn gefloat32() Op

fn gefloat64 #

fn gefloat64() Op

fn gesint32 #

fn gesint32() Op

fn gesint64 #

fn gesint64() Op

fn gesveci16x8 #

fn gesveci16x8() Op

fn gesveci32x4 #

fn gesveci32x4() Op

fn gesveci64x2 #

fn gesveci64x2() Op

fn gesveci8x16 #

fn gesveci8x16() Op

fn getallowinliningfunctionswithloops #

fn getallowinliningfunctionswithloops() bool

fn getalwaysinlinemaxsize #

fn getalwaysinlinemaxsize() Index

fn getdebuginfo #

fn getdebuginfo() bool

fn getelementsegment #

fn getelementsegment(module_ Module, name &i8) ElementSegment

fn getelementsegmentbyindex #

fn getelementsegmentbyindex(module_ Module, index Index) ElementSegment

fn getexport #

fn getexport(module_ Module, externalname &i8) Export

fn getexportbyindex #

fn getexportbyindex(module_ Module, index Index) Export

fn getfastmath #

fn getfastmath() bool

fn getflexibleinlinemaxsize #

fn getflexibleinlinemaxsize() Index

fn getfunction #

fn getfunction(module_ Module, name &i8) Function

fn getfunctionbyindex #

fn getfunctionbyindex(module_ Module, index Index) Function

fn getglobal #

fn getglobal(module_ Module, name &i8) Global

fn getglobalbyindex #

fn getglobalbyindex(module_ Module, index Index) Global

fn getlowmemoryunused #

fn getlowmemoryunused() bool

fn getmemorysegmentbytelength #

fn getmemorysegmentbytelength(module_ Module, id Index) usize

fn getmemorysegmentbyteoffset #

fn getmemorysegmentbyteoffset(module_ Module, id Index) u32

fn getmemorysegmentpassive #

fn getmemorysegmentpassive(module_ Module, id Index) bool

fn getnumelementsegments #

fn getnumelementsegments(module_ Module) Index

fn getnumexports #

fn getnumexports(module_ Module) Index

fn getnumfunctions #

fn getnumfunctions(module_ Module) Index

fn getnumglobals #

fn getnumglobals(module_ Module) Index

fn getnummemorysegments #

fn getnummemorysegments(module_ Module) u32

fn getnumtables #

fn getnumtables(module_ Module) Index

fn getonecallerinlinemaxsize #

fn getonecallerinlinemaxsize() Index

fn getoptimizelevel #

fn getoptimizelevel() int

fn getpassargument #

fn getpassargument(name &i8) &i8

fn getshrinklevel #

fn getshrinklevel() int

fn gettable #

fn gettable(module_ Module, name &i8) Table

fn gettablebyindex #

fn gettablebyindex(module_ Module, index Index) Table

fn gettag #

fn gettag(module_ Module, name &i8) Tag

fn gettypesystem #

fn gettypesystem() TypeSystem

fn getzerofilledmemory #

fn getzerofilledmemory() bool

fn geuint32 #

fn geuint32() Op

fn geuint64 #

fn geuint64() Op

fn geuveci16x8 #

fn geuveci16x8() Op

fn geuveci32x4 #

fn geuveci32x4() Op

fn geuveci8x16 #

fn geuveci8x16() Op

fn gevecf32x4 #

fn gevecf32x4() Op

fn gevecf64x2 #

fn gevecf64x2() Op

fn globalget #

fn globalget(module_ Module, name &i8, type_ Type) Expression

fn globalgetgetname #

fn globalgetgetname(expr Expression) &i8

fn globalgetinitexpr #

fn globalgetinitexpr(global Global) Expression

fn globalgetname #

fn globalgetname(global Global) &i8

fn globalgetsetname #

fn globalgetsetname(expr Expression, name &i8)

fn globalgettype #

fn globalgettype(global Global) Type

fn globalimportgetbase #

fn globalimportgetbase(import_ Global) &i8

fn globalimportgetmodule #

fn globalimportgetmodule(import_ Global) &i8

fn globalismutable #

fn globalismutable(global Global) bool

fn globalset #

fn globalset(module_ Module, name &i8, value Expression) Expression

fn globalsetgetname #

fn globalsetgetname(expr Expression) &i8

fn globalsetgetvalue #

fn globalsetgetvalue(expr Expression) Expression

fn globalsetsetname #

fn globalsetsetname(expr Expression, name &i8)

fn globalsetsetvalue #

fn globalsetsetvalue(expr Expression, valueexpr Expression)

fn gtfloat32 #

fn gtfloat32() Op

fn gtfloat64 #

fn gtfloat64() Op

fn gtsint32 #

fn gtsint32() Op

fn gtsint64 #

fn gtsint64() Op

fn gtsveci16x8 #

fn gtsveci16x8() Op

fn gtsveci32x4 #

fn gtsveci32x4() Op

fn gtsveci64x2 #

fn gtsveci64x2() Op

fn gtsveci8x16 #

fn gtsveci8x16() Op

fn gtuint32 #

fn gtuint32() Op

fn gtuint64 #

fn gtuint64() Op

fn gtuveci16x8 #

fn gtuveci16x8() Op

fn gtuveci32x4 #

fn gtuveci32x4() Op

fn gtuveci8x16 #

fn gtuveci8x16() Op

fn gtvecf32x4 #

fn gtvecf32x4() Op

fn gtvecf64x2 #

fn gtvecf64x2() Op

fn hasmemory #

fn hasmemory(module_ Module) bool

fn heaptypeany #

fn heaptypeany() HeapType

fn heaptypearray #

fn heaptypearray() HeapType

fn heaptypedata #

fn heaptypedata() HeapType

fn heaptypeeq #

fn heaptypeeq() HeapType

fn heaptypeext #

fn heaptypeext() HeapType

fn heaptypefunc #

fn heaptypefunc() HeapType

fn heaptypegetbottom #

fn heaptypegetbottom(heaptype HeapType) HeapType

fn heaptypei31 #

fn heaptypei31() HeapType

fn heaptypeisarray #

fn heaptypeisarray(heaptype HeapType) bool

fn heaptypeisbasic #

fn heaptypeisbasic(heaptype HeapType) bool

fn heaptypeisbottom #

fn heaptypeisbottom(heaptype HeapType) bool

fn heaptypeissignature #

fn heaptypeissignature(heaptype HeapType) bool

fn heaptypeisstruct #

fn heaptypeisstruct(heaptype HeapType) bool

fn heaptypeissubtype #

fn heaptypeissubtype(left HeapType, right HeapType) bool

fn heaptypenoext #

fn heaptypenoext() HeapType

fn heaptypenofunc #

fn heaptypenofunc() HeapType

fn heaptypenone #

fn heaptypenone() HeapType

fn heaptypestring #

fn heaptypestring() HeapType

fn heaptypestringviewiter #

fn heaptypestringviewiter() HeapType

fn heaptypestringviewwtf16 #

fn heaptypestringviewwtf16() HeapType

fn heaptypestringviewwtf8 #

fn heaptypestringviewwtf8() HeapType

fn i31get #

fn i31get(module_ Module, i31 Expression, signed_ bool) Expression

fn i31getgeti31 #

fn i31getgeti31(expr Expression) Expression

fn i31getissigned #

fn i31getissigned(expr Expression) bool

fn i31getseti31 #

fn i31getseti31(expr Expression, i31expr Expression)

fn i31getsetsigned #

fn i31getsetsigned(expr Expression, signed_ bool)

fn i31new #

fn i31new(module_ Module, value Expression) Expression

fn i31newgetvalue #

fn i31newgetvalue(expr Expression) Expression

fn i31newsetvalue #

fn i31newsetvalue(expr Expression, valueexpr Expression)

fn ifgetcondition #

fn ifgetcondition(expr Expression) Expression

fn ifgetiffalse #

fn ifgetiffalse(expr Expression) Expression

fn ifgetiftrue #

fn ifgetiftrue(expr Expression) Expression

fn ifsetcondition #

fn ifsetcondition(expr Expression, condexpr Expression)

fn ifsetiffalse #

fn ifsetiffalse(expr Expression, iffalseexpr Expression)

fn ifsetiftrue #

fn ifsetiftrue(expr Expression, iftrueexpr Expression)

fn invalidid #

fn invalidid() ExpressionId

fn lefloat32 #

fn lefloat32() Op

fn lefloat64 #

fn lefloat64() Op

fn lesint32 #

fn lesint32() Op

fn lesint64 #

fn lesint64() Op

fn lesveci16x8 #

fn lesveci16x8() Op

fn lesveci32x4 #

fn lesveci32x4() Op

fn lesveci64x2 #

fn lesveci64x2() Op

fn lesveci8x16 #

fn lesveci8x16() Op

fn leuint32 #

fn leuint32() Op

fn leuint64 #

fn leuint64() Op

fn leuveci16x8 #

fn leuveci16x8() Op

fn leuveci32x4 #

fn leuveci32x4() Op

fn leuveci8x16 #

fn leuveci8x16() Op

fn levecf32x4 #

fn levecf32x4() Op

fn levecf64x2 #

fn levecf64x2() Op

fn literalfloat32 #

fn literalfloat32(x f32) Literal

fn literalfloat32bits #

fn literalfloat32bits(x int) Literal

fn literalfloat64 #

fn literalfloat64(x f64) Literal

fn literalfloat64bits #

fn literalfloat64bits(x i64) Literal

fn literalint32 #

fn literalint32(x int) Literal

fn literalint64 #

fn literalint64(x i64) Literal

fn literalvec128 #

fn literalvec128(x &u8) Literal

fn load #

fn load(module_ Module, bytes u32, signed_ bool, offset u32, align u32, type_ Type, ptr Expression, memoryname &i8) Expression

fn load16lanevec128 #

fn load16lanevec128() Op

fn load16splatvec128 #

fn load16splatvec128() Op

fn load16x4svec128 #

fn load16x4svec128() Op

fn load16x4uvec128 #

fn load16x4uvec128() Op

fn load32lanevec128 #

fn load32lanevec128() Op

fn load32splatvec128 #

fn load32splatvec128() Op

fn load32x2svec128 #

fn load32x2svec128() Op

fn load32x2uvec128 #

fn load32x2uvec128() Op

fn load32zerovec128 #

fn load32zerovec128() Op

fn load64lanevec128 #

fn load64lanevec128() Op

fn load64splatvec128 #

fn load64splatvec128() Op

fn load64zerovec128 #

fn load64zerovec128() Op

fn load8lanevec128 #

fn load8lanevec128() Op

fn load8splatvec128 #

fn load8splatvec128() Op

fn load8x8svec128 #

fn load8x8svec128() Op

fn load8x8uvec128 #

fn load8x8uvec128() Op

fn loadgetalign #

fn loadgetalign(expr Expression) u32

fn loadgetbytes #

fn loadgetbytes(expr Expression) u32

fn loadgetoffset #

fn loadgetoffset(expr Expression) u32

fn loadgetptr #

fn loadgetptr(expr Expression) Expression

fn loadisatomic #

fn loadisatomic(expr Expression) bool

fn loadissigned #

fn loadissigned(expr Expression) bool

fn loadsetalign #

fn loadsetalign(expr Expression, align u32)

fn loadsetatomic #

fn loadsetatomic(expr Expression, isatomic bool)

fn loadsetbytes #

fn loadsetbytes(expr Expression, bytes u32)

fn loadsetoffset #

fn loadsetoffset(expr Expression, offset u32)

fn loadsetptr #

fn loadsetptr(expr Expression, ptrexpr Expression)

fn loadsetsigned #

fn loadsetsigned(expr Expression, issigned bool)

fn localget #

fn localget(module_ Module, index Index, type_ Type) Expression

fn localgetgetindex #

fn localgetgetindex(expr Expression) Index

fn localgetsetindex #

fn localgetsetindex(expr Expression, index Index)

fn localset #

fn localset(module_ Module, index Index, value Expression) Expression

fn localsetgetindex #

fn localsetgetindex(expr Expression) Index

fn localsetgetvalue #

fn localsetgetvalue(expr Expression) Expression

fn localsetistee #

fn localsetistee(expr Expression) bool

fn localsetsetindex #

fn localsetsetindex(expr Expression, index Index)

fn localsetsetvalue #

fn localsetsetvalue(expr Expression, valueexpr Expression)

fn localtee #

fn localtee(module_ Module, index Index, value Expression, type_ Type) Expression

fn loop #

fn loop(module_ Module, in_ &i8, body Expression) Expression

fn loopgetbody #

fn loopgetbody(expr Expression) Expression

fn loopgetname #

fn loopgetname(expr Expression) &i8

fn loopsetbody #

fn loopsetbody(expr Expression, bodyexpr Expression)

fn loopsetname #

fn loopsetname(expr Expression, name &i8)

fn ltfloat32 #

fn ltfloat32() Op

fn ltfloat64 #

fn ltfloat64() Op

fn ltsint32 #

fn ltsint32() Op

fn ltsint64 #

fn ltsint64() Op

fn ltsveci16x8 #

fn ltsveci16x8() Op

fn ltsveci32x4 #

fn ltsveci32x4() Op

fn ltsveci64x2 #

fn ltsveci64x2() Op

fn ltsveci8x16 #

fn ltsveci8x16() Op

fn ltuint32 #

fn ltuint32() Op

fn ltuint64 #

fn ltuint64() Op

fn ltuveci16x8 #

fn ltuveci16x8() Op

fn ltuveci32x4 #

fn ltuveci32x4() Op

fn ltuveci8x16 #

fn ltuveci8x16() Op

fn ltvecf32x4 #

fn ltvecf32x4() Op

fn ltvecf64x2 #

fn ltvecf64x2() Op

fn maxfloat32 #

fn maxfloat32() Op

fn maxfloat64 #

fn maxfloat64() Op

fn maxsveci16x8 #

fn maxsveci16x8() Op

fn maxsveci32x4 #

fn maxsveci32x4() Op

fn maxsveci8x16 #

fn maxsveci8x16() Op

fn maxuveci16x8 #

fn maxuveci16x8() Op

fn maxuveci32x4 #

fn maxuveci32x4() Op

fn maxuveci8x16 #

fn maxuveci8x16() Op

fn maxvecf32x4 #

fn maxvecf32x4() Op

fn maxvecf64x2 #

fn maxvecf64x2() Op

fn memorycopy #

fn memorycopy(module_ Module, dest Expression, source Expression, size Expression, destmemory &i8, sourcememory &i8) Expression

fn memorycopygetdest #

fn memorycopygetdest(expr Expression) Expression

fn memorycopygetsize #

fn memorycopygetsize(expr Expression) Expression

fn memorycopygetsource #

fn memorycopygetsource(expr Expression) Expression

fn memorycopysetdest #

fn memorycopysetdest(expr Expression, destexpr Expression)

fn memorycopysetsize #

fn memorycopysetsize(expr Expression, sizeexpr Expression)

fn memorycopysetsource #

fn memorycopysetsource(expr Expression, sourceexpr Expression)

fn memoryfill #

fn memoryfill(module_ Module, dest Expression, value Expression, size Expression, memoryname &i8) Expression

fn memoryfillgetdest #

fn memoryfillgetdest(expr Expression) Expression

fn memoryfillgetsize #

fn memoryfillgetsize(expr Expression) Expression

fn memoryfillgetvalue #

fn memoryfillgetvalue(expr Expression) Expression

fn memoryfillsetdest #

fn memoryfillsetdest(expr Expression, destexpr Expression)

fn memoryfillsetsize #

fn memoryfillsetsize(expr Expression, sizeexpr Expression)

fn memoryfillsetvalue #

fn memoryfillsetvalue(expr Expression, valueexpr Expression)

fn memorygetinitial #

fn memorygetinitial(module_ Module, name &i8) Index

fn memorygetmax #

fn memorygetmax(module_ Module, name &i8) Index

fn memorygrow #

fn memorygrow(module_ Module, delta Expression, memoryname &i8, memoryis64 bool) Expression

fn memorygrowgetdelta #

fn memorygrowgetdelta(expr Expression) Expression

fn memorygrowsetdelta #

fn memorygrowsetdelta(expr Expression, deltaexpr Expression)

fn memoryhasmax #

fn memoryhasmax(module_ Module, name &i8) bool

fn memoryimportgetbase #

fn memoryimportgetbase(module_ Module, name &i8) &i8

fn memoryimportgetmodule #

fn memoryimportgetmodule(module_ Module, name &i8) &i8

fn memoryinit #

fn memoryinit(module_ Module, segment u32, dest Expression, offset Expression, size Expression, memoryname &i8) Expression

fn memoryinitgetdest #

fn memoryinitgetdest(expr Expression) Expression

fn memoryinitgetoffset #

fn memoryinitgetoffset(expr Expression) Expression

fn memoryinitgetsegment #

fn memoryinitgetsegment(expr Expression) u32

fn memoryinitgetsize #

fn memoryinitgetsize(expr Expression) Expression

fn memoryinitsetdest #

fn memoryinitsetdest(expr Expression, destexpr Expression)

fn memoryinitsetoffset #

fn memoryinitsetoffset(expr Expression, offsetexpr Expression)

fn memoryinitsetsegment #

fn memoryinitsetsegment(expr Expression, segmentindex u32)

fn memoryinitsetsize #

fn memoryinitsetsize(expr Expression, sizeexpr Expression)

fn memoryis64 #

fn memoryis64(module_ Module, name &i8) bool

fn memoryisshared_ #

fn memoryisshared_(module_ Module, name &i8) bool

fn memorysize #

fn memorysize(module_ Module, memoryname &i8, memoryis64 bool) Expression

fn minfloat32 #

fn minfloat32() Op

fn minfloat64 #

fn minfloat64() Op

fn minsveci16x8 #

fn minsveci16x8() Op

fn minsveci32x4 #

fn minsveci32x4() Op

fn minsveci8x16 #

fn minsveci8x16() Op

fn minuveci16x8 #

fn minuveci16x8() Op

fn minuveci32x4 #

fn minuveci32x4() Op

fn minuveci8x16 #

fn minuveci8x16() Op

fn minvecf32x4 #

fn minvecf32x4() Op

fn minvecf64x2 #

fn minvecf64x2() Op

fn moduleadddebuginfofilename #

fn moduleadddebuginfofilename(module_ Module, filename &i8) Index

fn moduleallocateandwrite #

fn moduleallocateandwrite(module_ Module, sourcemapurl &i8) ModuleAllocateAndWriteResult

fn moduleallocateandwritestackir #

fn moduleallocateandwritestackir(module_ Module, optimize bool) &i8

fn moduleallocateandwritetext #

fn moduleallocateandwritetext(module_ Module) &i8

fn moduleautodrop #

fn moduleautodrop(module_ Module)

fn modulecreate #

fn modulecreate() Module

fn moduledispose #

fn moduledispose(module_ Module)

fn modulegetdebuginfofilename #

fn modulegetdebuginfofilename(module_ Module, index Index) &i8

fn modulegetfeatures #

fn modulegetfeatures(module_ Module) Features

fn moduleinterpret #

fn moduleinterpret(module_ Module)

fn moduleoptimize #

fn moduleoptimize(module_ Module)

fn moduleparse #

fn moduleparse(text &i8) Module

fn moduleprint #

fn moduleprint(module_ Module)

fn moduleprintasmjs #

fn moduleprintasmjs(module_ Module)

fn moduleprintstackir #

fn moduleprintstackir(module_ Module, optimize bool)

fn moduleread #

fn moduleread(input &i8, inputsize usize) Module

fn modulerunpasses #

fn modulerunpasses(module_ Module, passes &&u8, numpasses Index)

fn modulesetfeatures #

fn modulesetfeatures(module_ Module, features Features)

fn modulesetfieldname #

fn modulesetfieldname(module_ Module, heaptype HeapType, index Index, name &i8)

fn modulesettypename #

fn modulesettypename(module_ Module, heaptype HeapType, name &i8)

fn moduleupdatemaps #

fn moduleupdatemaps(module_ Module)

fn modulevalidate #

fn modulevalidate(module_ Module) bool

fn modulewrite #

fn modulewrite(module_ Module, output &i8, outputsize usize) usize

fn modulewritestackir #

fn modulewritestackir(module_ Module, output &i8, outputsize usize, optimize bool) usize

fn modulewritetext #

fn modulewritetext(module_ Module, output &i8, outputsize usize) usize

fn modulewritewithsourcemap #

fn modulewritewithsourcemap(module_ Module, url &i8, output &i8, outputsize usize, sourcemap &i8, sourcemapsize usize) BufferSizes

fn mulfloat32 #

fn mulfloat32() Op

fn mulfloat64 #

fn mulfloat64() Op

fn mulint32 #

fn mulint32() Op

fn mulint64 #

fn mulint64() Op

fn mulvecf32x4 #

fn mulvecf32x4() Op

fn mulvecf64x2 #

fn mulvecf64x2() Op

fn mulveci16x8 #

fn mulveci16x8() Op

fn mulveci32x4 #

fn mulveci32x4() Op

fn mulveci64x2 #

fn mulveci64x2() Op

fn narrowsveci16x8toveci8x16 #

fn narrowsveci16x8toveci8x16() Op

fn narrowsveci32x4toveci16x8 #

fn narrowsveci32x4toveci16x8() Op

fn narrowuveci16x8toveci8x16 #

fn narrowuveci16x8toveci8x16() Op

fn narrowuveci32x4toveci16x8 #

fn narrowuveci32x4toveci16x8() Op

fn nearestfloat32 #

fn nearestfloat32() Op

fn nearestfloat64 #

fn nearestfloat64() Op

fn nearestvecf32x4 #

fn nearestvecf32x4() Op

fn nearestvecf64x2 #

fn nearestvecf64x2() Op

fn nefloat32 #

fn nefloat32() Op

fn nefloat64 #

fn nefloat64() Op

fn negfloat32 #

fn negfloat32() Op

fn negfloat64 #

fn negfloat64() Op

fn negvecf32x4 #

fn negvecf32x4() Op

fn negvecf64x2 #

fn negvecf64x2() Op

fn negveci16x8 #

fn negveci16x8() Op

fn negveci32x4 #

fn negveci32x4() Op

fn negveci64x2 #

fn negveci64x2() Op

fn negveci8x16 #

fn negveci8x16() Op

fn neint32 #

fn neint32() Op

fn neint64 #

fn neint64() Op

fn nevecf32x4 #

fn nevecf32x4() Op

fn nevecf64x2 #

fn nevecf64x2() Op

fn neveci16x8 #

fn neveci16x8() Op

fn neveci32x4 #

fn neveci32x4() Op

fn neveci64x2 #

fn neveci64x2() Op

fn neveci8x16 #

fn neveci8x16() Op

fn nop #

fn nop(module_ Module) Expression

fn notvec128 #

fn notvec128() Op

fn orint32 #

fn orint32() Op

fn orint64 #

fn orint64() Op

fn orvec128 #

fn orvec128() Op

fn packedtypeint16 #

fn packedtypeint16() PackedType

fn packedtypeint8 #

fn packedtypeint8() PackedType

fn packedtypenotpacked #

fn packedtypenotpacked() PackedType

fn pmaxvecf32x4 #

fn pmaxvecf32x4() Op

fn pmaxvecf64x2 #

fn pmaxvecf64x2() Op

fn pminvecf32x4 #

fn pminvecf32x4() Op

fn pminvecf64x2 #

fn pminvecf64x2() Op

fn pop #

fn pop(module_ Module, type_ Type) Expression

fn popcntint32 #

fn popcntint32() Op

fn popcntint64 #

fn popcntint64() Op

fn popcntveci8x16 #

fn popcntveci8x16() Op

fn promotefloat32 #

fn promotefloat32() Op

fn promotelowvecf32x4tovecf64x2 #

fn promotelowvecf32x4tovecf64x2() Op

fn q15mulrsatsveci16x8 #

fn q15mulrsatsveci16x8() Op

fn refas #

fn refas(module_ Module, op Op, value Expression) Expression

fn refasdata #

fn refasdata() Op

fn refasexternexternalize #

fn refasexternexternalize() Op

fn refasexterninternalize #

fn refasexterninternalize() Op

fn refasfunc #

fn refasfunc() Op

fn refasgetop #

fn refasgetop(expr Expression) Op

fn refasgetvalue #

fn refasgetvalue(expr Expression) Expression

fn refasi31 #

fn refasi31() Op

fn refasnonnull #

fn refasnonnull() Op

fn refassetop #

fn refassetop(expr Expression, op Op)

fn refassetvalue #

fn refassetvalue(expr Expression, valueexpr Expression)

fn refcast #

fn refcast(module_ Module, ref Expression, intendedtype HeapType) Expression

fn refcastgetintendedtype #

fn refcastgetintendedtype(expr Expression) HeapType

fn refcastgetref #

fn refcastgetref(expr Expression) Expression

fn refcastsetintendedtype #

fn refcastsetintendedtype(expr Expression, intendedtype HeapType)

fn refcastsetref #

fn refcastsetref(expr Expression, refexpr Expression)

fn refeq #

fn refeq(module_ Module, left Expression, right Expression) Expression

fn refeqgetleft #

fn refeqgetleft(expr Expression) Expression

fn refeqgetright #

fn refeqgetright(expr Expression) Expression

fn refeqsetleft #

fn refeqsetleft(expr Expression, left Expression)

fn refeqsetright #

fn refeqsetright(expr Expression, right Expression)

fn reffunc #

fn reffunc(module_ Module, func &i8, type_ Type) Expression

fn reffuncgetfunc #

fn reffuncgetfunc(expr Expression) &i8

fn reffuncsetfunc #

fn reffuncsetfunc(expr Expression, funcname &i8)

fn refis #

fn refis(module_ Module, op Op, value Expression) Expression

fn refisdata #

fn refisdata() Op

fn refisfunc #

fn refisfunc() Op

fn refisgetop #

fn refisgetop(expr Expression) Op

fn refisgetvalue #

fn refisgetvalue(expr Expression) Expression

fn refisi31 #

fn refisi31() Op

fn refisnull #

fn refisnull() Op

fn refissetop #

fn refissetop(expr Expression, op Op)

fn refissetvalue #

fn refissetvalue(expr Expression, valueexpr Expression)

fn refnull #

fn refnull(module_ Module, type_ Type) Expression

fn reftest #

fn reftest(module_ Module, ref Expression, intendedtype HeapType) Expression

fn reftestgetintendedtype #

fn reftestgetintendedtype(expr Expression) HeapType

fn reftestgetref #

fn reftestgetref(expr Expression) Expression

fn reftestsetintendedtype #

fn reftestsetintendedtype(expr Expression, intendedtype HeapType)

fn reftestsetref #

fn reftestsetref(expr Expression, refexpr Expression)

fn reinterpretfloat32 #

fn reinterpretfloat32() Op

fn reinterpretfloat64 #

fn reinterpretfloat64() Op

fn reinterpretint32 #

fn reinterpretint32() Op

fn reinterpretint64 #

fn reinterpretint64() Op

fn relooperaddblock #

fn relooperaddblock(relooper Relooper, code Expression) RelooperBlock

fn relooperaddblockwithswitch #

fn relooperaddblockwithswitch(relooper Relooper, code Expression, condition Expression) RelooperBlock

fn relooperaddbranch #

fn relooperaddbranch(from RelooperBlock, to RelooperBlock, condition Expression, code Expression)

fn relooperaddbranchforswitch #

fn relooperaddbranchforswitch(from RelooperBlock, to RelooperBlock, indexes &Index, numindexes Index, code Expression)

fn reloopercreate #

fn reloopercreate(module_ Module) Relooper

fn relooperrenderanddispose #

fn relooperrenderanddispose(relooper Relooper, entry RelooperBlock, labelhelper Index) Expression

fn removeelementsegment #

fn removeelementsegment(module_ Module, name &i8)

fn removeexport #

fn removeexport(module_ Module, externalname &i8)

fn removefunction #

fn removefunction(module_ Module, name &i8)

fn removeglobal #

fn removeglobal(module_ Module, name &i8)

fn removetable #

fn removetable(module_ Module, table &i8)

fn removetag #

fn removetag(module_ Module, name &i8)

fn remsint32 #

fn remsint32() Op

fn remsint64 #

fn remsint64() Op

fn remuint32 #

fn remuint32() Op

fn remuint64 #

fn remuint64() Op

fn replacelanevecf32x4 #

fn replacelanevecf32x4() Op

fn replacelanevecf64x2 #

fn replacelanevecf64x2() Op

fn replacelaneveci16x8 #

fn replacelaneveci16x8() Op

fn replacelaneveci32x4 #

fn replacelaneveci32x4() Op

fn replacelaneveci64x2 #

fn replacelaneveci64x2() Op

fn replacelaneveci8x16 #

fn replacelaneveci8x16() Op

fn ret #

fn ret(module_ Module, value Expression) Expression

fn rethrow #

fn rethrow(module_ Module, target &i8) Expression

fn rethrowgettarget #

fn rethrowgettarget(expr Expression) &i8

fn rethrowsettarget #

fn rethrowsettarget(expr Expression, target &i8)

fn returncall #

fn returncall(module_ Module, target &i8, operands &Expression, numoperands Index, returntype Type) Expression

fn returncallindirect #

fn returncallindirect(module_ Module, table &i8, target Expression, operands &Expression, numoperands Index, params Type, results Type) Expression

fn returngetvalue #

fn returngetvalue(expr Expression) Expression

fn returnsetvalue #

fn returnsetvalue(expr Expression, valueexpr Expression)

fn rotlint32 #

fn rotlint32() Op

fn rotlint64 #

fn rotlint64() Op

fn rotrint32 #

fn rotrint32() Op

fn rotrint64 #

fn rotrint64() Op

fn selectgetcondition #

fn selectgetcondition(expr Expression) Expression

fn selectgetiffalse #

fn selectgetiffalse(expr Expression) Expression

fn selectgetiftrue #

fn selectgetiftrue(expr Expression) Expression

fn selectsetcondition #

fn selectsetcondition(expr Expression, condexpr Expression)

fn selectsetiffalse #

fn selectsetiffalse(expr Expression, iffalseexpr Expression)

fn selectsetiftrue #

fn selectsetiftrue(expr Expression, iftrueexpr Expression)

fn setallowinliningfunctionswithloops #

fn setallowinliningfunctionswithloops(enabled bool)

fn setalwaysinlinemaxsize #

fn setalwaysinlinemaxsize(size Index)

fn setcolorsenabled #

fn setcolorsenabled(enabled bool)

fn setdebuginfo #

fn setdebuginfo(on bool)

fn setfastmath #

fn setfastmath(value bool)

fn setflexibleinlinemaxsize #

fn setflexibleinlinemaxsize(size Index)

fn setlowmemoryunused #

fn setlowmemoryunused(on bool)

fn setmemory #

fn setmemory(module_ Module, initial Index, maximum Index, exportname &i8, segments &&u8, segmentpassive &bool, segmentoffsets &Expression, segmentsizes &Index, numsegments Index, shared_ bool, memory64 bool, name &i8)

fn setonecallerinlinemaxsize #

fn setonecallerinlinemaxsize(size Index)

fn setoptimizelevel #

fn setoptimizelevel(level int)

fn setpassargument #

fn setpassargument(name &i8, value &i8)

fn setshrinklevel #

fn setshrinklevel(level int)

fn setstart #

fn setstart(module_ Module, start Function)

fn settypesystem #

fn settypesystem(typesystem TypeSystem)

fn setzerofilledmemory #

fn setzerofilledmemory(on bool)

fn shlint32 #

fn shlint32() Op

fn shlint64 #

fn shlint64() Op

fn shlveci16x8 #

fn shlveci16x8() Op

fn shlveci32x4 #

fn shlveci32x4() Op

fn shlveci64x2 #

fn shlveci64x2() Op

fn shlveci8x16 #

fn shlveci8x16() Op

fn shrsint32 #

fn shrsint32() Op

fn shrsint64 #

fn shrsint64() Op

fn shrsveci16x8 #

fn shrsveci16x8() Op

fn shrsveci32x4 #

fn shrsveci32x4() Op

fn shrsveci64x2 #

fn shrsveci64x2() Op

fn shrsveci8x16 #

fn shrsveci8x16() Op

fn shruint32 #

fn shruint32() Op

fn shruint64 #

fn shruint64() Op

fn shruveci16x8 #

fn shruveci16x8() Op

fn shruveci32x4 #

fn shruveci32x4() Op

fn shruveci64x2 #

fn shruveci64x2() Op

fn shruveci8x16 #

fn shruveci8x16() Op

fn sideeffectany #

fn sideeffectany() SideEffects

fn sideeffectbranches #

fn sideeffectbranches() SideEffects

fn sideeffectcalls #

fn sideeffectcalls() SideEffects

fn sideeffectdanglingpop #

fn sideeffectdanglingpop() SideEffects

fn sideeffectimplicittrap #

fn sideeffectimplicittrap() SideEffects

fn sideeffectisatomic #

fn sideeffectisatomic() SideEffects

fn sideeffectnone #

fn sideeffectnone() SideEffects

fn sideeffectreadsglobal #

fn sideeffectreadsglobal() SideEffects

fn sideeffectreadslocal #

fn sideeffectreadslocal() SideEffects

fn sideeffectreadsmemory #

fn sideeffectreadsmemory() SideEffects

fn sideeffectreadstable #

fn sideeffectreadstable() SideEffects

fn sideeffectthrows #

fn sideeffectthrows() SideEffects

fn sideeffecttrapsneverhappen #

fn sideeffecttrapsneverhappen() SideEffects

fn sideeffectwritesglobal #

fn sideeffectwritesglobal() SideEffects

fn sideeffectwriteslocal #

fn sideeffectwriteslocal() SideEffects

fn sideeffectwritesmemory #

fn sideeffectwritesmemory() SideEffects

fn sideeffectwritestable #

fn sideeffectwritestable() SideEffects

fn signaturetypegetparams #

fn signaturetypegetparams(heaptype HeapType) Type

fn signaturetypegetresults #

fn signaturetypegetresults(heaptype HeapType) Type

fn simdextract #

fn simdextract(module_ Module, op Op, vec Expression, index u8) Expression

fn simdextractgetindex #

fn simdextractgetindex(expr Expression) u8

fn simdextractgetop #

fn simdextractgetop(expr Expression) Op

fn simdextractgetvec #

fn simdextractgetvec(expr Expression) Expression

fn simdextractsetindex #

fn simdextractsetindex(expr Expression, index u8)

fn simdextractsetop #

fn simdextractsetop(expr Expression, op Op)

fn simdextractsetvec #

fn simdextractsetvec(expr Expression, vecexpr Expression)

fn simdload #

fn simdload(module_ Module, op Op, offset u32, align u32, ptr Expression, name &i8) Expression

fn simdloadgetalign #

fn simdloadgetalign(expr Expression) u32

fn simdloadgetoffset #

fn simdloadgetoffset(expr Expression) u32

fn simdloadgetop #

fn simdloadgetop(expr Expression) Op

fn simdloadgetptr #

fn simdloadgetptr(expr Expression) Expression

fn simdloadsetalign #

fn simdloadsetalign(expr Expression, align u32)

fn simdloadsetoffset #

fn simdloadsetoffset(expr Expression, offset u32)

fn simdloadsetop #

fn simdloadsetop(expr Expression, op Op)

fn simdloadsetptr #

fn simdloadsetptr(expr Expression, ptrexpr Expression)

fn simdloadstorelane #

fn simdloadstorelane(module_ Module, op Op, offset u32, align u32, index u8, ptr Expression, vec Expression, memoryname &i8) Expression

fn simdloadstorelanegetalign #

fn simdloadstorelanegetalign(expr Expression) u32

fn simdloadstorelanegetindex #

fn simdloadstorelanegetindex(expr Expression) u8

fn simdloadstorelanegetoffset #

fn simdloadstorelanegetoffset(expr Expression) u32

fn simdloadstorelanegetop #

fn simdloadstorelanegetop(expr Expression) Op

fn simdloadstorelanegetptr #

fn simdloadstorelanegetptr(expr Expression) Expression

fn simdloadstorelanegetvec #

fn simdloadstorelanegetvec(expr Expression) Expression

fn simdloadstorelaneisstore #

fn simdloadstorelaneisstore(expr Expression) bool

fn simdloadstorelanesetalign #

fn simdloadstorelanesetalign(expr Expression, align u32)

fn simdloadstorelanesetindex #

fn simdloadstorelanesetindex(expr Expression, index u8)

fn simdloadstorelanesetoffset #

fn simdloadstorelanesetoffset(expr Expression, offset u32)

fn simdloadstorelanesetop #

fn simdloadstorelanesetop(expr Expression, op Op)

fn simdloadstorelanesetptr #

fn simdloadstorelanesetptr(expr Expression, ptrexpr Expression)

fn simdloadstorelanesetvec #

fn simdloadstorelanesetvec(expr Expression, vecexpr Expression)

fn simdreplace #

fn simdreplace(module_ Module, op Op, vec Expression, index u8, value Expression) Expression

fn simdreplacegetindex #

fn simdreplacegetindex(expr Expression) u8

fn simdreplacegetop #

fn simdreplacegetop(expr Expression) Op

fn simdreplacegetvalue #

fn simdreplacegetvalue(expr Expression) Expression

fn simdreplacegetvec #

fn simdreplacegetvec(expr Expression) Expression

fn simdreplacesetindex #

fn simdreplacesetindex(expr Expression, index u8)

fn simdreplacesetop #

fn simdreplacesetop(expr Expression, op Op)

fn simdreplacesetvalue #

fn simdreplacesetvalue(expr Expression, valueexpr Expression)

fn simdreplacesetvec #

fn simdreplacesetvec(expr Expression, vecexpr Expression)

fn simdshift #

fn simdshift(module_ Module, op Op, vec Expression, shift Expression) Expression

fn simdshiftgetop #

fn simdshiftgetop(expr Expression) Op

fn simdshiftgetshift #

fn simdshiftgetshift(expr Expression) Expression

fn simdshiftgetvec #

fn simdshiftgetvec(expr Expression) Expression

fn simdshiftsetop #

fn simdshiftsetop(expr Expression, op Op)

fn simdshiftsetshift #

fn simdshiftsetshift(expr Expression, shiftexpr Expression)

fn simdshiftsetvec #

fn simdshiftsetvec(expr Expression, vecexpr Expression)

fn simdshuffle #

fn simdshuffle(module_ Module, left Expression, right Expression, mask &u8) Expression

fn simdshufflegetleft #

fn simdshufflegetleft(expr Expression) Expression

fn simdshufflegetmask #

fn simdshufflegetmask(expr Expression, mask &u8)

fn simdshufflegetright #

fn simdshufflegetright(expr Expression) Expression

fn simdshufflesetleft #

fn simdshufflesetleft(expr Expression, leftexpr Expression)

fn simdshufflesetmask #

fn simdshufflesetmask(expr Expression, mask &u8)

fn simdshufflesetright #

fn simdshufflesetright(expr Expression, rightexpr Expression)

fn simdternary #

fn simdternary(module_ Module, op Op, a Expression, b Expression, c Expression) Expression

fn simdternarygeta #

fn simdternarygeta(expr Expression) Expression

fn simdternarygetb #

fn simdternarygetb(expr Expression) Expression

fn simdternarygetc #

fn simdternarygetc(expr Expression) Expression

fn simdternarygetop #

fn simdternarygetop(expr Expression) Op

fn simdternaryseta #

fn simdternaryseta(expr Expression, aexpr Expression)

fn simdternarysetb #

fn simdternarysetb(expr Expression, bexpr Expression)

fn simdternarysetc #

fn simdternarysetc(expr Expression, cexpr Expression)

fn simdternarysetop #

fn simdternarysetop(expr Expression, op Op)

fn splatvecf32x4 #

fn splatvecf32x4() Op

fn splatvecf64x2 #

fn splatvecf64x2() Op

fn splatveci16x8 #

fn splatveci16x8() Op

fn splatveci32x4 #

fn splatveci32x4() Op

fn splatveci64x2 #

fn splatveci64x2() Op

fn splatveci8x16 #

fn splatveci8x16() Op

fn sqrtfloat32 #

fn sqrtfloat32() Op

fn sqrtfloat64 #

fn sqrtfloat64() Op

fn sqrtvecf32x4 #

fn sqrtvecf32x4() Op

fn sqrtvecf64x2 #

fn sqrtvecf64x2() Op

fn store #

fn store(module_ Module, bytes u32, offset u32, align u32, ptr Expression, value Expression, type_ Type, memoryname &i8) Expression

fn store16lanevec128 #

fn store16lanevec128() Op

fn store32lanevec128 #

fn store32lanevec128() Op

fn store64lanevec128 #

fn store64lanevec128() Op

fn store8lanevec128 #

fn store8lanevec128() Op

fn storegetalign #

fn storegetalign(expr Expression) u32

fn storegetbytes #

fn storegetbytes(expr Expression) u32

fn storegetoffset #

fn storegetoffset(expr Expression) u32

fn storegetptr #

fn storegetptr(expr Expression) Expression

fn storegetvalue #

fn storegetvalue(expr Expression) Expression

fn storegetvaluetype #

fn storegetvaluetype(expr Expression) Type

fn storeisatomic #

fn storeisatomic(expr Expression) bool

fn storesetalign #

fn storesetalign(expr Expression, align u32)

fn storesetatomic #

fn storesetatomic(expr Expression, isatomic bool)

fn storesetbytes #

fn storesetbytes(expr Expression, bytes u32)

fn storesetoffset #

fn storesetoffset(expr Expression, offset u32)

fn storesetptr #

fn storesetptr(expr Expression, ptrexpr Expression)

fn storesetvalue #

fn storesetvalue(expr Expression, valueexpr Expression)

fn storesetvaluetype #

fn storesetvaluetype(expr Expression, valuetype Type)

fn stringas #

fn stringas(module_ Module, op Op, ref Expression) Expression

fn stringasgetop #

fn stringasgetop(expr Expression) Op

fn stringasgetref #

fn stringasgetref(expr Expression) Expression

fn stringasiter #

fn stringasiter() Op

fn stringassetop #

fn stringassetop(expr Expression, op Op)

fn stringassetref #

fn stringassetref(expr Expression, refexpr Expression)

fn stringaswtf16 #

fn stringaswtf16() Op

fn stringaswtf8 #

fn stringaswtf8() Op

fn stringconcat #

fn stringconcat(module_ Module, left Expression, right Expression) Expression

fn stringconcatgetleft #

fn stringconcatgetleft(expr Expression) Expression

fn stringconcatgetright #

fn stringconcatgetright(expr Expression) Expression

fn stringconcatsetleft #

fn stringconcatsetleft(expr Expression, leftexpr Expression)

fn stringconcatsetright #

fn stringconcatsetright(expr Expression, rightexpr Expression)

fn stringconst #

fn stringconst(module_ Module, name &i8) Expression

fn stringconstgetstring #

fn stringconstgetstring(expr Expression) &i8

fn stringconstsetstring #

fn stringconstsetstring(expr Expression, stringstr &i8)

fn stringencode #

fn stringencode(module_ Module, op Op, ref Expression, ptr Expression, start Expression) Expression

fn stringencodegetop #

fn stringencodegetop(expr Expression) Op

fn stringencodegetptr #

fn stringencodegetptr(expr Expression) Expression

fn stringencodegetref #

fn stringencodegetref(expr Expression) Expression

fn stringencodegetstart #

fn stringencodegetstart(expr Expression) Expression

fn stringencodesetop #

fn stringencodesetop(expr Expression, op Op)

fn stringencodesetptr #

fn stringencodesetptr(expr Expression, ptrexpr Expression)

fn stringencodesetref #

fn stringencodesetref(expr Expression, refexpr Expression)

fn stringencodesetstart #

fn stringencodesetstart(expr Expression, startexpr Expression)

fn stringencodeutf8 #

fn stringencodeutf8() Op

fn stringencodeutf8array #

fn stringencodeutf8array() Op

fn stringencodewtf16 #

fn stringencodewtf16() Op

fn stringencodewtf16array #

fn stringencodewtf16array() Op

fn stringencodewtf8 #

fn stringencodewtf8() Op

fn stringencodewtf8array #

fn stringencodewtf8array() Op

fn stringeq #

fn stringeq(module_ Module, left Expression, right Expression) Expression

fn stringeqgetleft #

fn stringeqgetleft(expr Expression) Expression

fn stringeqgetright #

fn stringeqgetright(expr Expression) Expression

fn stringeqsetleft #

fn stringeqsetleft(expr Expression, leftexpr Expression)

fn stringeqsetright #

fn stringeqsetright(expr Expression, rightexpr Expression)

fn stringitermove #

fn stringitermove(module_ Module, op Op, ref Expression, num Expression) Expression

fn stringitermoveadvance #

fn stringitermoveadvance() Op

fn stringitermovegetnum #

fn stringitermovegetnum(expr Expression) Expression

fn stringitermovegetop #

fn stringitermovegetop(expr Expression) Op

fn stringitermovegetref #

fn stringitermovegetref(expr Expression) Expression

fn stringitermoverewind #

fn stringitermoverewind() Op

fn stringitermovesetnum #

fn stringitermovesetnum(expr Expression, numexpr Expression)

fn stringitermovesetop #

fn stringitermovesetop(expr Expression, op Op)

fn stringitermovesetref #

fn stringitermovesetref(expr Expression, refexpr Expression)

fn stringiternext #

fn stringiternext(module_ Module, ref Expression) Expression

fn stringiternextgetref #

fn stringiternextgetref(expr Expression) Expression

fn stringiternextsetref #

fn stringiternextsetref(expr Expression, refexpr Expression)

fn stringmeasure #

fn stringmeasure(module_ Module, op Op, ref Expression) Expression

fn stringmeasuregetop #

fn stringmeasuregetop(expr Expression) Op

fn stringmeasuregetref #

fn stringmeasuregetref(expr Expression) Expression

fn stringmeasureisusv #

fn stringmeasureisusv() Op

fn stringmeasuresetop #

fn stringmeasuresetop(expr Expression, op Op)

fn stringmeasuresetref #

fn stringmeasuresetref(expr Expression, refexpr Expression)

fn stringmeasureutf8 #

fn stringmeasureutf8() Op

fn stringmeasurewtf16 #

fn stringmeasurewtf16() Op

fn stringmeasurewtf16view #

fn stringmeasurewtf16view() Op

fn stringmeasurewtf8 #

fn stringmeasurewtf8() Op

fn stringnew #

fn stringnew(module_ Module, op Op, ptr Expression, length Expression, start Expression, end Expression) Expression

fn stringnewgetend #

fn stringnewgetend(expr Expression) Expression

fn stringnewgetlength #

fn stringnewgetlength(expr Expression) Expression

fn stringnewgetop #

fn stringnewgetop(expr Expression) Op

fn stringnewgetptr #

fn stringnewgetptr(expr Expression) Expression

fn stringnewgetstart #

fn stringnewgetstart(expr Expression) Expression

fn stringnewreplace #

fn stringnewreplace() Op

fn stringnewreplacearray #

fn stringnewreplacearray() Op

fn stringnewsetend #

fn stringnewsetend(expr Expression, endexpr Expression)

fn stringnewsetlength #

fn stringnewsetlength(expr Expression, lengthexpr Expression)

fn stringnewsetop #

fn stringnewsetop(expr Expression, op Op)

fn stringnewsetptr #

fn stringnewsetptr(expr Expression, ptrexpr Expression)

fn stringnewsetstart #

fn stringnewsetstart(expr Expression, startexpr Expression)

fn stringnewutf8 #

fn stringnewutf8() Op

fn stringnewutf8array #

fn stringnewutf8array() Op

fn stringnewwtf16 #

fn stringnewwtf16() Op

fn stringnewwtf16array #

fn stringnewwtf16array() Op

fn stringnewwtf8 #

fn stringnewwtf8() Op

fn stringnewwtf8array #

fn stringnewwtf8array() Op

fn stringsliceiter #

fn stringsliceiter(module_ Module, ref Expression, num Expression) Expression

fn stringsliceitergetnum #

fn stringsliceitergetnum(expr Expression) Expression

fn stringsliceitergetref #

fn stringsliceitergetref(expr Expression) Expression

fn stringsliceitersetnum #

fn stringsliceitersetnum(expr Expression, numexpr Expression)

fn stringsliceitersetref #

fn stringsliceitersetref(expr Expression, refexpr Expression)

fn stringslicewtf #

fn stringslicewtf(module_ Module, op Op, ref Expression, start Expression, end Expression) Expression

fn stringslicewtf16 #

fn stringslicewtf16() Op

fn stringslicewtf8 #

fn stringslicewtf8() Op

fn stringslicewtfgetend #

fn stringslicewtfgetend(expr Expression) Expression

fn stringslicewtfgetop #

fn stringslicewtfgetop(expr Expression) Op

fn stringslicewtfgetref #

fn stringslicewtfgetref(expr Expression) Expression

fn stringslicewtfgetstart #

fn stringslicewtfgetstart(expr Expression) Expression

fn stringslicewtfsetend #

fn stringslicewtfsetend(expr Expression, endexpr Expression)

fn stringslicewtfsetop #

fn stringslicewtfsetop(expr Expression, op Op)

fn stringslicewtfsetref #

fn stringslicewtfsetref(expr Expression, refexpr Expression)

fn stringslicewtfsetstart #

fn stringslicewtfsetstart(expr Expression, startexpr Expression)

fn stringwtf16get #

fn stringwtf16get(module_ Module, ref Expression, pos Expression) Expression

fn stringwtf16getgetpos #

fn stringwtf16getgetpos(expr Expression) Expression

fn stringwtf16getgetref #

fn stringwtf16getgetref(expr Expression) Expression

fn stringwtf16getsetpos #

fn stringwtf16getsetpos(expr Expression, posexpr Expression)

fn stringwtf16getsetref #

fn stringwtf16getsetref(expr Expression, refexpr Expression)

fn stringwtf8advance #

fn stringwtf8advance(module_ Module, ref Expression, pos Expression, bytes Expression) Expression

fn stringwtf8advancegetbytes #

fn stringwtf8advancegetbytes(expr Expression) Expression

fn stringwtf8advancegetpos #

fn stringwtf8advancegetpos(expr Expression) Expression

fn stringwtf8advancegetref #

fn stringwtf8advancegetref(expr Expression) Expression

fn stringwtf8advancesetbytes #

fn stringwtf8advancesetbytes(expr Expression, bytesexpr Expression)

fn stringwtf8advancesetpos #

fn stringwtf8advancesetpos(expr Expression, posexpr Expression)

fn stringwtf8advancesetref #

fn stringwtf8advancesetref(expr Expression, refexpr Expression)

fn structget #

fn structget(module_ Module, index Index, ref Expression, type_ Type, signed_ bool) Expression

fn structgetgetindex #

fn structgetgetindex(expr Expression) Index

fn structgetgetref #

fn structgetgetref(expr Expression) Expression

fn structgetissigned #

fn structgetissigned(expr Expression) bool

fn structgetsetindex #

fn structgetsetindex(expr Expression, index Index)

fn structgetsetref #

fn structgetsetref(expr Expression, refexpr Expression)

fn structgetsetsigned #

fn structgetsetsigned(expr Expression, signed_ bool)

fn structnew #

fn structnew(module_ Module, operands &Expression, numoperands Index, type_ HeapType) Expression

fn structnewappendoperand #

fn structnewappendoperand(expr Expression, operandexpr Expression) Index

fn structnewgetnumoperands #

fn structnewgetnumoperands(expr Expression) Index

fn structnewgetoperandat #

fn structnewgetoperandat(expr Expression, index Index) Expression

fn structnewinsertoperandat #

fn structnewinsertoperandat(expr Expression, index Index, operandexpr Expression)

fn structnewremoveoperandat #

fn structnewremoveoperandat(expr Expression, index Index) Expression

fn structnewsetoperandat #

fn structnewsetoperandat(expr Expression, index Index, operandexpr Expression)

fn structset #

fn structset(module_ Module, index Index, ref Expression, value Expression) Expression

fn structsetgetindex #

fn structsetgetindex(expr Expression) Index

fn structsetgetref #

fn structsetgetref(expr Expression) Expression

fn structsetgetvalue #

fn structsetgetvalue(expr Expression) Expression

fn structsetsetindex #

fn structsetsetindex(expr Expression, index Index)

fn structsetsetref #

fn structsetsetref(expr Expression, refexpr Expression)

fn structsetsetvalue #

fn structsetsetvalue(expr Expression, valueexpr Expression)

fn structtypegetfieldpackedtype #

fn structtypegetfieldpackedtype(heaptype HeapType, index Index) PackedType

fn structtypegetfieldtype #

fn structtypegetfieldtype(heaptype HeapType, index Index) Type

fn structtypegetnumfields #

fn structtypegetnumfields(heaptype HeapType) Index

fn structtypeisfieldmutable #

fn structtypeisfieldmutable(heaptype HeapType, index Index) bool

fn subfloat32 #

fn subfloat32() Op

fn subfloat64 #

fn subfloat64() Op

fn subint32 #

fn subint32() Op

fn subint64 #

fn subint64() Op

fn subsatsveci16x8 #

fn subsatsveci16x8() Op

fn subsatsveci8x16 #

fn subsatsveci8x16() Op

fn subsatuveci16x8 #

fn subsatuveci16x8() Op

fn subsatuveci8x16 #

fn subsatuveci8x16() Op

fn subvecf32x4 #

fn subvecf32x4() Op

fn subvecf64x2 #

fn subvecf64x2() Op

fn subveci16x8 #

fn subveci16x8() Op

fn subveci32x4 #

fn subveci32x4() Op

fn subveci64x2 #

fn subveci64x2() Op

fn subveci8x16 #

fn subveci8x16() Op

fn switch #

fn switch(module_ Module, names &&u8, numnames Index, defaultname &i8, condition Expression, value Expression) Expression