Module v.gen.wasm.binaryen stdlib

v.gen.wasm.binaryen
Version:
0.3.3
License:
MIT
Dependencies from vmod:
0
Imports:
0
Imported by:
1
Repository:
OS-specific
Show selected OS-specific symbols.
Backend-specific
Show selected Backend-specific symbols.

Dependencies defined in v.mod

This section is empty.

Imports

This section is empty.

Imported by

Aliases

This section is empty.

Constants

This section is empty.

Sum types

This section is empty.

Functions

#fn absfloat32

c:BinaryenAbsFloat32
fn absfloat32() Op

#fn absfloat64

c:BinaryenAbsFloat64
fn absfloat64() Op

#fn absvecf32x4

c:BinaryenAbsVecF32x4
fn absvecf32x4() Op

#fn absvecf64x2

c:BinaryenAbsVecF64x2
fn absvecf64x2() Op

#fn absveci16x8

c:BinaryenAbsVecI16x8
fn absveci16x8() Op

#fn absveci32x4

c:BinaryenAbsVecI32x4
fn absveci32x4() Op

#fn absveci64x2

c:BinaryenAbsVecI64x2
fn absveci64x2() Op

#fn absveci8x16

c:BinaryenAbsVecI8x16
fn absveci8x16() Op

#fn addactiveelementsegment

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

#fn addcustomsection

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

#fn addexport

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

#fn addfloat32

c:BinaryenAddFloat32
fn addfloat32() Op

#fn addfloat64

c:BinaryenAddFloat64
fn addfloat64() Op

#fn addfunction

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

#fn addfunctionexport

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

#fn addfunctionimport

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

#fn addglobal

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

#fn addglobalexport

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

#fn addglobalimport

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

#fn addint32

c:BinaryenAddInt32
fn addint32() Op

#fn addint64

c:BinaryenAddInt64
fn addint64() Op

#fn addmemoryexport

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

#fn addmemoryimport

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

#fn addpassiveelementsegment

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

#fn addsatsveci16x8

c:BinaryenAddSatSVecI16x8
fn addsatsveci16x8() Op

#fn addsatsveci8x16

c:BinaryenAddSatSVecI8x16
fn addsatsveci8x16() Op

#fn addsatuveci16x8

c:BinaryenAddSatUVecI16x8
fn addsatuveci16x8() Op

#fn addsatuveci8x16

c:BinaryenAddSatUVecI8x16
fn addsatuveci8x16() Op

#fn addtable

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

#fn addtableexport

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

#fn addtableimport

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

#fn addtag

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

#fn addtagexport

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

#fn addtagimport

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

#fn addvecf32x4

c:BinaryenAddVecF32x4
fn addvecf32x4() Op

#fn addvecf64x2

c:BinaryenAddVecF64x2
fn addvecf64x2() Op

#fn addveci16x8

c:BinaryenAddVecI16x8
fn addveci16x8() Op

#fn addveci32x4

c:BinaryenAddVecI32x4
fn addveci32x4() Op

#fn addveci64x2

c:BinaryenAddVecI64x2
fn addveci64x2() Op

#fn addveci8x16

c:BinaryenAddVecI8x16
fn addveci8x16() Op

#fn alltrueveci16x8

c:BinaryenAllTrueVecI16x8
fn alltrueveci16x8() Op

#fn alltrueveci32x4

c:BinaryenAllTrueVecI32x4
fn alltrueveci32x4() Op

#fn alltrueveci64x2

c:BinaryenAllTrueVecI64x2
fn alltrueveci64x2() Op

#fn alltrueveci8x16

c:BinaryenAllTrueVecI8x16
fn alltrueveci8x16() Op

#fn andint32

c:BinaryenAndInt32
fn andint32() Op

#fn andint64

c:BinaryenAndInt64
fn andint64() Op

#fn andnotvec128

c:BinaryenAndNotVec128
fn andnotvec128() Op

#fn andvec128

c:BinaryenAndVec128
fn andvec128() Op

#fn anytruevec128

c:BinaryenAnyTrueVec128
fn anytruevec128() Op

#fn arecolorsenabled

c:BinaryenAreColorsEnabled
fn arecolorsenabled() bool

#fn arraycopy

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

#fn arraycopygetdestindex

c:BinaryenArrayCopyGetDestIndex
fn arraycopygetdestindex(expr Expression) Expression

#fn arraycopygetdestref

c:BinaryenArrayCopyGetDestRef
fn arraycopygetdestref(expr Expression) Expression

#fn arraycopygetlength

c:BinaryenArrayCopyGetLength
fn arraycopygetlength(expr Expression) Expression

#fn arraycopygetsrcindex

c:BinaryenArrayCopyGetSrcIndex
fn arraycopygetsrcindex(expr Expression) Expression

#fn arraycopygetsrcref

c:BinaryenArrayCopyGetSrcRef
fn arraycopygetsrcref(expr Expression) Expression

#fn arraycopysetdestindex

c:BinaryenArrayCopySetDestIndex
fn arraycopysetdestindex(expr Expression, destindexexpr Expression)

#fn arraycopysetdestref

c:BinaryenArrayCopySetDestRef
fn arraycopysetdestref(expr Expression, destrefexpr Expression)

#fn arraycopysetlength

c:BinaryenArrayCopySetLength
fn arraycopysetlength(expr Expression, lengthexpr Expression)

#fn arraycopysetsrcindex

c:BinaryenArrayCopySetSrcIndex
fn arraycopysetsrcindex(expr Expression, srcindexexpr Expression)

#fn arraycopysetsrcref

c:BinaryenArrayCopySetSrcRef
fn arraycopysetsrcref(expr Expression, srcrefexpr Expression)

#fn arrayget

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

#fn arraygetgetindex

c:BinaryenArrayGetGetIndex
fn arraygetgetindex(expr Expression) Expression

#fn arraygetgetref

c:BinaryenArrayGetGetRef
fn arraygetgetref(expr Expression) Expression

#fn arraygetissigned

c:BinaryenArrayGetIsSigned
fn arraygetissigned(expr Expression) bool

#fn arraygetsetindex

c:BinaryenArrayGetSetIndex
fn arraygetsetindex(expr Expression, indexexpr Expression)

#fn arraygetsetref

c:BinaryenArrayGetSetRef
fn arraygetsetref(expr Expression, refexpr Expression)

#fn arraygetsetsigned

c:BinaryenArrayGetSetSigned
fn arraygetsetsigned(expr Expression, signed_ bool)

#fn arrayinit

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

#fn arrayinitappendvalue

c:BinaryenArrayInitAppendValue
fn arrayinitappendvalue(expr Expression, valueexpr Expression) Index

#fn arrayinitgetnumvalues

c:BinaryenArrayInitGetNumValues
fn arrayinitgetnumvalues(expr Expression) Index

#fn arrayinitgetvalueat

c:BinaryenArrayInitGetValueAt
fn arrayinitgetvalueat(expr Expression, index Index) Expression

#fn arrayinitinsertvalueat

c:BinaryenArrayInitInsertValueAt
fn arrayinitinsertvalueat(expr Expression, index Index, valueexpr Expression)

#fn arrayinitremovevalueat

c:BinaryenArrayInitRemoveValueAt
fn arrayinitremovevalueat(expr Expression, index Index) Expression

#fn arrayinitsetvalueat

c:BinaryenArrayInitSetValueAt
fn arrayinitsetvalueat(expr Expression, index Index, valueexpr Expression)

#fn arraylen

c:BinaryenArrayLen
fn arraylen(module_ Module, ref Expression) Expression

#fn arraylengetref

c:BinaryenArrayLenGetRef
fn arraylengetref(expr Expression) Expression

#fn arraylensetref

c:BinaryenArrayLenSetRef
fn arraylensetref(expr Expression, refexpr Expression)

#fn arraynew

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

#fn arraynewgetinit

c:BinaryenArrayNewGetInit
fn arraynewgetinit(expr Expression) Expression

#fn arraynewgetsize

c:BinaryenArrayNewGetSize
fn arraynewgetsize(expr Expression) Expression

#fn arraynewsetinit

c:BinaryenArrayNewSetInit
fn arraynewsetinit(expr Expression, initexpr Expression)

#fn arraynewsetsize

c:BinaryenArrayNewSetSize
fn arraynewsetsize(expr Expression, sizeexpr Expression)

#fn arrayset

c:BinaryenArraySet
fn arrayset(module_ Module, ref Expression, index Expression, value Expression) Expression

#fn arraysetgetindex

c:BinaryenArraySetGetIndex
fn arraysetgetindex(expr Expression) Expression

#fn arraysetgetref

c:BinaryenArraySetGetRef
fn arraysetgetref(expr Expression) Expression

#fn arraysetgetvalue

c:BinaryenArraySetGetValue
fn arraysetgetvalue(expr Expression) Expression

#fn arraysetsetindex

c:BinaryenArraySetSetIndex
fn arraysetsetindex(expr Expression, indexexpr Expression)

#fn arraysetsetref

c:BinaryenArraySetSetRef
fn arraysetsetref(expr Expression, refexpr Expression)

#fn arraysetsetvalue

c:BinaryenArraySetSetValue
fn arraysetsetvalue(expr Expression, valueexpr Expression)

#fn arraytypegetelementpackedtype

c:BinaryenArrayTypeGetElementPackedType
fn arraytypegetelementpackedtype(heaptype HeapType) PackedType

#fn arraytypegetelementtype

c:BinaryenArrayTypeGetElementType
fn arraytypegetelementtype(heaptype HeapType) Type

#fn arraytypeiselementmutable

c:BinaryenArrayTypeIsElementMutable
fn arraytypeiselementmutable(heaptype HeapType) bool

#fn atomiccmpxchg

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

#fn atomiccmpxchggetbytes

c:BinaryenAtomicCmpxchgGetBytes
fn atomiccmpxchggetbytes(expr Expression) u32

#fn atomiccmpxchggetexpected

c:BinaryenAtomicCmpxchgGetExpected
fn atomiccmpxchggetexpected(expr Expression) Expression

#fn atomiccmpxchggetoffset

c:BinaryenAtomicCmpxchgGetOffset
fn atomiccmpxchggetoffset(expr Expression) u32

#fn atomiccmpxchggetptr

c:BinaryenAtomicCmpxchgGetPtr
fn atomiccmpxchggetptr(expr Expression) Expression

#fn atomiccmpxchggetreplacement

c:BinaryenAtomicCmpxchgGetReplacement
fn atomiccmpxchggetreplacement(expr Expression) Expression

#fn atomiccmpxchgsetbytes

c:BinaryenAtomicCmpxchgSetBytes
fn atomiccmpxchgsetbytes(expr Expression, bytes u32)

#fn atomiccmpxchgsetexpected

c:BinaryenAtomicCmpxchgSetExpected
fn atomiccmpxchgsetexpected(expr Expression, expectedexpr Expression)

#fn atomiccmpxchgsetoffset

c:BinaryenAtomicCmpxchgSetOffset
fn atomiccmpxchgsetoffset(expr Expression, offset u32)

#fn atomiccmpxchgsetptr

c:BinaryenAtomicCmpxchgSetPtr
fn atomiccmpxchgsetptr(expr Expression, ptrexpr Expression)

#fn atomiccmpxchgsetreplacement

c:BinaryenAtomicCmpxchgSetReplacement
fn atomiccmpxchgsetreplacement(expr Expression, replacementexpr Expression)

#fn atomicfence

c:BinaryenAtomicFence
fn atomicfence(module_ Module) Expression

#fn atomicfencegetorder

c:BinaryenAtomicFenceGetOrder
fn atomicfencegetorder(expr Expression) u8

#fn atomicfencesetorder

c:BinaryenAtomicFenceSetOrder
fn atomicfencesetorder(expr Expression, order u8)

#fn atomicload

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

#fn atomicnotify

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

#fn atomicnotifygetnotifycount

c:BinaryenAtomicNotifyGetNotifyCount
fn atomicnotifygetnotifycount(expr Expression) Expression

#fn atomicnotifygetptr

c:BinaryenAtomicNotifyGetPtr
fn atomicnotifygetptr(expr Expression) Expression

#fn atomicnotifysetnotifycount

c:BinaryenAtomicNotifySetNotifyCount
fn atomicnotifysetnotifycount(expr Expression, notifycountexpr Expression)

#fn atomicnotifysetptr

c:BinaryenAtomicNotifySetPtr
fn atomicnotifysetptr(expr Expression, ptrexpr Expression)

#fn atomicrmw

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

#fn atomicrmwadd

c:BinaryenAtomicRMWAdd
fn atomicrmwadd() Op

#fn atomicrmwand

c:BinaryenAtomicRMWAnd
fn atomicrmwand() Op

#fn atomicrmwgetbytes

c:BinaryenAtomicRMWGetBytes
fn atomicrmwgetbytes(expr Expression) u32

#fn atomicrmwgetoffset

c:BinaryenAtomicRMWGetOffset
fn atomicrmwgetoffset(expr Expression) u32

#fn atomicrmwgetop

c:BinaryenAtomicRMWGetOp
fn atomicrmwgetop(expr Expression) Op

#fn atomicrmwgetptr

c:BinaryenAtomicRMWGetPtr
fn atomicrmwgetptr(expr Expression) Expression

#fn atomicrmwgetvalue

c:BinaryenAtomicRMWGetValue
fn atomicrmwgetvalue(expr Expression) Expression

#fn atomicrmwor

c:BinaryenAtomicRMWOr
fn atomicrmwor() Op

#fn atomicrmwsetbytes

c:BinaryenAtomicRMWSetBytes
fn atomicrmwsetbytes(expr Expression, bytes u32)

#fn atomicrmwsetoffset

c:BinaryenAtomicRMWSetOffset
fn atomicrmwsetoffset(expr Expression, offset u32)

#fn atomicrmwsetop

c:BinaryenAtomicRMWSetOp
fn atomicrmwsetop(expr Expression, op Op)

#fn atomicrmwsetptr

c:BinaryenAtomicRMWSetPtr
fn atomicrmwsetptr(expr Expression, ptrexpr Expression)

#fn atomicrmwsetvalue

c:BinaryenAtomicRMWSetValue
fn atomicrmwsetvalue(expr Expression, valueexpr Expression)

#fn atomicrmwsub

c:BinaryenAtomicRMWSub
fn atomicrmwsub() Op

#fn atomicrmwxchg

c:BinaryenAtomicRMWXchg
fn atomicrmwxchg() Op

#fn atomicrmwxor

c:BinaryenAtomicRMWXor
fn atomicrmwxor() Op

#fn atomicstore

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

#fn atomicwait

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

#fn atomicwaitgetexpected

c:BinaryenAtomicWaitGetExpected
fn atomicwaitgetexpected(expr Expression) Expression

#fn atomicwaitgetexpectedtype

c:BinaryenAtomicWaitGetExpectedType
fn atomicwaitgetexpectedtype(expr Expression) Type

#fn atomicwaitgetptr

c:BinaryenAtomicWaitGetPtr
fn atomicwaitgetptr(expr Expression) Expression

#fn atomicwaitgettimeout

c:BinaryenAtomicWaitGetTimeout
fn atomicwaitgettimeout(expr Expression) Expression

#fn atomicwaitsetexpected

c:BinaryenAtomicWaitSetExpected
fn atomicwaitsetexpected(expr Expression, expectedexpr Expression)

#fn atomicwaitsetexpectedtype

c:BinaryenAtomicWaitSetExpectedType
fn atomicwaitsetexpectedtype(expr Expression, expectedtype Type)

#fn atomicwaitsetptr

c:BinaryenAtomicWaitSetPtr
fn atomicwaitsetptr(expr Expression, ptrexpr Expression)

#fn atomicwaitsettimeout

c:BinaryenAtomicWaitSetTimeout
fn atomicwaitsettimeout(expr Expression, timeoutexpr Expression)

#fn avgruveci16x8

c:BinaryenAvgrUVecI16x8
fn avgruveci16x8() Op

#fn avgruveci8x16

c:BinaryenAvgrUVecI8x16
fn avgruveci8x16() Op

#fn bif

c:BinaryenIf
fn bif(module_ Module, condition Expression, iftrue Expression, iffalse Expression) Expression

#fn binary

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

#fn binarygetleft

c:BinaryenBinaryGetLeft
fn binarygetleft(expr Expression) Expression

#fn binarygetop

c:BinaryenBinaryGetOp
fn binarygetop(expr Expression) Op

#fn binarygetright

c:BinaryenBinaryGetRight
fn binarygetright(expr Expression) Expression

#fn binarysetleft

c:BinaryenBinarySetLeft
fn binarysetleft(expr Expression, leftexpr Expression)

#fn binarysetop

c:BinaryenBinarySetOp
fn binarysetop(expr Expression, op Op)

#fn binarysetright

c:BinaryenBinarySetRight
fn binarysetright(expr Expression, rightexpr Expression)

#fn bitmaskveci16x8

c:BinaryenBitmaskVecI16x8
fn bitmaskveci16x8() Op

#fn bitmaskveci32x4

c:BinaryenBitmaskVecI32x4
fn bitmaskveci32x4() Op

#fn bitmaskveci64x2

c:BinaryenBitmaskVecI64x2
fn bitmaskveci64x2() Op

#fn bitmaskveci8x16

c:BinaryenBitmaskVecI8x16
fn bitmaskveci8x16() Op

#fn bitselectvec128

c:BinaryenBitselectVec128
fn bitselectvec128() Op

#fn block

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

#fn blockappendchild

c:BinaryenBlockAppendChild
fn blockappendchild(expr Expression, childexpr Expression) Index

#fn blockgetchildat

c:BinaryenBlockGetChildAt
fn blockgetchildat(expr Expression, index Index) Expression

#fn blockgetname

c:BinaryenBlockGetName
fn blockgetname(expr Expression) &i8

#fn blockgetnumchildren

c:BinaryenBlockGetNumChildren
fn blockgetnumchildren(expr Expression) Index

#fn blockinsertchildat

c:BinaryenBlockInsertChildAt
fn blockinsertchildat(expr Expression, index Index, childexpr Expression)

#fn blockremovechildat

c:BinaryenBlockRemoveChildAt
fn blockremovechildat(expr Expression, index Index) Expression

#fn blocksetchildat

c:BinaryenBlockSetChildAt
fn blocksetchildat(expr Expression, index Index, childexpr Expression)

#fn blocksetname

c:BinaryenBlockSetName
fn blocksetname(expr Expression, name &i8)

#fn br

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

#fn breakgetcondition

c:BinaryenBreakGetCondition
fn breakgetcondition(expr Expression) Expression

#fn breakgetname

c:BinaryenBreakGetName
fn breakgetname(expr Expression) &i8

#fn breakgetvalue

c:BinaryenBreakGetValue
fn breakgetvalue(expr Expression) Expression

#fn breaksetcondition

c:BinaryenBreakSetCondition
fn breaksetcondition(expr Expression, condexpr Expression)

#fn breaksetname

c:BinaryenBreakSetName
fn breaksetname(expr Expression, name &i8)

#fn breaksetvalue

c:BinaryenBreakSetValue
fn breaksetvalue(expr Expression, valueexpr Expression)

#fn bron

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

#fn broncast

c:BinaryenBrOnCast
fn broncast() Op

#fn broncastfail

c:BinaryenBrOnCastFail
fn broncastfail() Op

#fn brondata

c:BinaryenBrOnData
fn brondata() Op

#fn bronfunc

c:BinaryenBrOnFunc
fn bronfunc() Op

#fn brongetintendedtype

c:BinaryenBrOnGetIntendedType
fn brongetintendedtype(expr Expression) HeapType

#fn brongetname

c:BinaryenBrOnGetName
fn brongetname(expr Expression) &i8

#fn brongetop

c:BinaryenBrOnGetOp
fn brongetop(expr Expression) Op

#fn brongetref

c:BinaryenBrOnGetRef
fn brongetref(expr Expression) Expression

#fn broni31

c:BinaryenBrOnI31
fn broni31() Op

#fn bronnondata

c:BinaryenBrOnNonData
fn bronnondata() Op

#fn bronnonfunc

c:BinaryenBrOnNonFunc
fn bronnonfunc() Op

#fn bronnoni31

c:BinaryenBrOnNonI31
fn bronnoni31() Op

#fn bronnonnull

c:BinaryenBrOnNonNull
fn bronnonnull() Op

#fn bronnull

c:BinaryenBrOnNull
fn bronnull() Op

#fn bronsetintendedtype

c:BinaryenBrOnSetIntendedType
fn bronsetintendedtype(expr Expression, intendedtype HeapType)

#fn bronsetname

c:BinaryenBrOnSetName
fn bronsetname(expr Expression, namestr &i8)

#fn bronsetop

c:BinaryenBrOnSetOp
fn bronsetop(expr Expression, op Op)

#fn bronsetref

c:BinaryenBrOnSetRef
fn bronsetref(expr Expression, refexpr Expression)

#fn bselect

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

#fn call

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

#fn callappendoperand

c:BinaryenCallAppendOperand
fn callappendoperand(expr Expression, operandexpr Expression) Index

#fn callgetnumoperands

c:BinaryenCallGetNumOperands
fn callgetnumoperands(expr Expression) Index

#fn callgetoperandat

c:BinaryenCallGetOperandAt
fn callgetoperandat(expr Expression, index Index) Expression

#fn callgettarget

c:BinaryenCallGetTarget
fn callgettarget(expr Expression) &i8

#fn callindirect

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

#fn callindirectappendoperand

c:BinaryenCallIndirectAppendOperand
fn callindirectappendoperand(expr Expression, operandexpr Expression) Index

#fn callindirectgetnumoperands

c:BinaryenCallIndirectGetNumOperands
fn callindirectgetnumoperands(expr Expression) Index

#fn callindirectgetoperandat

c:BinaryenCallIndirectGetOperandAt
fn callindirectgetoperandat(expr Expression, index Index) Expression

#fn callindirectgetparams

c:BinaryenCallIndirectGetParams
fn callindirectgetparams(expr Expression) Type

#fn callindirectgetresults

c:BinaryenCallIndirectGetResults
fn callindirectgetresults(expr Expression) Type

#fn callindirectgettable

c:BinaryenCallIndirectGetTable
fn callindirectgettable(expr Expression) &i8

#fn callindirectgettarget

c:BinaryenCallIndirectGetTarget
fn callindirectgettarget(expr Expression) Expression

#fn callindirectinsertoperandat

c:BinaryenCallIndirectInsertOperandAt
fn callindirectinsertoperandat(expr Expression, index Index, operandexpr Expression)

#fn callindirectisreturn

c:BinaryenCallIndirectIsReturn
fn callindirectisreturn(expr Expression) bool

#fn callindirectremoveoperandat

c:BinaryenCallIndirectRemoveOperandAt
fn callindirectremoveoperandat(expr Expression, index Index) Expression

#fn callindirectsetoperandat

c:BinaryenCallIndirectSetOperandAt
fn callindirectsetoperandat(expr Expression, index Index, operandexpr Expression)

#fn callindirectsetparams

c:BinaryenCallIndirectSetParams
fn callindirectsetparams(expr Expression, params Type)

#fn callindirectsetresults

c:BinaryenCallIndirectSetResults
fn callindirectsetresults(expr Expression, params Type)

#fn callindirectsetreturn

c:BinaryenCallIndirectSetReturn
fn callindirectsetreturn(expr Expression, isreturn bool)

#fn callindirectsettable

c:BinaryenCallIndirectSetTable
fn callindirectsettable(expr Expression, table &i8)

#fn callindirectsettarget

c:BinaryenCallIndirectSetTarget
fn callindirectsettarget(expr Expression, targetexpr Expression)

#fn callinsertoperandat

c:BinaryenCallInsertOperandAt
fn callinsertoperandat(expr Expression, index Index, operandexpr Expression)

#fn callisreturn

c:BinaryenCallIsReturn
fn callisreturn(expr Expression) bool

#fn callref

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

#fn callrefappendoperand

c:BinaryenCallRefAppendOperand
fn callrefappendoperand(expr Expression, operandexpr Expression) Index

#fn callrefgetnumoperands

c:BinaryenCallRefGetNumOperands
fn callrefgetnumoperands(expr Expression) Index

#fn callrefgetoperandat

c:BinaryenCallRefGetOperandAt
fn callrefgetoperandat(expr Expression, index Index) Expression

#fn callrefgettarget

c:BinaryenCallRefGetTarget
fn callrefgettarget(expr Expression) Expression

#fn callrefinsertoperandat

c:BinaryenCallRefInsertOperandAt
fn callrefinsertoperandat(expr Expression, index Index, operandexpr Expression)

#fn callrefisreturn

c:BinaryenCallRefIsReturn
fn callrefisreturn(expr Expression) bool

#fn callrefremoveoperandat

c:BinaryenCallRefRemoveOperandAt
fn callrefremoveoperandat(expr Expression, index Index) Expression

#fn callrefsetoperandat

c:BinaryenCallRefSetOperandAt
fn callrefsetoperandat(expr Expression, index Index, operandexpr Expression)

#fn callrefsetreturn

c:BinaryenCallRefSetReturn
fn callrefsetreturn(expr Expression, isreturn bool)

#fn callrefsettarget

c:BinaryenCallRefSetTarget
fn callrefsettarget(expr Expression, targetexpr Expression)

#fn callremoveoperandat

c:BinaryenCallRemoveOperandAt
fn callremoveoperandat(expr Expression, index Index) Expression

#fn callsetoperandat

c:BinaryenCallSetOperandAt
fn callsetoperandat(expr Expression, index Index, operandexpr Expression)

#fn callsetreturn

c:BinaryenCallSetReturn
fn callsetreturn(expr Expression, isreturn bool)

#fn callsettarget

c:BinaryenCallSetTarget
fn callsettarget(expr Expression, target &i8)

#fn ceilfloat32

c:BinaryenCeilFloat32
fn ceilfloat32() Op

#fn ceilfloat64

c:BinaryenCeilFloat64
fn ceilfloat64() Op

#fn ceilvecf32x4

c:BinaryenCeilVecF32x4
fn ceilvecf32x4() Op

#fn ceilvecf64x2

c:BinaryenCeilVecF64x2
fn ceilvecf64x2() Op

#fn clearpassarguments

c:BinaryenClearPassArguments
fn clearpassarguments()

#fn clzint32

c:BinaryenClzInt32
fn clzint32() Op

#fn clzint64

c:BinaryenClzInt64
fn clzint64() Op

#fn constant

c:BinaryenConst
fn constant(module_ Module, value Literal) Expression

#fn constgetvaluef32

c:BinaryenConstGetValueF32
fn constgetvaluef32(expr Expression) f32

#fn constgetvaluef64

c:BinaryenConstGetValueF64
fn constgetvaluef64(expr Expression) f64

#fn constgetvaluei32

c:BinaryenConstGetValueI32
fn constgetvaluei32(expr Expression) int

#fn constgetvaluei64

c:BinaryenConstGetValueI64
fn constgetvaluei64(expr Expression) i64

#fn constgetvaluei64high

c:BinaryenConstGetValueI64High
fn constgetvaluei64high(expr Expression) int

#fn constgetvaluei64low

c:BinaryenConstGetValueI64Low
fn constgetvaluei64low(expr Expression) int

#fn constgetvaluev128

c:BinaryenConstGetValueV128
fn constgetvaluev128(expr Expression, out &u8)

#fn constsetvaluef32

c:BinaryenConstSetValueF32
fn constsetvaluef32(expr Expression, value f32)

#fn constsetvaluef64

c:BinaryenConstSetValueF64
fn constsetvaluef64(expr Expression, value f64)

#fn constsetvaluei32

c:BinaryenConstSetValueI32
fn constsetvaluei32(expr Expression, value int)

#fn constsetvaluei64

c:BinaryenConstSetValueI64
fn constsetvaluei64(expr Expression, value i64)

#fn constsetvaluei64high

c:BinaryenConstSetValueI64High
fn constsetvaluei64high(expr Expression, valuehigh int)

#fn constsetvaluei64low

c:BinaryenConstSetValueI64Low
fn constsetvaluei64low(expr Expression, valuelow int)

#fn constsetvaluev128

c:BinaryenConstSetValueV128
fn constsetvaluev128(expr Expression, value &u8)

#fn convertlowsveci32x4tovecf64x2

c:BinaryenConvertLowSVecI32x4ToVecF64x2
fn convertlowsveci32x4tovecf64x2() Op

#fn convertlowuveci32x4tovecf64x2

c:BinaryenConvertLowUVecI32x4ToVecF64x2
fn convertlowuveci32x4tovecf64x2() Op

#fn convertsint32tofloat32

c:BinaryenConvertSInt32ToFloat32
fn convertsint32tofloat32() Op

#fn convertsint32tofloat64

c:BinaryenConvertSInt32ToFloat64
fn convertsint32tofloat64() Op

#fn convertsint64tofloat32

c:BinaryenConvertSInt64ToFloat32
fn convertsint64tofloat32() Op

#fn convertsint64tofloat64

c:BinaryenConvertSInt64ToFloat64
fn convertsint64tofloat64() Op

#fn convertsveci32x4tovecf32x4

c:BinaryenConvertSVecI32x4ToVecF32x4
fn convertsveci32x4tovecf32x4() Op

#fn convertuint32tofloat32

c:BinaryenConvertUInt32ToFloat32
fn convertuint32tofloat32() Op

#fn convertuint32tofloat64

c:BinaryenConvertUInt32ToFloat64
fn convertuint32tofloat64() Op

#fn convertuint64tofloat32

c:BinaryenConvertUInt64ToFloat32
fn convertuint64tofloat32() Op

#fn convertuint64tofloat64

c:BinaryenConvertUInt64ToFloat64
fn convertuint64tofloat64() Op

#fn convertuveci32x4tovecf32x4

c:BinaryenConvertUVecI32x4ToVecF32x4
fn convertuveci32x4tovecf32x4() Op

#fn copymemorysegmentdata

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

#fn copysignfloat32

c:BinaryenCopySignFloat32
fn copysignfloat32() Op

#fn copysignfloat64

c:BinaryenCopySignFloat64
fn copysignfloat64() Op

#fn ctzint32

c:BinaryenCtzInt32
fn ctzint32() Op

#fn ctzint64

c:BinaryenCtzInt64
fn ctzint64() Op

#fn datadrop

c:BinaryenDataDrop
fn datadrop(module_ Module, segment u32) Expression

#fn datadropgetsegment

c:BinaryenDataDropGetSegment
fn datadropgetsegment(expr Expression) u32

#fn datadropsetsegment

c:BinaryenDataDropSetSegment
fn datadropsetsegment(expr Expression, segmentindex u32)

#fn demotefloat64

c:BinaryenDemoteFloat64
fn demotefloat64() Op

#fn demotezerovecf64x2tovecf32x4

c:BinaryenDemoteZeroVecF64x2ToVecF32x4
fn demotezerovecf64x2tovecf32x4() Op

#fn divfloat32

c:BinaryenDivFloat32
fn divfloat32() Op

#fn divfloat64

c:BinaryenDivFloat64
fn divfloat64() Op

#fn divsint32

c:BinaryenDivSInt32
fn divsint32() Op

#fn divsint64

c:BinaryenDivSInt64
fn divsint64() Op

#fn divuint32

c:BinaryenDivUInt32
fn divuint32() Op

#fn divuint64

c:BinaryenDivUInt64
fn divuint64() Op

#fn divvecf32x4

c:BinaryenDivVecF32x4
fn divvecf32x4() Op

#fn divvecf64x2

c:BinaryenDivVecF64x2
fn divvecf64x2() Op

#fn dotsveci16x8toveci32x4

c:BinaryenDotSVecI16x8ToVecI32x4
fn dotsveci16x8toveci32x4() Op

#fn drop

c:BinaryenDrop
fn drop(module_ Module, value Expression) Expression

#fn dropgetvalue

c:BinaryenDropGetValue
fn dropgetvalue(expr Expression) Expression

#fn dropsetvalue

c:BinaryenDropSetValue
fn dropsetvalue(expr Expression, valueexpr Expression)

#fn elementsegmentgetdata

c:BinaryenElementSegmentGetData
fn elementsegmentgetdata(elem ElementSegment, dataid Index) &i8

#fn elementsegmentgetlength

c:BinaryenElementSegmentGetLength
fn elementsegmentgetlength(elem ElementSegment) Index

#fn elementsegmentgetname

c:BinaryenElementSegmentGetName
fn elementsegmentgetname(elem ElementSegment) &i8

#fn elementsegmentgetoffset

c:BinaryenElementSegmentGetOffset
fn elementsegmentgetoffset(elem ElementSegment) Expression

#fn elementsegmentgettable

c:BinaryenElementSegmentGetTable
fn elementsegmentgettable(elem ElementSegment) &i8

#fn elementsegmentispassive

c:BinaryenElementSegmentIsPassive
fn elementsegmentispassive(elem ElementSegment) bool

#fn elementsegmentsetname

c:BinaryenElementSegmentSetName
fn elementsegmentsetname(elem ElementSegment, name &i8)

#fn elementsegmentsettable

c:BinaryenElementSegmentSetTable
fn elementsegmentsettable(elem ElementSegment, table &i8)

#fn eqfloat32

c:BinaryenEqFloat32
fn eqfloat32() Op

#fn eqfloat64

c:BinaryenEqFloat64
fn eqfloat64() Op

#fn eqint32

c:BinaryenEqInt32
fn eqint32() Op

#fn eqint64

c:BinaryenEqInt64
fn eqint64() Op

#fn eqvecf32x4

c:BinaryenEqVecF32x4
fn eqvecf32x4() Op

#fn eqvecf64x2

c:BinaryenEqVecF64x2
fn eqvecf64x2() Op

#fn eqveci16x8

c:BinaryenEqVecI16x8
fn eqveci16x8() Op

#fn eqveci32x4

c:BinaryenEqVecI32x4
fn eqveci32x4() Op

#fn eqveci64x2

c:BinaryenEqVecI64x2
fn eqveci64x2() Op

#fn eqveci8x16

c:BinaryenEqVecI8x16
fn eqveci8x16() Op

#fn eqzint32

c:BinaryenEqZInt32
fn eqzint32() Op

#fn eqzint64

c:BinaryenEqZInt64
fn eqzint64() Op

#fn exportgetkind

c:BinaryenExportGetKind
fn exportgetkind(export_ Export) ExternalKind

#fn exportgetname

c:BinaryenExportGetName
fn exportgetname(export_ Export) &i8

#fn exportgetvalue

c:BinaryenExportGetValue
fn exportgetvalue(export_ Export) &i8

#fn expressioncopy

c:BinaryenExpressionCopy
fn expressioncopy(expr Expression, module_ Module) Expression

#fn expressionfinalize

c:BinaryenExpressionFinalize
fn expressionfinalize(expr Expression)

#fn expressiongetid

c:BinaryenExpressionGetId
fn expressiongetid(expr Expression) ExpressionId

#fn expressiongetsideeffects

c:BinaryenExpressionGetSideEffects
fn expressiongetsideeffects(expr Expression, module_ Module) SideEffects

#fn expressiongettype

c:BinaryenExpressionGetType
fn expressiongettype(expr Expression) Type

#fn expressionprint

c:BinaryenExpressionPrint
fn expressionprint(expr Expression)

#fn expressionrunnercreate

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

#fn expressionrunnerflagsdefault

c:ExpressionRunnerFlagsDefault
fn expressionrunnerflagsdefault() ExpressionRunnerFlags

#fn expressionrunnerflagspreservesideeffects

c:ExpressionRunnerFlagsPreserveSideeffects
fn expressionrunnerflagspreservesideeffects() ExpressionRunnerFlags

#fn expressionrunnerflagstraversecalls

c:ExpressionRunnerFlagsTraverseCalls
fn expressionrunnerflagstraversecalls() ExpressionRunnerFlags

#fn expressionrunnerrunanddispose

c:ExpressionRunnerRunAndDispose
fn expressionrunnerrunanddispose(runner ExpressionRunner, expr Expression) Expression

#fn expressionrunnersetglobalvalue

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

#fn expressionrunnersetlocalvalue

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

#fn expressionsettype

c:BinaryenExpressionSetType
fn expressionsettype(expr Expression, type_ Type)

#fn extaddpairwisesveci16x8toi32x4

c:BinaryenExtAddPairwiseSVecI16x8ToI32x4
fn extaddpairwisesveci16x8toi32x4() Op

#fn extaddpairwisesveci8x16toi16x8

c:BinaryenExtAddPairwiseSVecI8x16ToI16x8
fn extaddpairwisesveci8x16toi16x8() Op

#fn extaddpairwiseuveci16x8toi32x4

c:BinaryenExtAddPairwiseUVecI16x8ToI32x4
fn extaddpairwiseuveci16x8toi32x4() Op

#fn extaddpairwiseuveci8x16toi16x8

c:BinaryenExtAddPairwiseUVecI8x16ToI16x8
fn extaddpairwiseuveci8x16toi16x8() Op

#fn extendhighsveci16x8toveci32x4

c:BinaryenExtendHighSVecI16x8ToVecI32x4
fn extendhighsveci16x8toveci32x4() Op

#fn extendhighsveci32x4toveci64x2

c:BinaryenExtendHighSVecI32x4ToVecI64x2
fn extendhighsveci32x4toveci64x2() Op

#fn extendhighsveci8x16toveci16x8

c:BinaryenExtendHighSVecI8x16ToVecI16x8
fn extendhighsveci8x16toveci16x8() Op

#fn extendhighuveci16x8toveci32x4

c:BinaryenExtendHighUVecI16x8ToVecI32x4
fn extendhighuveci16x8toveci32x4() Op

#fn extendhighuveci32x4toveci64x2

c:BinaryenExtendHighUVecI32x4ToVecI64x2
fn extendhighuveci32x4toveci64x2() Op

#fn extendhighuveci8x16toveci16x8

c:BinaryenExtendHighUVecI8x16ToVecI16x8
fn extendhighuveci8x16toveci16x8() Op

#fn extendlowsveci16x8toveci32x4

c:BinaryenExtendLowSVecI16x8ToVecI32x4
fn extendlowsveci16x8toveci32x4() Op

#fn extendlowsveci32x4toveci64x2

c:BinaryenExtendLowSVecI32x4ToVecI64x2
fn extendlowsveci32x4toveci64x2() Op

#fn extendlowsveci8x16toveci16x8

c:BinaryenExtendLowSVecI8x16ToVecI16x8
fn extendlowsveci8x16toveci16x8() Op

#fn extendlowuveci16x8toveci32x4

c:BinaryenExtendLowUVecI16x8ToVecI32x4
fn extendlowuveci16x8toveci32x4() Op

#fn extendlowuveci32x4toveci64x2

c:BinaryenExtendLowUVecI32x4ToVecI64x2
fn extendlowuveci32x4toveci64x2() Op

#fn extendlowuveci8x16toveci16x8

c:BinaryenExtendLowUVecI8x16ToVecI16x8
fn extendlowuveci8x16toveci16x8() Op

#fn extends16int32

c:BinaryenExtendS16Int32
fn extends16int32() Op

#fn extends16int64

c:BinaryenExtendS16Int64
fn extends16int64() Op

#fn extends32int64

c:BinaryenExtendS32Int64
fn extends32int64() Op

#fn extends8int32

c:BinaryenExtendS8Int32
fn extends8int32() Op

#fn extends8int64

c:BinaryenExtendS8Int64
fn extends8int64() Op

#fn extendsint32

c:BinaryenExtendSInt32
fn extendsint32() Op

#fn extenduint32

c:BinaryenExtendUInt32
fn extenduint32() Op

#fn externalfunction

c:BinaryenExternalFunction
fn externalfunction() ExternalKind

#fn externalglobal

c:BinaryenExternalGlobal
fn externalglobal() ExternalKind

#fn externalmemory

c:BinaryenExternalMemory
fn externalmemory() ExternalKind

#fn externaltable

c:BinaryenExternalTable
fn externaltable() ExternalKind

#fn externaltag

c:BinaryenExternalTag
fn externaltag() ExternalKind

#fn extmulhighsveci16x8

c:BinaryenExtMulHighSVecI16x8
fn extmulhighsveci16x8() Op

#fn extmulhighsveci32x4

c:BinaryenExtMulHighSVecI32x4
fn extmulhighsveci32x4() Op

#fn extmulhighsveci64x2

c:BinaryenExtMulHighSVecI64x2
fn extmulhighsveci64x2() Op

#fn extmulhighuveci16x8

c:BinaryenExtMulHighUVecI16x8
fn extmulhighuveci16x8() Op

#fn extmulhighuveci32x4

c:BinaryenExtMulHighUVecI32x4
fn extmulhighuveci32x4() Op

#fn extmulhighuveci64x2

c:BinaryenExtMulHighUVecI64x2
fn extmulhighuveci64x2() Op

#fn extmullowsveci16x8

c:BinaryenExtMulLowSVecI16x8
fn extmullowsveci16x8() Op

#fn extmullowsveci32x4

c:BinaryenExtMulLowSVecI32x4
fn extmullowsveci32x4() Op

#fn extmullowsveci64x2

c:BinaryenExtMulLowSVecI64x2
fn extmullowsveci64x2() Op

#fn extmullowuveci16x8

c:BinaryenExtMulLowUVecI16x8
fn extmullowuveci16x8() Op

#fn extmullowuveci32x4

c:BinaryenExtMulLowUVecI32x4
fn extmullowuveci32x4() Op

#fn extmullowuveci64x2

c:BinaryenExtMulLowUVecI64x2
fn extmullowuveci64x2() Op

#fn extractlanesveci16x8

c:BinaryenExtractLaneSVecI16x8
fn extractlanesveci16x8() Op

#fn extractlanesveci8x16

c:BinaryenExtractLaneSVecI8x16
fn extractlanesveci8x16() Op

#fn extractlaneuveci16x8

c:BinaryenExtractLaneUVecI16x8
fn extractlaneuveci16x8() Op

#fn extractlaneuveci8x16

c:BinaryenExtractLaneUVecI8x16
fn extractlaneuveci8x16() Op

#fn extractlanevecf32x4

c:BinaryenExtractLaneVecF32x4
fn extractlanevecf32x4() Op

#fn extractlanevecf64x2

c:BinaryenExtractLaneVecF64x2
fn extractlanevecf64x2() Op

#fn extractlaneveci32x4

c:BinaryenExtractLaneVecI32x4
fn extractlaneveci32x4() Op

#fn extractlaneveci64x2

c:BinaryenExtractLaneVecI64x2
fn extractlaneveci64x2() Op

#fn featureall

c:BinaryenFeatureAll
fn featureall() Features

#fn featureatomics

c:BinaryenFeatureAtomics
fn featureatomics() Features

#fn featurebulkmemory

c:BinaryenFeatureBulkMemory
fn featurebulkmemory() Features

#fn featureexceptionhandling

c:BinaryenFeatureExceptionHandling
fn featureexceptionhandling() Features

#fn featureextendedconst

c:BinaryenFeatureExtendedConst
fn featureextendedconst() Features

#fn featuregc

c:BinaryenFeatureGC
fn featuregc() Features

#fn featurememory64

c:BinaryenFeatureMemory64
fn featurememory64() Features

#fn featuremultimemories

c:BinaryenFeatureMultiMemories
fn featuremultimemories() Features

#fn featuremultivalue

c:BinaryenFeatureMultivalue
fn featuremultivalue() Features

#fn featuremutableglobals

c:BinaryenFeatureMutableGlobals
fn featuremutableglobals() Features

#fn featuremvp

c:BinaryenFeatureMVP
fn featuremvp() Features

#fn featurenontrappingfptoint

c:BinaryenFeatureNontrappingFPToInt
fn featurenontrappingfptoint() Features

#fn featurereferencetypes

c:BinaryenFeatureReferenceTypes
fn featurereferencetypes() Features

#fn featurerelaxedsimd

c:BinaryenFeatureRelaxedSIMD
fn featurerelaxedsimd() Features

#fn featuresignext

c:BinaryenFeatureSignExt
fn featuresignext() Features

#fn featuresimd128

c:BinaryenFeatureSIMD128
fn featuresimd128() Features

#fn featurestrings

c:BinaryenFeatureStrings
fn featurestrings() Features

#fn featuretailcall

c:BinaryenFeatureTailCall
fn featuretailcall() Features

#fn floorfloat32

c:BinaryenFloorFloat32
fn floorfloat32() Op

#fn floorfloat64

c:BinaryenFloorFloat64
fn floorfloat64() Op

#fn floorvecf32x4

c:BinaryenFloorVecF32x4
fn floorvecf32x4() Op

#fn floorvecf64x2

c:BinaryenFloorVecF64x2
fn floorvecf64x2() Op

#fn functiongetbody

c:BinaryenFunctionGetBody
fn functiongetbody(func Function) Expression

#fn functiongetlocalname

c:BinaryenFunctionGetLocalName
fn functiongetlocalname(func Function, index Index) &i8

#fn functiongetname

c:BinaryenFunctionGetName
fn functiongetname(func Function) &i8

#fn functiongetnumlocals

c:BinaryenFunctionGetNumLocals
fn functiongetnumlocals(func Function) Index

#fn functiongetnumvars

c:BinaryenFunctionGetNumVars
fn functiongetnumvars(func Function) Index

#fn functiongetparams

c:BinaryenFunctionGetParams
fn functiongetparams(func Function) Type

#fn functiongetresults

c:BinaryenFunctionGetResults
fn functiongetresults(func Function) Type

#fn functiongetvar

c:BinaryenFunctionGetVar
fn functiongetvar(func Function, index Index) Type

#fn functionhaslocalname

c:BinaryenFunctionHasLocalName
fn functionhaslocalname(func Function, index Index) bool

#fn functionimportgetbase

c:BinaryenFunctionImportGetBase
fn functionimportgetbase(import_ Function) &i8

#fn functionimportgetmodule

c:BinaryenFunctionImportGetModule
fn functionimportgetmodule(import_ Function) &i8

#fn functionoptimize

c:BinaryenFunctionOptimize
fn functionoptimize(func Function, module_ Module)

#fn functionrunpasses

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

#fn functionsetbody

c:BinaryenFunctionSetBody
fn functionsetbody(func Function, body Expression)

#fn functionsetdebuglocation

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

#fn functionsetlocalname

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

#fn gefloat32

c:BinaryenGeFloat32
fn gefloat32() Op

#fn gefloat64

c:BinaryenGeFloat64
fn gefloat64() Op

#fn gesint32

c:BinaryenGeSInt32
fn gesint32() Op

#fn gesint64

c:BinaryenGeSInt64
fn gesint64() Op

#fn gesveci16x8

c:BinaryenGeSVecI16x8
fn gesveci16x8() Op

#fn gesveci32x4

c:BinaryenGeSVecI32x4
fn gesveci32x4() Op

#fn gesveci64x2

c:BinaryenGeSVecI64x2
fn gesveci64x2() Op

#fn gesveci8x16

c:BinaryenGeSVecI8x16
fn gesveci8x16() Op

#fn getallowinliningfunctionswithloops

c:BinaryenGetAllowInliningFunctionsWithLoops
fn getallowinliningfunctionswithloops() bool

#fn getalwaysinlinemaxsize

c:BinaryenGetAlwaysInlineMaxSize
fn getalwaysinlinemaxsize() Index

#fn getdebuginfo

c:BinaryenGetDebugInfo
fn getdebuginfo() bool

#fn getelementsegment

c:BinaryenGetElementSegment
fn getelementsegment(module_ Module, name &i8) ElementSegment

#fn getelementsegmentbyindex

c:BinaryenGetElementSegmentByIndex
fn getelementsegmentbyindex(module_ Module, index Index) ElementSegment

#fn getexport

c:BinaryenGetExport
fn getexport(module_ Module, externalname &i8) Export

#fn getexportbyindex

c:BinaryenGetExportByIndex
fn getexportbyindex(module_ Module, index Index) Export

#fn getfastmath

c:BinaryenGetFastMath
fn getfastmath() bool

#fn getflexibleinlinemaxsize

c:BinaryenGetFlexibleInlineMaxSize
fn getflexibleinlinemaxsize() Index

#fn getfunction

c:BinaryenGetFunction
fn getfunction(module_ Module, name &i8) Function

#fn getfunctionbyindex

c:BinaryenGetFunctionByIndex
fn getfunctionbyindex(module_ Module, index Index) Function

#fn getglobal

c:BinaryenGetGlobal
fn getglobal(module_ Module, name &i8) Global

#fn getglobalbyindex

c:BinaryenGetGlobalByIndex
fn getglobalbyindex(module_ Module, index Index) Global

#fn getlowmemoryunused

c:BinaryenGetLowMemoryUnused
fn getlowmemoryunused() bool

#fn getmemorysegmentbytelength

c:BinaryenGetMemorySegmentByteLength
fn getmemorysegmentbytelength(module_ Module, id Index) usize

#fn getmemorysegmentbyteoffset

c:BinaryenGetMemorySegmentByteOffset
fn getmemorysegmentbyteoffset(module_ Module, id Index) u32

#fn getmemorysegmentpassive

c:BinaryenGetMemorySegmentPassive
fn getmemorysegmentpassive(module_ Module, id Index) bool

#fn getnumelementsegments

c:BinaryenGetNumElementSegments
fn getnumelementsegments(module_ Module) Index

#fn getnumexports

c:BinaryenGetNumExports
fn getnumexports(module_ Module) Index

#fn getnumfunctions

c:BinaryenGetNumFunctions
fn getnumfunctions(module_ Module) Index

#fn getnumglobals

c:BinaryenGetNumGlobals
fn getnumglobals(module_ Module) Index

#fn getnummemorysegments

c:BinaryenGetNumMemorySegments
fn getnummemorysegments(module_ Module) u32

#fn getnumtables

c:BinaryenGetNumTables
fn getnumtables(module_ Module) Index

#fn getonecallerinlinemaxsize

c:BinaryenGetOneCallerInlineMaxSize
fn getonecallerinlinemaxsize() Index

#fn getoptimizelevel

c:BinaryenGetOptimizeLevel
fn getoptimizelevel() int

#fn getpassargument

c:BinaryenGetPassArgument
fn getpassargument(name &i8) &i8

#fn getshrinklevel

c:BinaryenGetShrinkLevel
fn getshrinklevel() int

#fn gettable

c:BinaryenGetTable
fn gettable(module_ Module, name &i8) Table

#fn gettablebyindex

c:BinaryenGetTableByIndex
fn gettablebyindex(module_ Module, index Index) Table

#fn gettag

c:BinaryenGetTag
fn gettag(module_ Module, name &i8) Tag

#fn gettypesystem

c:BinaryenGetTypeSystem
fn gettypesystem() TypeSystem

#fn getzerofilledmemory

c:BinaryenGetZeroFilledMemory
fn getzerofilledmemory() bool

#fn geuint32

c:BinaryenGeUInt32
fn geuint32() Op

#fn geuint64

c:BinaryenGeUInt64
fn geuint64() Op

#fn geuveci16x8

c:BinaryenGeUVecI16x8
fn geuveci16x8() Op

#fn geuveci32x4

c:BinaryenGeUVecI32x4
fn geuveci32x4() Op

#fn geuveci8x16

c:BinaryenGeUVecI8x16
fn geuveci8x16() Op

#fn gevecf32x4

c:BinaryenGeVecF32x4
fn gevecf32x4() Op

#fn gevecf64x2

c:BinaryenGeVecF64x2
fn gevecf64x2() Op

#fn globalget

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

#fn globalgetgetname

c:BinaryenGlobalGetGetName
fn globalgetgetname(expr Expression) &i8

#fn globalgetinitexpr

c:BinaryenGlobalGetInitExpr
fn globalgetinitexpr(global Global) Expression

#fn globalgetname

c:BinaryenGlobalGetName
fn globalgetname(global Global) &i8

#fn globalgetsetname

c:BinaryenGlobalGetSetName
fn globalgetsetname(expr Expression, name &i8)

#fn globalgettype

c:BinaryenGlobalGetType
fn globalgettype(global Global) Type

#fn globalimportgetbase

c:BinaryenGlobalImportGetBase
fn globalimportgetbase(import_ Global) &i8

#fn globalimportgetmodule

c:BinaryenGlobalImportGetModule
fn globalimportgetmodule(import_ Global) &i8

#fn globalismutable

c:BinaryenGlobalIsMutable
fn globalismutable(global Global) bool

#fn globalset

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

#fn globalsetgetname

c:BinaryenGlobalSetGetName
fn globalsetgetname(expr Expression) &i8

#fn globalsetgetvalue

c:BinaryenGlobalSetGetValue
fn globalsetgetvalue(expr Expression) Expression

#fn globalsetsetname

c:BinaryenGlobalSetSetName
fn globalsetsetname(expr Expression, name &i8)

#fn globalsetsetvalue

c:BinaryenGlobalSetSetValue
fn globalsetsetvalue(expr Expression, valueexpr Expression)

#fn gtfloat32

c:BinaryenGtFloat32
fn gtfloat32() Op

#fn gtfloat64

c:BinaryenGtFloat64
fn gtfloat64() Op

#fn gtsint32

c:BinaryenGtSInt32
fn gtsint32() Op

#fn gtsint64

c:BinaryenGtSInt64
fn gtsint64() Op

#fn gtsveci16x8

c:BinaryenGtSVecI16x8
fn gtsveci16x8() Op

#fn gtsveci32x4

c:BinaryenGtSVecI32x4
fn gtsveci32x4() Op

#fn gtsveci64x2

c:BinaryenGtSVecI64x2
fn gtsveci64x2() Op

#fn gtsveci8x16

c:BinaryenGtSVecI8x16
fn gtsveci8x16() Op

#fn gtuint32

c:BinaryenGtUInt32
fn gtuint32() Op

#fn gtuint64

c:BinaryenGtUInt64
fn gtuint64() Op

#fn gtuveci16x8

c:BinaryenGtUVecI16x8
fn gtuveci16x8() Op

#fn gtuveci32x4

c:BinaryenGtUVecI32x4
fn gtuveci32x4() Op

#fn gtuveci8x16

c:BinaryenGtUVecI8x16
fn gtuveci8x16() Op

#fn gtvecf32x4

c:BinaryenGtVecF32x4
fn gtvecf32x4() Op

#fn gtvecf64x2

c:BinaryenGtVecF64x2
fn gtvecf64x2() Op

#fn hasmemory

c:BinaryenHasMemory
fn hasmemory(module_ Module) bool

#fn heaptypeany

c:BinaryenHeapTypeAny
fn heaptypeany() HeapType

#fn heaptypearray

c:BinaryenHeapTypeArray
fn heaptypearray() HeapType

#fn heaptypedata

c:BinaryenHeapTypeData
fn heaptypedata() HeapType

#fn heaptypeeq

c:BinaryenHeapTypeEq
fn heaptypeeq() HeapType

#fn heaptypeext

c:BinaryenHeapTypeExt
fn heaptypeext() HeapType

#fn heaptypefunc

c:BinaryenHeapTypeFunc
fn heaptypefunc() HeapType

#fn heaptypegetbottom

c:BinaryenHeapTypeGetBottom
fn heaptypegetbottom(heaptype HeapType) HeapType

#fn heaptypei31

c:BinaryenHeapTypeI31
fn heaptypei31() HeapType

#fn heaptypeisarray

c:BinaryenHeapTypeIsArray
fn heaptypeisarray(heaptype HeapType) bool

#fn heaptypeisbasic

c:BinaryenHeapTypeIsBasic
fn heaptypeisbasic(heaptype HeapType) bool

#fn heaptypeisbottom

c:BinaryenHeapTypeIsBottom
fn heaptypeisbottom(heaptype HeapType) bool

#fn heaptypeissignature

c:BinaryenHeapTypeIsSignature
fn heaptypeissignature(heaptype HeapType) bool

#fn heaptypeisstruct

c:BinaryenHeapTypeIsStruct
fn heaptypeisstruct(heaptype HeapType) bool

#fn heaptypeissubtype

c:BinaryenHeapTypeIsSubType
fn heaptypeissubtype(left HeapType, right HeapType) bool

#fn heaptypenoext

c:BinaryenHeapTypeNoext
fn heaptypenoext() HeapType

#fn heaptypenofunc

c:BinaryenHeapTypeNofunc
fn heaptypenofunc() HeapType

#fn heaptypenone

c:BinaryenHeapTypeNone
fn heaptypenone() HeapType

#fn heaptypestring

c:BinaryenHeapTypeString
fn heaptypestring() HeapType

#fn heaptypestringviewiter

c:BinaryenHeapTypeStringviewIter
fn heaptypestringviewiter() HeapType

#fn heaptypestringviewwtf16

c:BinaryenHeapTypeStringviewWTF16
fn heaptypestringviewwtf16() HeapType

#fn heaptypestringviewwtf8

c:BinaryenHeapTypeStringviewWTF8
fn heaptypestringviewwtf8() HeapType

#fn i31get

c:BinaryenI31Get
fn i31get(module_ Module, i31 Expression, signed_ bool) Expression

#fn i31getgeti31

c:BinaryenI31GetGetI31
fn i31getgeti31(expr Expression) Expression

#fn i31getissigned

c:BinaryenI31GetIsSigned
fn i31getissigned(expr Expression) bool

#fn i31getseti31

c:BinaryenI31GetSetI31
fn i31getseti31(expr Expression, i31expr Expression)

#fn i31getsetsigned

c:BinaryenI31GetSetSigned
fn i31getsetsigned(expr Expression, signed_ bool)

#fn i31new

c:BinaryenI31New
fn i31new(module_ Module, value Expression) Expression

#fn i31newgetvalue

c:BinaryenI31NewGetValue
fn i31newgetvalue(expr Expression) Expression

#fn i31newsetvalue

c:BinaryenI31NewSetValue
fn i31newsetvalue(expr Expression, valueexpr Expression)

#fn ifgetcondition

c:BinaryenIfGetCondition
fn ifgetcondition(expr Expression) Expression

#fn ifgetiffalse

c:BinaryenIfGetIfFalse
fn ifgetiffalse(expr Expression) Expression

#fn ifgetiftrue

c:BinaryenIfGetIfTrue
fn ifgetiftrue(expr Expression) Expression

#fn ifsetcondition

c:BinaryenIfSetCondition
fn ifsetcondition(expr Expression, condexpr Expression)

#fn ifsetiffalse

c:BinaryenIfSetIfFalse
fn ifsetiffalse(expr Expression, iffalseexpr Expression)

#fn ifsetiftrue

c:BinaryenIfSetIfTrue
fn ifsetiftrue(expr Expression, iftrueexpr Expression)

#fn invalidid

c:BinaryenInvalidId
fn invalidid() ExpressionId

#fn lefloat32

c:BinaryenLeFloat32
fn lefloat32() Op

#fn lefloat64

c:BinaryenLeFloat64
fn lefloat64() Op

#fn lesint32

c:BinaryenLeSInt32
fn lesint32() Op

#fn lesint64

c:BinaryenLeSInt64
fn lesint64() Op

#fn lesveci16x8

c:BinaryenLeSVecI16x8
fn lesveci16x8() Op

#fn lesveci32x4

c:BinaryenLeSVecI32x4
fn lesveci32x4() Op

#fn lesveci64x2

c:BinaryenLeSVecI64x2
fn lesveci64x2() Op

#fn lesveci8x16

c:BinaryenLeSVecI8x16
fn lesveci8x16() Op

#fn leuint32

c:BinaryenLeUInt32
fn leuint32() Op

#fn leuint64

c:BinaryenLeUInt64
fn leuint64() Op

#fn leuveci16x8

c:BinaryenLeUVecI16x8
fn leuveci16x8() Op

#fn leuveci32x4

c:BinaryenLeUVecI32x4
fn leuveci32x4() Op

#fn leuveci8x16

c:BinaryenLeUVecI8x16
fn leuveci8x16() Op

#fn levecf32x4

c:BinaryenLeVecF32x4
fn levecf32x4() Op

#fn levecf64x2

c:BinaryenLeVecF64x2
fn levecf64x2() Op

#fn literalfloat32

c:BinaryenLiteralFloat32
fn literalfloat32(x f32) Literal

#fn literalfloat32bits

c:BinaryenLiteralFloat32Bits
fn literalfloat32bits(x int) Literal

#fn literalfloat64

c:BinaryenLiteralFloat64
fn literalfloat64(x f64) Literal

#fn literalfloat64bits

c:BinaryenLiteralFloat64Bits
fn literalfloat64bits(x i64) Literal

#fn literalint32

c:BinaryenLiteralInt32
fn literalint32(x int) Literal

#fn literalint64

c:BinaryenLiteralInt64
fn literalint64(x i64) Literal

#fn literalvec128

c:BinaryenLiteralVec128
fn literalvec128(x &u8) Literal

#fn load

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

#fn load16lanevec128

c:BinaryenLoad16LaneVec128
fn load16lanevec128() Op

#fn load16splatvec128

c:BinaryenLoad16SplatVec128
fn load16splatvec128() Op

#fn load16x4svec128

c:BinaryenLoad16x4SVec128
fn load16x4svec128() Op

#fn load16x4uvec128

c:BinaryenLoad16x4UVec128
fn load16x4uvec128() Op

#fn load32lanevec128

c:BinaryenLoad32LaneVec128
fn load32lanevec128() Op

#fn load32splatvec128

c:BinaryenLoad32SplatVec128
fn load32splatvec128() Op

#fn load32x2svec128

c:BinaryenLoad32x2SVec128
fn load32x2svec128() Op

#fn load32x2uvec128

c:BinaryenLoad32x2UVec128
fn load32x2uvec128() Op

#fn load32zerovec128

c:BinaryenLoad32ZeroVec128
fn load32zerovec128() Op

#fn load64lanevec128

c:BinaryenLoad64LaneVec128
fn load64lanevec128() Op

#fn load64splatvec128

c:BinaryenLoad64SplatVec128
fn load64splatvec128() Op

#fn load64zerovec128

c:BinaryenLoad64ZeroVec128
fn load64zerovec128() Op

#fn load8lanevec128

c:BinaryenLoad8LaneVec128
fn load8lanevec128() Op

#fn load8splatvec128

c:BinaryenLoad8SplatVec128
fn load8splatvec128() Op

#fn load8x8svec128

c:BinaryenLoad8x8SVec128
fn load8x8svec128() Op

#fn load8x8uvec128

c:BinaryenLoad8x8UVec128
fn load8x8uvec128() Op

#fn loadgetalign

c:BinaryenLoadGetAlign
fn loadgetalign(expr Expression) u32

#fn loadgetbytes

c:BinaryenLoadGetBytes
fn loadgetbytes(expr Expression) u32

#fn loadgetoffset

c:BinaryenLoadGetOffset
fn loadgetoffset(expr Expression) u32

#fn loadgetptr

c:BinaryenLoadGetPtr
fn loadgetptr(expr Expression) Expression

#fn loadisatomic

c:BinaryenLoadIsAtomic
fn loadisatomic(expr Expression) bool

#fn loadissigned

c:BinaryenLoadIsSigned
fn loadissigned(expr Expression) bool

#fn loadsetalign

c:BinaryenLoadSetAlign
fn loadsetalign(expr Expression, align u32)

#fn loadsetatomic

c:BinaryenLoadSetAtomic
fn loadsetatomic(expr Expression, isatomic bool)

#fn loadsetbytes

c:BinaryenLoadSetBytes
fn loadsetbytes(expr Expression, bytes u32)

#fn loadsetoffset

c:BinaryenLoadSetOffset
fn loadsetoffset(expr Expression, offset u32)

#fn loadsetptr

c:BinaryenLoadSetPtr
fn loadsetptr(expr Expression, ptrexpr Expression)

#fn loadsetsigned

c:BinaryenLoadSetSigned
fn loadsetsigned(expr Expression, issigned bool)

#fn localget

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

#fn localgetgetindex

c:BinaryenLocalGetGetIndex
fn localgetgetindex(expr Expression) Index

#fn localgetsetindex

c:BinaryenLocalGetSetIndex
fn localgetsetindex(expr Expression, index Index)

#fn localset

c:BinaryenLocalSet
fn localset(module_ Module, index Index, value Expression) Expression

#fn localsetgetindex

c:BinaryenLocalSetGetIndex
fn localsetgetindex(expr Expression) Index

#fn localsetgetvalue

c:BinaryenLocalSetGetValue
fn localsetgetvalue(expr Expression) Expression

#fn localsetistee

c:BinaryenLocalSetIsTee
fn localsetistee(expr Expression) bool

#fn localsetsetindex

c:BinaryenLocalSetSetIndex
fn localsetsetindex(expr Expression, index Index)

#fn localsetsetvalue

c:BinaryenLocalSetSetValue
fn localsetsetvalue(expr Expression, valueexpr Expression)

#fn localtee

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

#fn loop

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

#fn loopgetbody

c:BinaryenLoopGetBody
fn loopgetbody(expr Expression) Expression

#fn loopgetname

c:BinaryenLoopGetName
fn loopgetname(expr Expression) &i8

#fn loopsetbody

c:BinaryenLoopSetBody
fn loopsetbody(expr Expression, bodyexpr Expression)

#fn loopsetname

c:BinaryenLoopSetName
fn loopsetname(expr Expression, name &i8)

#fn ltfloat32

c:BinaryenLtFloat32
fn ltfloat32() Op

#fn ltfloat64

c:BinaryenLtFloat64
fn ltfloat64() Op

#fn ltsint32

c:BinaryenLtSInt32
fn ltsint32() Op

#fn ltsint64

c:BinaryenLtSInt64
fn ltsint64() Op

#fn ltsveci16x8

c:BinaryenLtSVecI16x8
fn ltsveci16x8() Op

#fn ltsveci32x4

c:BinaryenLtSVecI32x4
fn ltsveci32x4() Op

#fn ltsveci64x2

c:BinaryenLtSVecI64x2
fn ltsveci64x2() Op

#fn ltsveci8x16

c:BinaryenLtSVecI8x16
fn ltsveci8x16() Op

#fn ltuint32

c:BinaryenLtUInt32
fn ltuint32() Op

#fn ltuint64

c:BinaryenLtUInt64
fn ltuint64() Op

#fn ltuveci16x8

c:BinaryenLtUVecI16x8
fn ltuveci16x8() Op

#fn ltuveci32x4

c:BinaryenLtUVecI32x4
fn ltuveci32x4() Op

#fn ltuveci8x16

c:BinaryenLtUVecI8x16
fn ltuveci8x16() Op

#fn ltvecf32x4

c:BinaryenLtVecF32x4
fn ltvecf32x4() Op

#fn ltvecf64x2

c:BinaryenLtVecF64x2
fn ltvecf64x2() Op

#fn maxfloat32

c:BinaryenMaxFloat32
fn maxfloat32() Op

#fn maxfloat64

c:BinaryenMaxFloat64
fn maxfloat64() Op

#fn maxsveci16x8

c:BinaryenMaxSVecI16x8
fn maxsveci16x8() Op

#fn maxsveci32x4

c:BinaryenMaxSVecI32x4
fn maxsveci32x4() Op

#fn maxsveci8x16

c:BinaryenMaxSVecI8x16
fn maxsveci8x16() Op

#fn maxuveci16x8

c:BinaryenMaxUVecI16x8
fn maxuveci16x8() Op

#fn maxuveci32x4

c:BinaryenMaxUVecI32x4
fn maxuveci32x4() Op

#fn maxuveci8x16

c:BinaryenMaxUVecI8x16
fn maxuveci8x16() Op

#fn maxvecf32x4

c:BinaryenMaxVecF32x4
fn maxvecf32x4() Op

#fn maxvecf64x2

c:BinaryenMaxVecF64x2
fn maxvecf64x2() Op

#fn memorycopy

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

#fn memorycopygetdest

c:BinaryenMemoryCopyGetDest
fn memorycopygetdest(expr Expression) Expression

#fn memorycopygetsize

c:BinaryenMemoryCopyGetSize
fn memorycopygetsize(expr Expression) Expression

#fn memorycopygetsource

c:BinaryenMemoryCopyGetSource
fn memorycopygetsource(expr Expression) Expression

#fn memorycopysetdest

c:BinaryenMemoryCopySetDest
fn memorycopysetdest(expr Expression, destexpr Expression)

#fn memorycopysetsize

c:BinaryenMemoryCopySetSize
fn memorycopysetsize(expr Expression, sizeexpr Expression)

#fn memorycopysetsource

c:BinaryenMemoryCopySetSource
fn memorycopysetsource(expr Expression, sourceexpr Expression)

#fn memoryfill

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

#fn memoryfillgetdest

c:BinaryenMemoryFillGetDest
fn memoryfillgetdest(expr Expression) Expression

#fn memoryfillgetsize

c:BinaryenMemoryFillGetSize
fn memoryfillgetsize(expr Expression) Expression

#fn memoryfillgetvalue

c:BinaryenMemoryFillGetValue
fn memoryfillgetvalue(expr Expression) Expression

#fn memoryfillsetdest

c:BinaryenMemoryFillSetDest
fn memoryfillsetdest(expr Expression, destexpr Expression)

#fn memoryfillsetsize

c:BinaryenMemoryFillSetSize
fn memoryfillsetsize(expr Expression, sizeexpr Expression)

#fn memoryfillsetvalue

c:BinaryenMemoryFillSetValue
fn memoryfillsetvalue(expr Expression, valueexpr Expression)

#fn memorygetinitial

c:BinaryenMemoryGetInitial
fn memorygetinitial(module_ Module, name &i8) Index

#fn memorygetmax

c:BinaryenMemoryGetMax
fn memorygetmax(module_ Module, name &i8) Index

#fn memorygrow

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

#fn memorygrowgetdelta

c:BinaryenMemoryGrowGetDelta
fn memorygrowgetdelta(expr Expression) Expression

#fn memorygrowsetdelta

c:BinaryenMemoryGrowSetDelta
fn memorygrowsetdelta(expr Expression, deltaexpr Expression)

#fn memoryhasmax

c:BinaryenMemoryHasMax
fn memoryhasmax(module_ Module, name &i8) bool

#fn memoryimportgetbase

c:BinaryenMemoryImportGetBase
fn memoryimportgetbase(module_ Module, name &i8) &i8

#fn memoryimportgetmodule

c:BinaryenMemoryImportGetModule
fn memoryimportgetmodule(module_ Module, name &i8) &i8

#fn memoryinit

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

#fn memoryinitgetdest

c:BinaryenMemoryInitGetDest
fn memoryinitgetdest(expr Expression) Expression

#fn memoryinitgetoffset

c:BinaryenMemoryInitGetOffset
fn memoryinitgetoffset(expr Expression) Expression

#fn memoryinitgetsegment

c:BinaryenMemoryInitGetSegment
fn memoryinitgetsegment(expr Expression) u32

#fn memoryinitgetsize

c:BinaryenMemoryInitGetSize
fn memoryinitgetsize(expr Expression) Expression

#fn memoryinitsetdest

c:BinaryenMemoryInitSetDest
fn memoryinitsetdest(expr Expression, destexpr Expression)

#fn memoryinitsetoffset

c:BinaryenMemoryInitSetOffset
fn memoryinitsetoffset(expr Expression, offsetexpr Expression)

#fn memoryinitsetsegment

c:BinaryenMemoryInitSetSegment
fn memoryinitsetsegment(expr Expression, segmentindex u32)

#fn memoryinitsetsize

c:BinaryenMemoryInitSetSize
fn memoryinitsetsize(expr Expression, sizeexpr Expression)

#fn memoryis64

c:BinaryenMemoryIs64
fn memoryis64(module_ Module, name &i8) bool

#fn memoryisshared_

c:BinaryenMemoryIsshared_
fn memoryisshared_(module_ Module, name &i8) bool

#fn memorysize

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

#fn minfloat32

c:BinaryenMinFloat32
fn minfloat32() Op

#fn minfloat64

c:BinaryenMinFloat64
fn minfloat64() Op

#fn minsveci16x8

c:BinaryenMinSVecI16x8
fn minsveci16x8() Op

#fn minsveci32x4

c:BinaryenMinSVecI32x4
fn minsveci32x4() Op

#fn minsveci8x16

c:BinaryenMinSVecI8x16
fn minsveci8x16() Op

#fn minuveci16x8

c:BinaryenMinUVecI16x8
fn minuveci16x8() Op

#fn minuveci32x4

c:BinaryenMinUVecI32x4
fn minuveci32x4() Op

#fn minuveci8x16

c:BinaryenMinUVecI8x16
fn minuveci8x16() Op

#fn minvecf32x4

c:BinaryenMinVecF32x4
fn minvecf32x4() Op

#fn minvecf64x2

c:BinaryenMinVecF64x2
fn minvecf64x2() Op

#fn moduleadddebuginfofilename

c:BinaryenModuleAddDebugInfoFileName
fn moduleadddebuginfofilename(module_ Module, filename &i8) Index

#fn moduleallocateandwrite

c:BinaryenModuleAllocateAndWrite
fn moduleallocateandwrite(module_ Module, sourcemapurl &i8) ModuleAllocateAndWriteResult

#fn moduleallocateandwritestackir

c:BinaryenModuleAllocateAndWriteStackIR
fn moduleallocateandwritestackir(module_ Module, optimize bool) &i8

#fn moduleallocateandwritetext

c:BinaryenModuleAllocateAndWriteText
fn moduleallocateandwritetext(module_ Module) &i8

#fn moduleautodrop

c:BinaryenModuleAutoDrop
fn moduleautodrop(module_ Module)

#fn modulecreate

c:BinaryenModuleCreate
fn modulecreate() Module

#fn moduledispose

c:BinaryenModuleDispose
fn moduledispose(module_ Module)

#fn modulegetdebuginfofilename

c:BinaryenModuleGetDebugInfoFileName
fn modulegetdebuginfofilename(module_ Module, index Index) &i8

#fn modulegetfeatures

c:BinaryenModuleGetFeatures
fn modulegetfeatures(module_ Module) Features

#fn moduleinterpret

c:BinaryenModuleInterpret
fn moduleinterpret(module_ Module)

#fn moduleoptimize

c:BinaryenModuleOptimize
fn moduleoptimize(module_ Module)

#fn moduleparse

c:BinaryenModuleParse
fn moduleparse(text &i8) Module

#fn moduleprint

c:BinaryenModulePrint
fn moduleprint(module_ Module)

#fn moduleprintasmjs

c:BinaryenModulePrintAsmjs
fn moduleprintasmjs(module_ Module)

#fn moduleprintstackir

c:BinaryenModulePrintStackIR
fn moduleprintstackir(module_ Module, optimize bool)

#fn moduleread

c:BinaryenModuleRead
fn moduleread(input &i8, inputsize usize) Module

#fn modulerunpasses

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

#fn modulesetfeatures

c:BinaryenModuleSetFeatures
fn modulesetfeatures(module_ Module, features Features)

#fn modulesetfieldname

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

#fn modulesettypename

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

#fn moduleupdatemaps

c:BinaryenModuleUpdateMaps
fn moduleupdatemaps(module_ Module)

#fn modulevalidate

c:BinaryenModuleValidate
fn modulevalidate(module_ Module) bool

#fn modulewrite

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

#fn modulewritestackir

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

#fn modulewritetext

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

#fn modulewritewithsourcemap

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

#fn mulfloat32

c:BinaryenMulFloat32
fn mulfloat32() Op

#fn mulfloat64

c:BinaryenMulFloat64
fn mulfloat64() Op

#fn mulint32

c:BinaryenMulInt32
fn mulint32() Op

#fn mulint64

c:BinaryenMulInt64
fn mulint64() Op

#fn mulvecf32x4

c:BinaryenMulVecF32x4
fn mulvecf32x4() Op

#fn mulvecf64x2

c:BinaryenMulVecF64x2
fn mulvecf64x2() Op

#fn mulveci16x8

c:BinaryenMulVecI16x8
fn mulveci16x8() Op

#fn mulveci32x4

c:BinaryenMulVecI32x4
fn mulveci32x4() Op

#fn mulveci64x2

c:BinaryenMulVecI64x2
fn mulveci64x2() Op

#fn narrowsveci16x8toveci8x16

c:BinaryenNarrowSVecI16x8ToVecI8x16
fn narrowsveci16x8toveci8x16() Op

#fn narrowsveci32x4toveci16x8

c:BinaryenNarrowSVecI32x4ToVecI16x8
fn narrowsveci32x4toveci16x8() Op

#fn narrowuveci16x8toveci8x16

c:BinaryenNarrowUVecI16x8ToVecI8x16
fn narrowuveci16x8toveci8x16() Op

#fn narrowuveci32x4toveci16x8

c:BinaryenNarrowUVecI32x4ToVecI16x8
fn narrowuveci32x4toveci16x8() Op

#fn nearestfloat32

c:BinaryenNearestFloat32
fn nearestfloat32() Op

#fn nearestfloat64

c:BinaryenNearestFloat64
fn nearestfloat64() Op

#fn nearestvecf32x4

c:BinaryenNearestVecF32x4
fn nearestvecf32x4() Op

#fn nearestvecf64x2

c:BinaryenNearestVecF64x2
fn nearestvecf64x2() Op

#fn nefloat32

c:BinaryenNeFloat32
fn nefloat32() Op

#fn nefloat64

c:BinaryenNeFloat64
fn nefloat64() Op

#fn negfloat32

c:BinaryenNegFloat32
fn negfloat32() Op

#fn negfloat64

c:BinaryenNegFloat64
fn negfloat64() Op

#fn negvecf32x4

c:BinaryenNegVecF32x4
fn negvecf32x4() Op

#fn negvecf64x2

c:BinaryenNegVecF64x2
fn negvecf64x2() Op

#fn negveci16x8

c:BinaryenNegVecI16x8
fn negveci16x8() Op

#fn negveci32x4

c:BinaryenNegVecI32x4
fn negveci32x4() Op

#fn negveci64x2

c:BinaryenNegVecI64x2
fn negveci64x2() Op

#fn negveci8x16

c:BinaryenNegVecI8x16
fn negveci8x16() Op

#fn neint32

c:BinaryenNeInt32
fn neint32() Op

#fn neint64

c:BinaryenNeInt64
fn neint64() Op

#fn nevecf32x4

c:BinaryenNeVecF32x4
fn nevecf32x4() Op

#fn nevecf64x2

c:BinaryenNeVecF64x2
fn nevecf64x2() Op

#fn neveci16x8

c:BinaryenNeVecI16x8
fn neveci16x8() Op

#fn neveci32x4

c:BinaryenNeVecI32x4
fn neveci32x4() Op

#fn neveci64x2

c:BinaryenNeVecI64x2
fn neveci64x2() Op

#fn neveci8x16

c:BinaryenNeVecI8x16
fn neveci8x16() Op

#fn nop

c:BinaryenNop
fn nop(module_ Module) Expression

#fn notvec128

c:BinaryenNotVec128
fn notvec128() Op

#fn orint32

c:BinaryenOrInt32
fn orint32() Op

#fn orint64

c:BinaryenOrInt64
fn orint64() Op

#fn orvec128

c:BinaryenOrVec128
fn orvec128() Op

#fn packedtypeint16

c:BinaryenPackedTypeInt16
fn packedtypeint16() PackedType

#fn packedtypeint8

c:BinaryenPackedTypeInt8
fn packedtypeint8() PackedType

#fn packedtypenotpacked

c:BinaryenPackedTypeNotPacked
fn packedtypenotpacked() PackedType

#fn pmaxvecf32x4

c:BinaryenPMaxVecF32x4
fn pmaxvecf32x4() Op

#fn pmaxvecf64x2

c:BinaryenPMaxVecF64x2
fn pmaxvecf64x2() Op

#fn pminvecf32x4

c:BinaryenPMinVecF32x4
fn pminvecf32x4() Op

#fn pminvecf64x2

c:BinaryenPMinVecF64x2
fn pminvecf64x2() Op

#fn pop

c:BinaryenPop
fn pop(module_ Module, type_ Type) Expression

#fn popcntint32

c:BinaryenPopcntInt32
fn popcntint32() Op

#fn popcntint64

c:BinaryenPopcntInt64
fn popcntint64() Op

#fn popcntveci8x16

c:BinaryenPopcntVecI8x16
fn popcntveci8x16() Op

#fn promotefloat32

c:BinaryenPromoteFloat32
fn promotefloat32() Op

#fn promotelowvecf32x4tovecf64x2

c:BinaryenPromoteLowVecF32x4ToVecF64x2
fn promotelowvecf32x4tovecf64x2() Op

#fn q15mulrsatsveci16x8

c:BinaryenQ15MulrSatSVecI16x8
fn q15mulrsatsveci16x8() Op

#fn refas

c:BinaryenRefAs
fn refas(module_ Module, op Op, value Expression) Expression

#fn refasdata

c:BinaryenRefAsData
fn refasdata() Op

#fn refasexternexternalize

c:BinaryenRefAsExternExternalize
fn refasexternexternalize() Op

#fn refasexterninternalize

c:BinaryenRefAsExternInternalize
fn refasexterninternalize() Op

#fn refasfunc

c:BinaryenRefAsFunc
fn refasfunc() Op

#fn refasgetop

c:BinaryenRefAsGetOp
fn refasgetop(expr Expression) Op

#fn refasgetvalue

c:BinaryenRefAsGetValue
fn refasgetvalue(expr Expression) Expression

#fn refasi31

c:BinaryenRefAsI31
fn refasi31() Op

#fn refasnonnull

c:BinaryenRefAsNonNull
fn refasnonnull() Op

#fn refassetop

c:BinaryenRefAsSetOp
fn refassetop(expr Expression, op Op)

#fn refassetvalue

c:BinaryenRefAsSetValue
fn refassetvalue(expr Expression, valueexpr Expression)

#fn refcast

c:BinaryenRefCast
fn refcast(module_ Module, ref Expression, intendedtype HeapType) Expression

#fn refcastgetintendedtype

c:BinaryenRefCastGetIntendedType
fn refcastgetintendedtype(expr Expression) HeapType

#fn refcastgetref

c:BinaryenRefCastGetRef
fn refcastgetref(expr Expression) Expression

#fn refcastsetintendedtype

c:BinaryenRefCastSetIntendedType
fn refcastsetintendedtype(expr Expression, intendedtype HeapType)

#fn refcastsetref

c:BinaryenRefCastSetRef
fn refcastsetref(expr Expression, refexpr Expression)

#fn refeq

c:BinaryenRefEq
fn refeq(module_ Module, left Expression, right Expression) Expression

#fn refeqgetleft

c:BinaryenRefEqGetLeft
fn refeqgetleft(expr Expression) Expression

#fn refeqgetright

c:BinaryenRefEqGetRight
fn refeqgetright(expr Expression) Expression

#fn refeqsetleft

c:BinaryenRefEqSetLeft
fn refeqsetleft(expr Expression, left Expression)

#fn refeqsetright

c:BinaryenRefEqSetRight
fn refeqsetright(expr Expression, right Expression)

#fn reffunc

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

#fn reffuncgetfunc

c:BinaryenRefFuncGetFunc
fn reffuncgetfunc(expr Expression) &i8

#fn reffuncsetfunc

c:BinaryenRefFuncSetFunc
fn reffuncsetfunc(expr Expression, funcname &i8)

#fn refis

c:BinaryenRefIs
fn refis(module_ Module, op Op, value Expression) Expression

#fn refisdata

c:BinaryenRefIsData
fn refisdata() Op

#fn refisfunc

c:BinaryenRefIsFunc
fn refisfunc() Op

#fn refisgetop

c:BinaryenRefIsGetOp
fn refisgetop(expr Expression) Op

#fn refisgetvalue

c:BinaryenRefIsGetValue
fn refisgetvalue(expr Expression) Expression

#fn refisi31

c:BinaryenRefIsI31
fn refisi31() Op

#fn refisnull

c:BinaryenRefIsNull
fn refisnull() Op

#fn refissetop

c:BinaryenRefIsSetOp
fn refissetop(expr Expression, op Op)

#fn refissetvalue

c:BinaryenRefIsSetValue
fn refissetvalue(expr Expression, valueexpr Expression)

#fn refnull

c:BinaryenRefNull
fn refnull(module_ Module, type_ Type) Expression

#fn reftest

c:BinaryenRefTest
fn reftest(module_ Module, ref Expression, intendedtype HeapType) Expression

#fn reftestgetintendedtype

c:BinaryenRefTestGetIntendedType
fn reftestgetintendedtype(expr Expression) HeapType

#fn reftestgetref

c:BinaryenRefTestGetRef
fn reftestgetref(expr Expression) Expression

#fn reftestsetintendedtype

c:BinaryenRefTestSetIntendedType
fn reftestsetintendedtype(expr Expression, intendedtype HeapType)

#fn reftestsetref

c:BinaryenRefTestSetRef
fn reftestsetref(expr Expression, refexpr Expression)

#fn reinterpretfloat32

c:BinaryenReinterpretFloat32
fn reinterpretfloat32() Op

#fn reinterpretfloat64

c:BinaryenReinterpretFloat64
fn reinterpretfloat64() Op

#fn reinterpretint32

c:BinaryenReinterpretInt32
fn reinterpretint32() Op

#fn reinterpretint64

c:BinaryenReinterpretInt64
fn reinterpretint64() Op

#fn relooperaddblock

c:RelooperAddBlock
fn relooperaddblock(relooper Relooper, code Expression) RelooperBlock

#fn relooperaddblockwithswitch

c:RelooperAddBlockWithSwitch
fn relooperaddblockwithswitch(relooper Relooper, code Expression, condition Expression) RelooperBlock

#fn relooperaddbranch

c:RelooperAddBranch
fn relooperaddbranch(from RelooperBlock, to RelooperBlock, condition Expression, code Expression)

#fn relooperaddbranchforswitch

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

#fn reloopercreate

c:RelooperCreate
fn reloopercreate(module_ Module) Relooper

#fn relooperrenderanddispose

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

#fn removeelementsegment

c:BinaryenRemoveElementSegment
fn removeelementsegment(module_ Module, name &i8)

#fn removeexport

c:BinaryenRemoveExport
fn removeexport(module_ Module, externalname &i8)

#fn removefunction

c:BinaryenRemoveFunction
fn removefunction(module_ Module, name &i8)

#fn removeglobal

c:BinaryenRemoveGlobal
fn removeglobal(module_ Module, name &i8)

#fn removetable

c:BinaryenRemoveTable
fn removetable(module_ Module, table &i8)

#fn removetag

c:BinaryenRemoveTag
fn removetag(module_ Module, name &i8)

#fn remsint32

c:BinaryenRemSInt32
fn remsint32() Op

#fn remsint64

c:BinaryenRemSInt64
fn remsint64() Op

#fn remuint32

c:BinaryenRemUInt32
fn remuint32() Op

#fn remuint64

c:BinaryenRemUInt64
fn remuint64() Op

#fn replacelanevecf32x4

c:BinaryenReplaceLaneVecF32x4
fn replacelanevecf32x4() Op

#fn replacelanevecf64x2

c:BinaryenReplaceLaneVecF64x2
fn replacelanevecf64x2() Op

#fn replacelaneveci16x8

c:BinaryenReplaceLaneVecI16x8
fn replacelaneveci16x8() Op

#fn replacelaneveci32x4

c:BinaryenReplaceLaneVecI32x4
fn replacelaneveci32x4() Op

#fn replacelaneveci64x2

c:BinaryenReplaceLaneVecI64x2
fn replacelaneveci64x2() Op

#fn replacelaneveci8x16

c:BinaryenReplaceLaneVecI8x16
fn replacelaneveci8x16() Op

#fn ret

c:BinaryenReturn
fn ret(module_ Module, value Expression) Expression

#fn rethrow

c:BinaryenRethrow
fn rethrow(module_ Module, target &i8) Expression

#fn rethrowgettarget

c:BinaryenRethrowGetTarget
fn rethrowgettarget(expr Expression) &i8

#fn rethrowsettarget

c:BinaryenRethrowSetTarget
fn rethrowsettarget(expr Expression, target &i8)

#fn returncall

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

#fn returncallindirect

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

#fn returngetvalue

c:BinaryenReturnGetValue
fn returngetvalue(expr Expression) Expression

#fn returnsetvalue

c:BinaryenReturnSetValue
fn returnsetvalue(expr Expression, valueexpr Expression)

#fn rotlint32

c:BinaryenRotLInt32
fn rotlint32() Op

#fn rotlint64

c:BinaryenRotLInt64
fn rotlint64() Op

#fn rotrint32

c:BinaryenRotRInt32
fn rotrint32() Op

#fn rotrint64

c:BinaryenRotRInt64
fn rotrint64() Op

#fn selectgetcondition

c:BinaryenSelectGetCondition
fn selectgetcondition(expr Expression) Expression

#fn selectgetiffalse

c:BinaryenSelectGetIfFalse
fn selectgetiffalse(expr Expression) Expression

#fn selectgetiftrue

c:BinaryenSelectGetIfTrue
fn selectgetiftrue(expr Expression) Expression

#fn selectsetcondition

c:BinaryenSelectSetCondition
fn selectsetcondition(expr Expression, condexpr Expression)

#fn selectsetiffalse

c:BinaryenSelectSetIfFalse
fn selectsetiffalse(expr Expression, iffalseexpr Expression)

#fn selectsetiftrue

c:BinaryenSelectSetIfTrue
fn selectsetiftrue(expr Expression, iftrueexpr Expression)

#fn setallowinliningfunctionswithloops

c:BinaryenSetAllowInliningFunctionsWithLoops
fn setallowinliningfunctionswithloops(enabled bool)

#fn setalwaysinlinemaxsize

c:BinaryenSetAlwaysInlineMaxSize
fn setalwaysinlinemaxsize(size Index)

#fn setcolorsenabled

c:BinaryenSetColorsEnabled
fn setcolorsenabled(enabled bool)

#fn setdebuginfo

c:BinaryenSetDebugInfo
fn setdebuginfo(on bool)

#fn setfastmath

c:BinaryenSetFastMath
fn setfastmath(value bool)

#fn setflexibleinlinemaxsize

c:BinaryenSetFlexibleInlineMaxSize
fn setflexibleinlinemaxsize(size Index)

#fn setlowmemoryunused

c:BinaryenSetLowMemoryUnused
fn setlowmemoryunused(on bool)

#fn setmemory

c:BinaryenSetMemory
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

c:BinaryenSetOneCallerInlineMaxSize
fn setonecallerinlinemaxsize(size Index)

#fn setoptimizelevel

c:BinaryenSetOptimizeLevel
fn setoptimizelevel(level int)

#fn setpassargument

c:BinaryenSetPassArgument
fn setpassargument(name &i8, value &i8)

#fn setshrinklevel

c:BinaryenSetShrinkLevel
fn setshrinklevel(level int)

#fn setstart

c:BinaryenSetStart
fn setstart(module_ Module, start Function)

#fn settypesystem

c:BinaryenSetTypeSystem
fn settypesystem(typesystem TypeSystem)

#fn setzerofilledmemory

c:BinaryenSetZeroFilledMemory
fn setzerofilledmemory(on bool)

#fn shlint32

c:BinaryenShlInt32
fn shlint32() Op

#fn shlint64

c:BinaryenShlInt64
fn shlint64() Op

#fn shlveci16x8

c:BinaryenShlVecI16x8
fn shlveci16x8() Op

#fn shlveci32x4

c:BinaryenShlVecI32x4
fn shlveci32x4() Op

#fn shlveci64x2

c:BinaryenShlVecI64x2
fn shlveci64x2() Op

#fn shlveci8x16

c:BinaryenShlVecI8x16
fn shlveci8x16() Op

#fn shrsint32

c:BinaryenShrSInt32
fn shrsint32() Op

#fn shrsint64

c:BinaryenShrSInt64
fn shrsint64() Op

#fn shrsveci16x8

c:BinaryenShrSVecI16x8
fn shrsveci16x8() Op

#fn shrsveci32x4

c:BinaryenShrSVecI32x4
fn shrsveci32x4() Op

#fn shrsveci64x2

c:BinaryenShrSVecI64x2
fn shrsveci64x2() Op

#fn shrsveci8x16

c:BinaryenShrSVecI8x16
fn shrsveci8x16() Op

#fn shruint32

c:BinaryenShrUInt32
fn shruint32() Op

#fn shruint64

c:BinaryenShrUInt64
fn shruint64() Op

#fn shruveci16x8

c:BinaryenShrUVecI16x8
fn shruveci16x8() Op

#fn shruveci32x4

c:BinaryenShrUVecI32x4
fn shruveci32x4() Op

#fn shruveci64x2

c:BinaryenShrUVecI64x2
fn shruveci64x2() Op

#fn shruveci8x16

c:BinaryenShrUVecI8x16
fn shruveci8x16() Op

#fn sideeffectany

c:BinaryenSideEffectAny
fn sideeffectany() SideEffects

#fn sideeffectbranches

c:BinaryenSideEffectBranches
fn sideeffectbranches() SideEffects

#fn sideeffectcalls

c:BinaryenSideEffectCalls
fn sideeffectcalls() SideEffects

#fn sideeffectdanglingpop

c:BinaryenSideEffectDanglingPop
fn sideeffectdanglingpop() SideEffects

#fn sideeffectimplicittrap

c:BinaryenSideEffectImplicitTrap
fn sideeffectimplicittrap() SideEffects

#fn sideeffectisatomic

c:BinaryenSideEffectIsAtomic
fn sideeffectisatomic() SideEffects

#fn sideeffectnone

c:BinaryenSideEffectNone
fn sideeffectnone() SideEffects

#fn sideeffectreadsglobal

c:BinaryenSideEffectReadsGlobal
fn sideeffectreadsglobal() SideEffects

#fn sideeffectreadslocal

c:BinaryenSideEffectReadsLocal
fn sideeffectreadslocal() SideEffects

#fn sideeffectreadsmemory

c:BinaryenSideEffectReadsMemory
fn sideeffectreadsmemory() SideEffects

#fn sideeffectreadstable

c:BinaryenSideEffectReadsTable
fn sideeffectreadstable() SideEffects

#fn sideeffectthrows

c:BinaryenSideEffectThrows
fn sideeffectthrows() SideEffects

#fn sideeffecttrapsneverhappen

c:BinaryenSideEffectTrapsNeverHappen
fn sideeffecttrapsneverhappen() SideEffects

#fn sideeffectwritesglobal

c:BinaryenSideEffectWritesGlobal
fn sideeffectwritesglobal() SideEffects

#fn sideeffectwriteslocal

c:BinaryenSideEffectWritesLocal
fn sideeffectwriteslocal() SideEffects

#fn sideeffectwritesmemory

c:BinaryenSideEffectWritesMemory
fn sideeffectwritesmemory() SideEffects

#fn sideeffectwritestable

c:BinaryenSideEffectWritesTable
fn sideeffectwritestable() SideEffects

#fn signaturetypegetparams

c:BinaryenSignatureTypeGetParams
fn signaturetypegetparams(heaptype HeapType) Type

#fn signaturetypegetresults

c:BinaryenSignatureTypeGetResults
fn signaturetypegetresults(heaptype HeapType) Type

#fn simdextract

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

#fn simdextractgetindex

c:BinaryenSIMDExtractGetIndex
fn simdextractgetindex(expr Expression) u8

#fn simdextractgetop

c:BinaryenSIMDExtractGetOp
fn simdextractgetop(expr Expression) Op

#fn simdextractgetvec

c:BinaryenSIMDExtractGetVec
fn simdextractgetvec(expr Expression) Expression

#fn simdextractsetindex

c:BinaryenSIMDExtractSetIndex
fn simdextractsetindex(expr Expression, index u8)

#fn simdextractsetop

c:BinaryenSIMDExtractSetOp
fn simdextractsetop(expr Expression, op Op)

#fn simdextractsetvec

c:BinaryenSIMDExtractSetVec
fn simdextractsetvec(expr Expression, vecexpr Expression)

#fn simdload

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

#fn simdloadgetalign

c:BinaryenSIMDLoadGetAlign
fn simdloadgetalign(expr Expression) u32

#fn simdloadgetoffset

c:BinaryenSIMDLoadGetOffset
fn simdloadgetoffset(expr Expression) u32

#fn simdloadgetop

c:BinaryenSIMDLoadGetOp
fn simdloadgetop(expr Expression) Op

#fn simdloadgetptr

c:BinaryenSIMDLoadGetPtr
fn simdloadgetptr(expr Expression) Expression

#fn simdloadsetalign

c:BinaryenSIMDLoadSetAlign
fn simdloadsetalign(expr Expression, align u32)

#fn simdloadsetoffset

c:BinaryenSIMDLoadSetOffset
fn simdloadsetoffset(expr Expression, offset u32)

#fn simdloadsetop

c:BinaryenSIMDLoadSetOp
fn simdloadsetop(expr Expression, op Op)

#fn simdloadsetptr

c:BinaryenSIMDLoadSetPtr
fn simdloadsetptr(expr Expression, ptrexpr Expression)

#fn simdloadstorelane

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

#fn simdloadstorelanegetalign

c:BinaryenSIMDLoadStoreLaneGetAlign
fn simdloadstorelanegetalign(expr Expression) u32

#fn simdloadstorelanegetindex

c:BinaryenSIMDLoadStoreLaneGetIndex
fn simdloadstorelanegetindex(expr Expression) u8

#fn simdloadstorelanegetoffset

c:BinaryenSIMDLoadStoreLaneGetOffset
fn simdloadstorelanegetoffset(expr Expression) u32

#fn simdloadstorelanegetop

c:BinaryenSIMDLoadStoreLaneGetOp
fn simdloadstorelanegetop(expr Expression) Op

#fn simdloadstorelanegetptr

c:BinaryenSIMDLoadStoreLaneGetPtr
fn simdloadstorelanegetptr(expr Expression) Expression

#fn simdloadstorelanegetvec

c:BinaryenSIMDLoadStoreLaneGetVec
fn simdloadstorelanegetvec(expr Expression) Expression

#fn simdloadstorelaneisstore

c:BinaryenSIMDLoadStoreLaneIsStore
fn simdloadstorelaneisstore(expr Expression) bool

#fn simdloadstorelanesetalign

c:BinaryenSIMDLoadStoreLaneSetAlign
fn simdloadstorelanesetalign(expr Expression, align u32)

#fn simdloadstorelanesetindex

c:BinaryenSIMDLoadStoreLaneSetIndex
fn simdloadstorelanesetindex(expr Expression, index u8)

#fn simdloadstorelanesetoffset

c:BinaryenSIMDLoadStoreLaneSetOffset
fn simdloadstorelanesetoffset(expr Expression, offset u32)

#fn simdloadstorelanesetop

c:BinaryenSIMDLoadStoreLaneSetOp
fn simdloadstorelanesetop(expr Expression, op Op)

#fn simdloadstorelanesetptr

c:BinaryenSIMDLoadStoreLaneSetPtr
fn simdloadstorelanesetptr(expr Expression, ptrexpr Expression)

#fn simdloadstorelanesetvec

c:BinaryenSIMDLoadStoreLaneSetVec
fn simdloadstorelanesetvec(expr Expression, vecexpr Expression)

#fn simdreplace

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

#fn simdreplacegetindex

c:BinaryenSIMDReplaceGetIndex
fn simdreplacegetindex(expr Expression) u8

#fn simdreplacegetop

c:BinaryenSIMDReplaceGetOp
fn simdreplacegetop(expr Expression) Op

#fn simdreplacegetvalue

c:BinaryenSIMDReplaceGetValue
fn simdreplacegetvalue(expr Expression) Expression

#fn simdreplacegetvec

c:BinaryenSIMDReplaceGetVec
fn simdreplacegetvec(expr Expression) Expression

#fn simdreplacesetindex

c:BinaryenSIMDReplaceSetIndex
fn simdreplacesetindex(expr Expression, index u8)

#fn simdreplacesetop

c:BinaryenSIMDReplaceSetOp
fn simdreplacesetop(expr Expression, op Op)

#fn simdreplacesetvalue

c:BinaryenSIMDReplaceSetValue
fn simdreplacesetvalue(expr Expression, valueexpr Expression)

#fn simdreplacesetvec

c:BinaryenSIMDReplaceSetVec
fn simdreplacesetvec(expr Expression, vecexpr Expression)

#fn simdshift

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

#fn simdshiftgetop

c:BinaryenSIMDShiftGetOp
fn simdshiftgetop(expr Expression) Op

#fn simdshiftgetshift

c:BinaryenSIMDShiftGetShift
fn simdshiftgetshift(expr Expression) Expression

#fn simdshiftgetvec

c:BinaryenSIMDShiftGetVec
fn simdshiftgetvec(expr Expression) Expression

#fn simdshiftsetop

c