Full Code of AndrewScheidecker/WAVM for AI

gitextract_8thbuf1h/

├── .clang-format
├── .clang-tidy
├── .editorconfig
├── .gitattributes
├── .github/
│   └── workflows/
│       └── build.yml
├── .gitignore
├── Benchmarks/
│   ├── binary-trees.wasm
│   ├── blake2b-memory64.wast
│   ├── blake2b.wast
│   ├── coremark.wasm
│   ├── fannkuch-redux.wasm
│   ├── fasta.wasm
│   ├── mandelbrot.wasm
│   ├── nbody.wasm
│   ├── spectral-norm.wasm
│   └── zlib.wasm
├── Build/
│   ├── dev.py
│   ├── lib/
│   │   ├── __init__.py
│   │   ├── benchmark.py
│   │   ├── build.py
│   │   ├── context.py
│   │   ├── coverage.py
│   │   ├── cpp_files.py
│   │   ├── format.py
│   │   ├── fuzz.py
│   │   ├── lint.py
│   │   ├── llvm.py
│   │   ├── output.py
│   │   ├── platform.py
│   │   ├── run.py
│   │   ├── task_graph.py
│   │   ├── test.py
│   │   ├── test_def.py
│   │   ├── tidy.py
│   │   ├── toolchain.py
│   │   ├── wasi.py
│   │   └── workspace.py
│   └── ruff.toml
├── CMakeLists.txt
├── Doc/
│   ├── BuildSystem.md
│   ├── Building.md
│   ├── CodeOrganization.md
│   ├── GettingStarted.md
│   ├── PortabilityMatrix.md
│   ├── SignalsAndExceptions.md
│   └── WAVMObjectReachability.dot
├── Dockerfile
├── Examples/
│   ├── CMakeLists.txt
│   ├── echo.wast
│   ├── embedder/
│   │   ├── c/
│   │   │   ├── CMakeLists.txt
│   │   │   └── embedder-example.c
│   │   ├── cpp/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── build.sh
│   │   │   └── embedder-example.cpp
│   │   └── cpp-wasi/
│   │       ├── CMakeLists.txt
│   │       └── embedder-example.cpp
│   ├── helloworld.wast
│   ├── tee.wast
│   └── trap.wast
├── Include/
│   └── WAVM/
│       ├── DWARF/
│       │   ├── Constants.h
│       │   ├── DWARF.h
│       │   └── Sections.h
│       ├── IR/
│       │   ├── FeatureSpec.h
│       │   ├── IR.h
│       │   ├── Module.h
│       │   ├── OperatorPrinter.h
│       │   ├── OperatorSignatures.h
│       │   ├── OperatorTable.h
│       │   ├── Operators.h
│       │   ├── RandomModule.h
│       │   ├── Types.h
│       │   ├── Types.natvis
│       │   ├── Validate.h
│       │   └── Value.h
│       ├── Inline/
│       │   ├── Assert.h
│       │   ├── BasicTypes.h
│       │   ├── CLI.h
│       │   ├── CMakeLists.txt
│       │   ├── Config.h.in
│       │   ├── DenseStaticIntSet.h
│       │   ├── Errors.h
│       │   ├── FixedString.h
│       │   ├── FloatComponents.h
│       │   ├── Hash.h
│       │   ├── HashMap.h
│       │   ├── HashSet.h
│       │   ├── HashTable.h
│       │   ├── I128.h
│       │   ├── Impl/
│       │   │   ├── HashMap.natvis
│       │   │   ├── HashMapImpl.h
│       │   │   ├── HashSet.natvis
│       │   │   ├── HashSetImpl.h
│       │   │   ├── HashTable.natvis
│       │   │   ├── HashTableImpl.h
│       │   │   ├── I128Impl.LICENSE
│       │   │   ├── I128Impl.h
│       │   │   ├── OptionalStorage.h
│       │   │   └── OptionalStorage.natvis
│       │   ├── IndexMap.h
│       │   ├── InlineArray.h
│       │   ├── IntCasts.h
│       │   ├── IntrusiveSharedPtr.h
│       │   ├── IsNameChar.h
│       │   ├── LEB128.h
│       │   ├── RandomStream.h
│       │   ├── Serialization.h
│       │   ├── StringBuilder.h
│       │   ├── Time.h
│       │   ├── Timing.h
│       │   ├── UnalignedArrayView.h
│       │   ├── Unicode.h
│       │   ├── Version.h.in
│       │   └── xxhash/
│       │       ├── CMakeLists.txt
│       │       ├── LICENSE
│       │       ├── xxh3.h
│       │       ├── xxhash.c
│       │       └── xxhash.h
│       ├── LLVMJIT/
│       │   └── LLVMJIT.h
│       ├── Logging/
│       │   └── Logging.h
│       ├── NFA/
│       │   └── NFA.h
│       ├── ObjectCache/
│       │   └── ObjectCache.h
│       ├── ObjectLinker/
│       │   └── ObjectLinker.h
│       ├── Platform/
│       │   ├── Alloca.h
│       │   ├── CPU.h
│       │   ├── Clock.h
│       │   ├── ConditionVariable.h
│       │   ├── Defines.h
│       │   ├── Diagnostics.h
│       │   ├── Error.h
│       │   ├── File.h
│       │   ├── Intrinsic.h
│       │   ├── Memory.h
│       │   ├── Mutex.h
│       │   ├── RWMutex.h
│       │   ├── Random.h
│       │   ├── Signal.h
│       │   ├── Thread.h
│       │   └── Unwind.h
│       ├── RegExp/
│       │   └── RegExp.h
│       ├── Runtime/
│       │   ├── Intrinsics.h
│       │   ├── Linker.h
│       │   └── Runtime.h
│       ├── RuntimeABI/
│       │   ├── CMakeLists.txt
│       │   └── RuntimeABI.h
│       ├── ThreadTest/
│       │   └── ThreadTest.h
│       ├── VFS/
│       │   ├── SandboxFS.h
│       │   └── VFS.h
│       ├── WASI/
│       │   ├── WASI.h
│       │   ├── WASIABI.LICENSE
│       │   └── WASIABI.h
│       ├── WASM/
│       │   └── WASM.h
│       ├── WASTParse/
│       │   ├── TestScript.h
│       │   └── WASTParse.h
│       ├── WASTPrint/
│       │   └── WASTPrint.h
│       └── wavm-c/
│           ├── wasm-c-api.LICENSE
│           └── wavm-c.h
├── LICENSE.txt
├── Lib/
│   ├── DWARF/
│   │   ├── CMakeLists.txt
│   │   └── DWARF.cpp
│   ├── IR/
│   │   ├── CMakeLists.txt
│   │   ├── DisassemblyNames.cpp
│   │   ├── FeatureSpec.cpp
│   │   ├── FloatPrinting.cpp
│   │   ├── Module.cpp
│   │   ├── Operators.cpp
│   │   ├── RandomModule.cpp
│   │   ├── Types.cpp
│   │   └── Validate.cpp
│   ├── LLVMJIT/
│   │   ├── CMakeLists.txt
│   │   ├── Disassembler.cpp
│   │   ├── EmitContext.h
│   │   ├── EmitConvert.cpp
│   │   ├── EmitCore.cpp
│   │   ├── EmitExceptions.cpp
│   │   ├── EmitFunction.cpp
│   │   ├── EmitFunctionContext.h
│   │   ├── EmitMem.cpp
│   │   ├── EmitModule.cpp
│   │   ├── EmitModuleContext.h
│   │   ├── EmitNumeric.cpp
│   │   ├── EmitTable.cpp
│   │   ├── EmitVar.cpp
│   │   ├── GDBRegistration.cpp
│   │   ├── LLVMCompile.cpp
│   │   ├── LLVMJIT.cpp
│   │   ├── LLVMJITPrivate.h
│   │   ├── LLVMModule.cpp
│   │   └── Thunk.cpp
│   ├── Logging/
│   │   ├── CMakeLists.txt
│   │   └── Logging.cpp
│   ├── NFA/
│   │   ├── CMakeLists.txt
│   │   └── NFA.cpp
│   ├── ObjectCache/
│   │   ├── CMakeLists.txt
│   │   └── ObjectCache.cpp
│   ├── ObjectLinker/
│   │   ├── CMakeLists.txt
│   │   ├── COFF.cpp
│   │   ├── ELF.cpp
│   │   ├── MachO.cpp
│   │   ├── ObjectLinker.cpp
│   │   └── ObjectLinkerPrivate.h
│   ├── Platform/
│   │   ├── CMakeLists.txt
│   │   ├── POSIX/
│   │   │   ├── CPUPOSIX.cpp
│   │   │   ├── ClockPOSIX.cpp
│   │   │   ├── ConditionVariablePOSIX.cpp
│   │   │   ├── DebugPersonality.cpp
│   │   │   ├── DiagnosticsPOSIX.cpp
│   │   │   ├── EHFrameDecode.cpp
│   │   │   ├── ErrorPOSIX.cpp
│   │   │   ├── FilePOSIX.cpp
│   │   │   ├── MemoryPOSIX.cpp
│   │   │   ├── MutexPOSIX.cpp
│   │   │   ├── POSIXPrivate.h
│   │   │   ├── RWMutexPOSIX.cpp
│   │   │   ├── RandomPOSIX.cpp
│   │   │   ├── SignalPOSIX.cpp
│   │   │   ├── ThreadPOSIX.cpp
│   │   │   └── UnwindPOSIX.cpp
│   │   └── Windows/
│   │       ├── CPUWindows.cpp
│   │       ├── ClockWindows.cpp
│   │       ├── ConditionVariableWindows.cpp
│   │       ├── DiagnosticsWindows.cpp
│   │       ├── ErrorWindows.cpp
│   │       ├── FileWindows.cpp
│   │       ├── MemoryWindows.cpp
│   │       ├── MutexWindows.cpp
│   │       ├── RWMutexWindows.cpp
│   │       ├── RandomWindows.cpp
│   │       ├── SignalWindows.cpp
│   │       ├── ThreadWindows.cpp
│   │       ├── UnwindWindows.cpp
│   │       └── WindowsPrivate.h
│   ├── RegExp/
│   │   ├── CMakeLists.txt
│   │   └── RegExp.cpp
│   ├── Runtime/
│   │   ├── Atomics.cpp
│   │   ├── CMakeLists.txt
│   │   ├── Compartment.cpp
│   │   ├── Context.cpp
│   │   ├── Diagnostics.cpp
│   │   ├── Exception.cpp
│   │   ├── Global.cpp
│   │   ├── Instance.cpp
│   │   ├── Intrinsics.cpp
│   │   ├── Invoke.cpp
│   │   ├── Linker.cpp
│   │   ├── Memory.cpp
│   │   ├── Module.cpp
│   │   ├── ObjectGC.cpp
│   │   ├── ResourceQuota.cpp
│   │   ├── Runtime.cpp
│   │   ├── RuntimePrivate.h
│   │   ├── Table.cpp
│   │   └── WAVMIntrinsics.cpp
│   ├── ThreadTest/
│   │   ├── CMakeLists.txt
│   │   └── ThreadTest.cpp
│   ├── VFS/
│   │   ├── CMakeLists.txt
│   │   ├── SandboxFS.cpp
│   │   └── VFS.cpp
│   ├── WASI/
│   │   ├── CMakeLists.txt
│   │   ├── WASI.cpp
│   │   ├── WASIArgsEnvs.cpp
│   │   ├── WASIClocks.cpp
│   │   ├── WASIDiagnostics.cpp
│   │   ├── WASIFile.cpp
│   │   └── WASIPrivate.h
│   ├── WASM/
│   │   ├── CMakeLists.txt
│   │   └── WASMSerialization.cpp
│   ├── WASTParse/
│   │   ├── CMakeLists.txt
│   │   ├── Lexer.cpp
│   │   ├── Lexer.h
│   │   ├── Parse.cpp
│   │   ├── Parse.h
│   │   ├── ParseFunction.cpp
│   │   ├── ParseModule.cpp
│   │   ├── ParseNumbers.cpp
│   │   └── ParseTests.cpp
│   ├── WASTPrint/
│   │   ├── CMakeLists.txt
│   │   └── Print.cpp
│   └── wavm-c/
│       ├── CMakeLists.txt
│       └── wavm-c.cpp
├── Programs/
│   └── wavm/
│       ├── CMakeLists.txt
│       ├── Testing/
│       │   ├── Benchmark.cpp
│       │   ├── DumpTestModules.cpp
│       │   ├── RunTestScript.cpp
│       │   ├── TestAPI.cpp
│       │   ├── TestCAPI.c
│       │   ├── TestDWARF.cpp
│       │   ├── TestHashMap.cpp
│       │   ├── TestHashSet.cpp
│       │   ├── TestI128.cpp
│       │   ├── TestLEB128.cpp
│       │   ├── TestObjectLinker.cpp
│       │   ├── TestUtils.h
│       │   ├── wavm-test.cpp
│       │   └── wavm-test.h
│       ├── wavm-assemble.cpp
│       ├── wavm-compile.cpp
│       ├── wavm-disassemble.cpp
│       ├── wavm-run.cpp
│       ├── wavm.cpp
│       └── wavm.h
├── README.md
├── THIRD-PARTY.md
├── Test/
│   ├── CMakeLists.txt
│   ├── WebAssembly/
│   │   ├── LICENSE.txt
│   │   ├── memory64/
│   │   │   ├── address.wast
│   │   │   ├── address64.wast
│   │   │   ├── align.wast
│   │   │   ├── align64.wast
│   │   │   ├── binary-leb128.wast
│   │   │   ├── binary.wast
│   │   │   ├── block.wast
│   │   │   ├── br.wast
│   │   │   ├── br_if.wast
│   │   │   ├── br_table.wast
│   │   │   ├── bulk64._wast
│   │   │   ├── call.wast
│   │   │   ├── call_indirect.wast
│   │   │   ├── comments.wast
│   │   │   ├── const.wast
│   │   │   ├── conversions.wast
│   │   │   ├── custom.wast
│   │   │   ├── data.wast
│   │   │   ├── elem.wast
│   │   │   ├── endianness.wast
│   │   │   ├── endianness64.wast
│   │   │   ├── exports.wast
│   │   │   ├── f32.wast
│   │   │   ├── f32_bitwise.wast
│   │   │   ├── f32_cmp.wast
│   │   │   ├── f64.wast
│   │   │   ├── f64_bitwise.wast
│   │   │   ├── f64_cmp.wast
│   │   │   ├── fac.wast
│   │   │   ├── float_exprs.wast
│   │   │   ├── float_literals.wast
│   │   │   ├── float_memory.wast
│   │   │   ├── float_memory64.wast
│   │   │   ├── float_misc.wast
│   │   │   ├── forward.wast
│   │   │   ├── func.wast
│   │   │   ├── func_ptrs.wast
│   │   │   ├── global.wast
│   │   │   ├── i32.wast
│   │   │   ├── i64.wast
│   │   │   ├── if.wast
│   │   │   ├── imports.wast
│   │   │   ├── inline-module.wast
│   │   │   ├── int_exprs.wast
│   │   │   ├── int_literals.wast
│   │   │   ├── labels.wast
│   │   │   ├── left-to-right.wast
│   │   │   ├── linking.wast
│   │   │   ├── load.wast
│   │   │   ├── load64.wast
│   │   │   ├── local_get.wast
│   │   │   ├── local_set.wast
│   │   │   ├── local_tee.wast
│   │   │   ├── loop.wast
│   │   │   ├── memory.wast
│   │   │   ├── memory64.wast
│   │   │   ├── memory_grow.wast
│   │   │   ├── memory_grow64.wast
│   │   │   ├── memory_redundancy.wast
│   │   │   ├── memory_redundancy64.wast
│   │   │   ├── memory_size.wast
│   │   │   ├── memory_trap.wast
│   │   │   ├── memory_trap64.wast
│   │   │   ├── names.wast
│   │   │   ├── nop.wast
│   │   │   ├── return.wast
│   │   │   ├── select.wast
│   │   │   ├── skip-stack-guard-page.wast
│   │   │   ├── stack.wast
│   │   │   ├── start.wast
│   │   │   ├── store.wast
│   │   │   ├── switch.wast
│   │   │   ├── table.wast
│   │   │   ├── token.wast
│   │   │   ├── traps.wast
│   │   │   ├── type.wast
│   │   │   ├── unreachable.wast
│   │   │   ├── unreached-invalid.wast
│   │   │   ├── unwind.wast
│   │   │   ├── utf8-custom-section-id.wast
│   │   │   ├── utf8-import-field.wast
│   │   │   ├── utf8-import-module.wast
│   │   │   └── utf8-invalid-encoding.wast
│   │   ├── multi-memory/
│   │   │   ├── address.wast
│   │   │   ├── align.wast
│   │   │   ├── binary-leb128.wast
│   │   │   ├── binary.wast
│   │   │   ├── block.wast
│   │   │   ├── br.wast
│   │   │   ├── br_if.wast
│   │   │   ├── br_table.wast
│   │   │   ├── bulk.wast
│   │   │   ├── call.wast
│   │   │   ├── call_indirect.wast
│   │   │   ├── comments.wast
│   │   │   ├── const.wast
│   │   │   ├── conversions.wast
│   │   │   ├── custom.wast
│   │   │   ├── data.wast
│   │   │   ├── elem.wast
│   │   │   ├── endianness.wast
│   │   │   ├── exports.wast
│   │   │   ├── f32.wast
│   │   │   ├── f32_bitwise.wast
│   │   │   ├── f32_cmp.wast
│   │   │   ├── f64.wast
│   │   │   ├── f64_bitwise.wast
│   │   │   ├── f64_cmp.wast
│   │   │   ├── fac.wast
│   │   │   ├── float_exprs.wast
│   │   │   ├── float_literals.wast
│   │   │   ├── float_memory.wast
│   │   │   ├── float_misc.wast
│   │   │   ├── forward.wast
│   │   │   ├── func.wast
│   │   │   ├── func_ptrs.wast
│   │   │   ├── global.wast
│   │   │   ├── i32.wast
│   │   │   ├── i64.wast
│   │   │   ├── if.wast
│   │   │   ├── imports.wast
│   │   │   ├── inline-module.wast
│   │   │   ├── int_exprs.wast
│   │   │   ├── int_literals.wast
│   │   │   ├── labels.wast
│   │   │   ├── left-to-right.wast
│   │   │   ├── linking.wast
│   │   │   ├── load.wast
│   │   │   ├── local_get.wast
│   │   │   ├── local_set.wast
│   │   │   ├── local_tee.wast
│   │   │   ├── loop.wast
│   │   │   ├── memory-multi.wast
│   │   │   ├── memory.wast
│   │   │   ├── memory_copy.wast
│   │   │   ├── memory_fill.wast
│   │   │   ├── memory_grow.wast
│   │   │   ├── memory_init.wast
│   │   │   ├── memory_redundancy.wast
│   │   │   ├── memory_size.wast
│   │   │   ├── memory_trap.wast
│   │   │   ├── names.wast
│   │   │   ├── nop.wast
│   │   │   ├── ref_func.wast
│   │   │   ├── ref_is_null.wast
│   │   │   ├── ref_null.wast
│   │   │   ├── return.wast
│   │   │   ├── select.wast
│   │   │   ├── skip-stack-guard-page.wast
│   │   │   ├── stack.wast
│   │   │   ├── start.wast
│   │   │   ├── store.wast
│   │   │   ├── switch.wast
│   │   │   ├── table-sub.wast
│   │   │   ├── table.wast
│   │   │   ├── table_copy.wast
│   │   │   ├── table_fill.wast
│   │   │   ├── table_get.wast
│   │   │   ├── table_grow.wast
│   │   │   ├── table_init.wast
│   │   │   ├── table_set.wast
│   │   │   ├── table_size.wast
│   │   │   ├── token.wast
│   │   │   ├── traps.wast
│   │   │   ├── type.wast
│   │   │   ├── unreachable.wast
│   │   │   ├── unreached-invalid.wast
│   │   │   ├── unreached-valid.wast
│   │   │   ├── unwind.wast
│   │   │   ├── utf8-custom-section-id.wast
│   │   │   ├── utf8-import-field.wast
│   │   │   ├── utf8-import-module.wast
│   │   │   └── utf8-invalid-encoding.wast
│   │   ├── spec/
│   │   │   ├── address.wast
│   │   │   ├── align.wast
│   │   │   ├── binary-leb128.wast
│   │   │   ├── binary.wast
│   │   │   ├── block.wast
│   │   │   ├── br.wast
│   │   │   ├── br_if.wast
│   │   │   ├── br_table.wast
│   │   │   ├── bulk.wast
│   │   │   ├── call.wast
│   │   │   ├── call_indirect.wast
│   │   │   ├── comments.wast
│   │   │   ├── const.wast
│   │   │   ├── conversions.wast
│   │   │   ├── custom.wast
│   │   │   ├── data.wast
│   │   │   ├── elem.wast
│   │   │   ├── endianness.wast
│   │   │   ├── exports.wast
│   │   │   ├── f32.wast
│   │   │   ├── f32_bitwise.wast
│   │   │   ├── f32_cmp.wast
│   │   │   ├── f64.wast
│   │   │   ├── f64_bitwise.wast
│   │   │   ├── f64_cmp.wast
│   │   │   ├── fac.wast
│   │   │   ├── float_exprs.wast
│   │   │   ├── float_literals.wast
│   │   │   ├── float_memory.wast
│   │   │   ├── float_misc.wast
│   │   │   ├── forward.wast
│   │   │   ├── func.wast
│   │   │   ├── func_ptrs.wast
│   │   │   ├── global.wast
│   │   │   ├── i32.wast
│   │   │   ├── i64.wast
│   │   │   ├── if.wast
│   │   │   ├── imports.wast
│   │   │   ├── inline-module.wast
│   │   │   ├── int_exprs.wast
│   │   │   ├── int_literals.wast
│   │   │   ├── labels.wast
│   │   │   ├── left-to-right.wast
│   │   │   ├── linking.wast
│   │   │   ├── load.wast
│   │   │   ├── local_get.wast
│   │   │   ├── local_set.wast
│   │   │   ├── local_tee.wast
│   │   │   ├── loop.wast
│   │   │   ├── memory.wast
│   │   │   ├── memory_copy.wast
│   │   │   ├── memory_fill.wast
│   │   │   ├── memory_grow.wast
│   │   │   ├── memory_init.wast
│   │   │   ├── memory_redundancy.wast
│   │   │   ├── memory_size.wast
│   │   │   ├── memory_trap.wast
│   │   │   ├── names.wast
│   │   │   ├── nop.wast
│   │   │   ├── ref_func.wast
│   │   │   ├── ref_is_null.wast
│   │   │   ├── ref_null.wast
│   │   │   ├── return.wast
│   │   │   ├── select.wast
│   │   │   ├── simd/
│   │   │   │   ├── meta/
│   │   │   │   │   ├── README.md
│   │   │   │   │   ├── gen_tests.py
│   │   │   │   │   ├── simd.py
│   │   │   │   │   ├── simd_arithmetic.py
│   │   │   │   │   ├── simd_bitwise.py
│   │   │   │   │   ├── simd_compare.py
│   │   │   │   │   ├── simd_ext_mul.py
│   │   │   │   │   ├── simd_extadd_pairwise.py
│   │   │   │   │   ├── simd_f32x4.py
│   │   │   │   │   ├── simd_f32x4_arith.py
│   │   │   │   │   ├── simd_f32x4_cmp.py
│   │   │   │   │   ├── simd_f32x4_pmin_pmax.py
│   │   │   │   │   ├── simd_f32x4_rounding.py
│   │   │   │   │   ├── simd_f64x2.py
│   │   │   │   │   ├── simd_f64x2_arith.py
│   │   │   │   │   ├── simd_f64x2_cmp.py
│   │   │   │   │   ├── simd_f64x2_pmin_pmax.py
│   │   │   │   │   ├── simd_f64x2_rounding.py
│   │   │   │   │   ├── simd_float_op.py
│   │   │   │   │   ├── simd_i16x8_arith.py
│   │   │   │   │   ├── simd_i16x8_cmp.py
│   │   │   │   │   ├── simd_i16x8_q15mulr_sat_s.py
│   │   │   │   │   ├── simd_i32x4_arith.py
│   │   │   │   │   ├── simd_i32x4_cmp.py
│   │   │   │   │   ├── simd_i32x4_dot_i16x8.py
│   │   │   │   │   ├── simd_i64x2_arith.py
│   │   │   │   │   ├── simd_i64x2_cmp.py
│   │   │   │   │   ├── simd_i8x16_arith.py
│   │   │   │   │   ├── simd_i8x16_cmp.py
│   │   │   │   │   ├── simd_int_arith2.py
│   │   │   │   │   ├── simd_int_to_int_extend.py
│   │   │   │   │   ├── simd_int_trunc_sat_float.py
│   │   │   │   │   ├── simd_integer_op.py
│   │   │   │   │   ├── simd_lane_value.py
│   │   │   │   │   ├── simd_load_lane.py
│   │   │   │   │   ├── simd_sat_arith.py
│   │   │   │   │   ├── simd_store_lane.py
│   │   │   │   │   └── test_assert.py
│   │   │   │   ├── simd_address.wast
│   │   │   │   ├── simd_align.wast
│   │   │   │   ├── simd_bit_shift.wast
│   │   │   │   ├── simd_bitwise.wast
│   │   │   │   ├── simd_boolean.wast
│   │   │   │   ├── simd_const.wast
│   │   │   │   ├── simd_conversions.wast
│   │   │   │   ├── simd_f32x4.wast
│   │   │   │   ├── simd_f32x4_arith.wast
│   │   │   │   ├── simd_f32x4_cmp.wast
│   │   │   │   ├── simd_f32x4_pmin_pmax.wast
│   │   │   │   ├── simd_f32x4_rounding.wast
│   │   │   │   ├── simd_f64x2.wast
│   │   │   │   ├── simd_f64x2_arith.wast
│   │   │   │   ├── simd_f64x2_cmp.wast
│   │   │   │   ├── simd_f64x2_pmin_pmax.wast
│   │   │   │   ├── simd_f64x2_rounding.wast
│   │   │   │   ├── simd_i16x8_arith.wast
│   │   │   │   ├── simd_i16x8_arith2.wast
│   │   │   │   ├── simd_i16x8_cmp.wast
│   │   │   │   ├── simd_i16x8_extadd_pairwise_i8x16.wast
│   │   │   │   ├── simd_i16x8_extmul_i8x16.wast
│   │   │   │   ├── simd_i16x8_q15mulr_sat_s.wast
│   │   │   │   ├── simd_i16x8_sat_arith.wast
│   │   │   │   ├── simd_i32x4_arith.wast
│   │   │   │   ├── simd_i32x4_arith2.wast
│   │   │   │   ├── simd_i32x4_cmp.wast
│   │   │   │   ├── simd_i32x4_dot_i16x8.wast
│   │   │   │   ├── simd_i32x4_extadd_pairwise_i16x8.wast
│   │   │   │   ├── simd_i32x4_extmul_i16x8.wast
│   │   │   │   ├── simd_i32x4_trunc_sat_f32x4.wast
│   │   │   │   ├── simd_i32x4_trunc_sat_f64x2.wast
│   │   │   │   ├── simd_i64x2_arith.wast
│   │   │   │   ├── simd_i64x2_arith2.wast
│   │   │   │   ├── simd_i64x2_cmp.wast
│   │   │   │   ├── simd_i64x2_extmul_i32x4.wast
│   │   │   │   ├── simd_i8x16_arith.wast
│   │   │   │   ├── simd_i8x16_arith2.wast
│   │   │   │   ├── simd_i8x16_cmp.wast
│   │   │   │   ├── simd_i8x16_sat_arith.wast
│   │   │   │   ├── simd_int_to_int_extend.wast
│   │   │   │   ├── simd_lane.wast
│   │   │   │   ├── simd_load.wast
│   │   │   │   ├── simd_load16_lane.wast
│   │   │   │   ├── simd_load32_lane.wast
│   │   │   │   ├── simd_load64_lane.wast
│   │   │   │   ├── simd_load8_lane.wast
│   │   │   │   ├── simd_load_extend.wast
│   │   │   │   ├── simd_load_splat.wast
│   │   │   │   ├── simd_load_zero.wast
│   │   │   │   ├── simd_splat.wast
│   │   │   │   ├── simd_store.wast
│   │   │   │   ├── simd_store16_lane.wast
│   │   │   │   ├── simd_store32_lane.wast
│   │   │   │   ├── simd_store64_lane.wast
│   │   │   │   └── simd_store8_lane.wast
│   │   │   ├── skip-stack-guard-page.wast
│   │   │   ├── stack.wast
│   │   │   ├── start.wast
│   │   │   ├── store.wast
│   │   │   ├── switch.wast
│   │   │   ├── table-sub.wast
│   │   │   ├── table.wast
│   │   │   ├── table_copy.wast
│   │   │   ├── table_fill.wast
│   │   │   ├── table_get.wast
│   │   │   ├── table_grow.wast
│   │   │   ├── table_init.wast
│   │   │   ├── table_set.wast
│   │   │   ├── table_size.wast
│   │   │   ├── token.wast
│   │   │   ├── traps.wast
│   │   │   ├── type.wast
│   │   │   ├── unreachable.wast
│   │   │   ├── unreached-invalid.wast
│   │   │   ├── unreached-valid.wast
│   │   │   ├── unwind.wast
│   │   │   ├── utf8-custom-section-id.wast
│   │   │   ├── utf8-import-field.wast
│   │   │   ├── utf8-import-module.wast
│   │   │   └── utf8-invalid-encoding.wast
│   │   └── threads/
│   │       ├── address.wast
│   │       ├── align.wast
│   │       ├── atomic.wast
│   │       ├── binary-leb128.wast
│   │       ├── binary.wast
│   │       ├── block.wast
│   │       ├── br.wast
│   │       ├── br_if.wast
│   │       ├── br_table.wast
│   │       ├── call.wast
│   │       ├── call_indirect.wast
│   │       ├── comments.wast
│   │       ├── const.wast
│   │       ├── conversions.wast
│   │       ├── custom.wast
│   │       ├── data.wast
│   │       ├── elem.wast
│   │       ├── endianness.wast
│   │       ├── exports.wast
│   │       ├── f32.wast
│   │       ├── f32_bitwise.wast
│   │       ├── f32_cmp.wast
│   │       ├── f64.wast
│   │       ├── f64_bitwise.wast
│   │       ├── f64_cmp.wast
│   │       ├── fac.wast
│   │       ├── float_exprs.wast
│   │       ├── float_literals.wast
│   │       ├── float_memory.wast
│   │       ├── float_misc.wast
│   │       ├── forward.wast
│   │       ├── func.wast
│   │       ├── func_ptrs.wast
│   │       ├── global.wast
│   │       ├── i32.wast
│   │       ├── i64.wast
│   │       ├── if.wast
│   │       ├── imports.wast
│   │       ├── inline-module.wast
│   │       ├── int_exprs.wast
│   │       ├── int_literals.wast
│   │       ├── labels.wast
│   │       ├── left-to-right.wast
│   │       ├── linking.wast
│   │       ├── load.wast
│   │       ├── local_get.wast
│   │       ├── local_set.wast
│   │       ├── local_tee.wast
│   │       ├── loop.wast
│   │       ├── memory.wast
│   │       ├── memory_grow.wast
│   │       ├── memory_redundancy.wast
│   │       ├── memory_size.wast
│   │       ├── memory_trap.wast
│   │       ├── names.wast
│   │       ├── nop.wast
│   │       ├── return.wast
│   │       ├── select.wast
│   │       ├── skip-stack-guard-page.wast
│   │       ├── stack.wast
│   │       ├── start.wast
│   │       ├── store.wast
│   │       ├── switch.wast
│   │       ├── table.wast
│   │       ├── thread.wast
│   │       ├── token.wast
│   │       ├── traps.wast
│   │       ├── type.wast
│   │       ├── unreachable.wast
│   │       ├── unreached-invalid.wast
│   │       ├── unwind.wast
│   │       ├── utf8-custom-section-id.wast
│   │       ├── utf8-import-field.wast
│   │       ├── utf8-import-module.wast
│   │       └── utf8-invalid-encoding.wast
│   ├── fuzz/
│   │   ├── CMakeLists.txt
│   │   ├── FuzzTargetCommonMain.h
│   │   ├── ModuleMatcher.h
│   │   ├── fuzz-assemble.cpp
│   │   ├── fuzz-compile-model.cpp
│   │   ├── fuzz-disassemble.cpp
│   │   ├── fuzz-instantiate.cpp
│   │   ├── translate-compile-model-corpus.cpp
│   │   └── wastFuzzDictionary.txt
│   ├── object-cache/
│   │   ├── module_a.wast
│   │   └── module_b.wast
│   ├── wasi/
│   │   ├── cpp/
│   │   │   ├── append.cpp
│   │   │   ├── args.cpp
│   │   │   ├── cat.cpp
│   │   │   ├── clock.cpp
│   │   │   ├── clock_res.cpp
│   │   │   ├── environ.cpp
│   │   │   ├── exit.cpp
│   │   │   ├── fd_fdstat.cpp
│   │   │   ├── fd_filestat_set_size.cpp
│   │   │   ├── fd_filestat_set_times.cpp
│   │   │   ├── fd_renumber.cpp
│   │   │   ├── fd_seek_tell.cpp
│   │   │   ├── fd_sync.cpp
│   │   │   ├── largefile.cpp
│   │   │   ├── ls.cpp
│   │   │   ├── mkdir.cpp
│   │   │   ├── mmap.cpp
│   │   │   ├── mv.cpp
│   │   │   ├── path_filestat_set_times.cpp
│   │   │   ├── preadwrite.cpp
│   │   │   ├── random.cpp
│   │   │   ├── rm.cpp
│   │   │   ├── rmdir.cpp
│   │   │   ├── stat.cpp
│   │   │   ├── stdout.cpp
│   │   │   └── write.cpp
│   │   └── wast/
│   │       ├── fd_read_oob.wast
│   │       ├── fd_write_oob.wast
│   │       └── random_get_oob.wast
│   └── wavm/
│       ├── bulk_memory_ops.wast
│       ├── divide_by_zero_in_try.wast
│       ├── exceptions.wast
│       ├── infinite-recursion.wast
│       ├── issues/
│       │   ├── issue-345.wast
│       │   ├── issue-346.wast
│       │   ├── issue-347.wast
│       │   ├── issue-354.wast
│       │   ├── issue-355.wast
│       │   ├── issue-356.wast
│       │   ├── issue-357.wast
│       │   ├── issue-360.wast
│       │   ├── issue-378.wast
│       │   ├── issue-383.wast
│       │   └── issue-384.wast
│       ├── many_functions.wast
│       ├── misc.wast
│       ├── multi_memory.wast
│       ├── reference_types.wast
│       ├── simd.wast
│       ├── simd_const_simple.wast
│       ├── skip-stack-guard-page.wast
│       ├── syntax_recursion.wast
│       ├── threads.wast
│       ├── trunc_sat.wast
│       ├── wat_custom_section.wast
│       └── wavm_atomic.wast
├── ThirdParty/
│   ├── BLAKE2/
│   │   ├── .gitignore
│   │   ├── CMakeLists.txt
│   │   ├── COPYING
│   │   ├── README.md
│   │   ├── include/
│   │   │   └── blake2.h
│   │   ├── neon/
│   │   │   ├── blake2-impl.h
│   │   │   ├── blake2b-load-neon.h
│   │   │   ├── blake2b-neon.c
│   │   │   ├── blake2b-round.h
│   │   │   ├── blake2b.c
│   │   │   ├── blake2bp.c
│   │   │   ├── blake2s-load-neon.h
│   │   │   ├── blake2s-neon.c
│   │   │   ├── blake2s-round.h
│   │   │   ├── blake2s.c
│   │   │   ├── blake2sp.c
│   │   │   ├── blake2xb.c
│   │   │   └── blake2xs.c
│   │   ├── ref/
│   │   │   ├── blake2-impl.h
│   │   │   ├── blake2b-ref.c
│   │   │   ├── blake2bp-ref.c
│   │   │   ├── blake2s-ref.c
│   │   │   ├── blake2sp-ref.c
│   │   │   ├── blake2xb-ref.c
│   │   │   └── blake2xs-ref.c
│   │   └── sse/
│   │       ├── blake2-config.h
│   │       ├── blake2-impl.h
│   │       ├── blake2b-load-sse2.h
│   │       ├── blake2b-load-sse41.h
│   │       ├── blake2b-round.h
│   │       ├── blake2b.c
│   │       ├── blake2bp.c
│   │       ├── blake2s-load-sse2.h
│   │       ├── blake2s-load-sse41.h
│   │       ├── blake2s-load-xop.h
│   │       ├── blake2s-round.h
│   │       ├── blake2s.c
│   │       ├── blake2sp.c
│   │       ├── blake2xb.c
│   │       └── blake2xs.c
│   ├── Benchmarks/
│   │   ├── ComputerLanguageBenchmarksGame/
│   │   │   ├── LICENSE
│   │   │   ├── binary-trees/
│   │   │   │   └── binary-trees.c
│   │   │   ├── fannkuch-redux/
│   │   │   │   └── fannkuch-redux.c
│   │   │   ├── fasta/
│   │   │   │   └── fasta.c
│   │   │   ├── mandelbrot/
│   │   │   │   └── mandelbrot.c
│   │   │   ├── nbody/
│   │   │   │   └── nbody.c
│   │   │   └── spectral-norm/
│   │   │       └── spectral-norm.c
│   │   └── coremark/
│   │       ├── .github/
│   │       │   └── workflows/
│   │       │       └── c-cpp.yml
│   │       ├── LICENSE.md
│   │       ├── Makefile
│   │       ├── README.md
│   │       ├── barebones/
│   │       │   ├── core_portme.c
│   │       │   ├── core_portme.h
│   │       │   ├── core_portme.mak
│   │       │   ├── cvt.c
│   │       │   └── ee_printf.c
│   │       ├── barebones_porting.md
│   │       ├── core_list_join.c
│   │       ├── core_main.c
│   │       ├── core_matrix.c
│   │       ├── core_state.c
│   │       ├── core_util.c
│   │       ├── coremark.h
│   │       ├── coremark.md5
│   │       ├── cygwin/
│   │       │   └── core_portme.mak
│   │       ├── docs/
│   │       │   ├── READM.md
│   │       │   └── html/
│   │       │       ├── files/
│   │       │       │   ├── PIC32/
│   │       │       │   │   └── core_portme-mak.html
│   │       │       │   ├── core_list_join-c.html
│   │       │       │   ├── core_main-c.html
│   │       │       │   ├── core_matrix-c.html
│   │       │       │   ├── core_state-c.html
│   │       │       │   ├── core_util-c.html
│   │       │       │   ├── coremark-h.html
│   │       │       │   ├── linux/
│   │       │       │   │   ├── core_portme-c.html
│   │       │       │   │   ├── core_portme-h.html
│   │       │       │   │   └── core_portme-mak.html
│   │       │       │   ├── readme-txt.html
│   │       │       │   └── release_notes-txt.html
│   │       │       ├── index/
│   │       │       │   ├── BuildTargets.html
│   │       │       │   ├── Configuration.html
│   │       │       │   ├── Configurations.html
│   │       │       │   ├── Files.html
│   │       │       │   ├── Functions.html
│   │       │       │   ├── General.html
│   │       │       │   ├── General2.html
│   │       │       │   ├── Types.html
│   │       │       │   └── Variables.html
│   │       │       ├── index.html
│   │       │       ├── javascript/
│   │       │       │   ├── main.js
│   │       │       │   └── searchdata.js
│   │       │       ├── search/
│   │       │       │   ├── BuildTargetsP.html
│   │       │       │   ├── ConfigurationC.html
│   │       │       │   ├── ConfigurationH.html
│   │       │       │   ├── ConfigurationM.html
│   │       │       │   ├── ConfigurationS.html
│   │       │       │   ├── ConfigurationT.html
│   │       │       │   ├── ConfigurationU.html
│   │       │       │   ├── ConfigurationsH.html
│   │       │       │   ├── ConfigurationsM.html
│   │       │       │   ├── ConfigurationsS.html
│   │       │       │   ├── ConfigurationsT.html
│   │       │       │   ├── FilesC.html
│   │       │       │   ├── FilesR.html
│   │       │       │   ├── FunctionsC.html
│   │       │       │   ├── FunctionsG.html
│   │       │       │   ├── FunctionsI.html
│   │       │       │   ├── FunctionsM.html
│   │       │       │   ├── FunctionsP.html
│   │       │       │   ├── FunctionsS.html
│   │       │       │   ├── FunctionsT.html
│   │       │       │   ├── GeneralB.html
│   │       │       │   ├── GeneralC.html
│   │       │       │   ├── GeneralD.html
│   │       │       │   ├── GeneralF.html
│   │       │       │   ├── GeneralG.html
│   │       │       │   ├── GeneralH.html
│   │       │       │   ├── GeneralI.html
│   │       │       │   ├── GeneralL.html
│   │       │       │   ├── GeneralM.html
│   │       │       │   ├── GeneralO.html
│   │       │       │   ├── GeneralP.html
│   │       │       │   ├── GeneralR.html
│   │       │       │   ├── GeneralS.html
│   │       │       │   ├── GeneralT.html
│   │       │       │   ├── GeneralU.html
│   │       │       │   ├── GeneralV.html
│   │       │       │   ├── GeneralW.html
│   │       │       │   ├── NoResults.html
│   │       │       │   ├── TypesS.html
│   │       │       │   ├── VariablesC.html
│   │       │       │   ├── VariablesD.html
│   │       │       │   ├── VariablesL.html
│   │       │       │   ├── VariablesO.html
│   │       │       │   ├── VariablesP.html
│   │       │       │   ├── VariablesR.html
│   │       │       │   └── VariablesS.html
│   │       │       └── styles/
│   │       │           ├── 1.css
│   │       │           ├── 2.css
│   │       │           └── main.css
│   │       ├── freebsd/
│   │       │   └── core_portme.mak
│   │       ├── linux/
│   │       │   └── core_portme.mak
│   │       ├── macos/
│   │       │   └── core_portme.mak
│   │       ├── posix/
│   │       │   ├── core_portme.c
│   │       │   ├── core_portme.h
│   │       │   ├── core_portme.mak
│   │       │   └── core_portme_posix_overrides.h
│   │       ├── rtems/
│   │       │   ├── core_portme.mak
│   │       │   └── init.c
│   │       ├── simple/
│   │       │   ├── core_portme.c
│   │       │   ├── core_portme.h
│   │       │   └── core_portme.mak
│   │       └── zephyr/
│   │           └── module.yml
│   ├── liblmdb/
│   │   ├── .gitignore
│   │   ├── CMakeLists.txt
│   │   ├── COPYRIGHT
│   │   ├── Doxyfile
│   │   ├── LICENSE
│   │   ├── Makefile
│   │   ├── intro.doc
│   │   ├── lmdb.h
│   │   ├── mdb.c
│   │   ├── mdb_copy.1
│   │   ├── mdb_copy.c
│   │   ├── mdb_drop.1
│   │   ├── mdb_drop.c
│   │   ├── mdb_dump.1
│   │   ├── mdb_dump.c
│   │   ├── mdb_load.1
│   │   ├── mdb_load.c
│   │   ├── mdb_stat.1
│   │   ├── mdb_stat.c
│   │   ├── midl.c
│   │   ├── midl.h
│   │   ├── mtest.c
│   │   ├── mtest2.c
│   │   ├── mtest3.c
│   │   ├── mtest4.c
│   │   ├── mtest5.c
│   │   ├── mtest6.c
│   │   ├── sample-bdb.txt
│   │   ├── sample-mdb.txt
│   │   └── tooltag
│   └── libunwind/
│       ├── .arcconfig
│       ├── .clang-format
│       ├── CMakeLists.txt
│       ├── LICENSE.TXT
│       ├── PROVENANCE.txt
│       ├── cmake/
│       │   ├── Modules/
│       │   │   └── HandleLibunwindFlags.cmake
│       │   └── config-ix.cmake
│       ├── docs/
│       │   ├── BuildingLibunwind.rst
│       │   ├── CMakeLists.txt
│       │   ├── README.txt
│       │   ├── conf.py
│       │   └── index.rst
│       ├── include/
│       │   ├── CMakeLists.txt
│       │   ├── __libunwind_config.h
│       │   ├── libunwind.h
│       │   ├── libunwind.modulemap
│       │   ├── mach-o/
│       │   │   └── compact_unwind_encoding.h
│       │   ├── unwind.h
│       │   ├── unwind_arm_ehabi.h
│       │   └── unwind_itanium.h
│       ├── src/
│       │   ├── AddressSpace.hpp
│       │   ├── CMakeLists.txt
│       │   ├── CompactUnwinder.hpp
│       │   ├── DwarfInstructions.hpp
│       │   ├── DwarfParser.hpp
│       │   ├── EHHeaderParser.hpp
│       │   ├── FrameHeaderCache.hpp
│       │   ├── RWMutex.hpp
│       │   ├── Registers.hpp
│       │   ├── Unwind-EHABI.cpp
│       │   ├── Unwind-EHABI.h
│       │   ├── Unwind-seh.cpp
│       │   ├── Unwind-sjlj.c
│       │   ├── Unwind-wasm.c
│       │   ├── UnwindCursor.hpp
│       │   ├── UnwindLevel1-gcc-ext.c
│       │   ├── UnwindLevel1.c
│       │   ├── UnwindRegistersRestore.S
│       │   ├── UnwindRegistersSave.S
│       │   ├── Unwind_AIXExtras.cpp
│       │   ├── assembly.h
│       │   ├── config.h
│       │   ├── dwarf2.h
│       │   ├── libunwind.cpp
│       │   ├── libunwind_ext.h
│       │   └── shadow_stack_unwind.h
│       └── test/
│           ├── CMakeLists.txt
│           ├── aix_runtime_link.pass.cpp
│           ├── aix_signal_unwind.pass.sh.S
│           ├── alignment.compile.pass.cpp
│           ├── bad_unwind_info.pass.cpp
│           ├── configs/
│           │   ├── apple-libunwind-system.cfg.in
│           │   ├── armv7m-picolibc-libunwind.cfg.in
│           │   ├── cmake-bridge.cfg.in
│           │   ├── ibm-libunwind-shared.cfg.in
│           │   ├── llvm-libunwind-merged.cfg.in
│           │   ├── llvm-libunwind-shared-mingw.cfg.in
│           │   ├── llvm-libunwind-shared.cfg.in
│           │   ├── llvm-libunwind-static-mingw.cfg.in
│           │   └── llvm-libunwind-static.cfg.in
│           ├── floatregister.pass.cpp
│           ├── forceunwind.pass.cpp
│           ├── frameheadercache_test.pass.cpp
│           ├── libunwind_01.pass.cpp
│           ├── libunwind_02.pass.cpp
│           ├── lit.cfg.py
│           ├── remember_state_leak.pass.sh.s
│           ├── signal_frame.pass.cpp
│           ├── signal_unwind.pass.cpp
│           ├── unw_getcontext.pass.cpp
│           ├── unw_resume.pass.cpp
│           ├── unwind_leaffunction.pass.cpp
│           └── unwind_scalable_vectors.pass.cpp
├── VERSION
├── WebAssembly.tmLanguage
├── cmake/
│   ├── DetectSyncPrimitiveSizes.cmake
│   └── DetectUnwindStateSizes.cmake
└── vs-chromium-project.txt

SYMBOL INDEX (3921 symbols across 376 files)

FILE: Build/dev.py
  function get_default_work_dir (line 26) | def get_default_work_dir() -> Path:
  function init_work_dir (line 33) | def init_work_dir(work_dir: Path) -> Path:
  function main (line 40) | def main() -> int:

FILE: Build/lib/benchmark.py
  class BenchmarkProgram (line 28) | class BenchmarkProgram:
  function get_benchmark_test_defs (line 79) | def get_benchmark_test_defs() -> list[TestDef]:
  class BenchmarkSource (line 108) | class BenchmarkSource:
  function _clbg_source (line 118) | def _clbg_source(name: str, extra_flags: Optional[list[str]] = None) -> ...
  class CompileBenchmarkTask (line 162) | class CompileBenchmarkTask(Task):
    method __init__ (line 165) | def __init__(
    method run (line 180) | def run(self) -> TaskResult:
  function setup_benchmark_compile_tasks (line 220) | def setup_benchmark_compile_tasks(
  function _mean (line 248) | def _mean(values: list[float]) -> float:
  function _stddev (line 254) | def _stddev(values: list[float]) -> float:
  function _run_file_benchmark_once (line 267) | def _run_file_benchmark_once(
  function _extract_json_from_output (line 325) | def _extract_json_from_output(text: str) -> Optional[str]:
  function _get_results_dir (line 355) | def _get_results_dir(work_dir: Path) -> Path:
  function save_results (line 359) | def save_results(work_dir: Path, name: str, results: dict) -> Path:
  function load_results (line 369) | def load_results(work_dir: Path, name: str) -> Optional[dict]:
  function list_saved_results (line 382) | def list_saved_results(work_dir: Path) -> list[str]:
  function _format_val (line 395) | def _format_val(mean: float, std: float, unit: str) -> str:
  function _format_delta (line 404) | def _format_delta(delta: float, pct: float, unit: str) -> str:
  function _is_regression (line 409) | def _is_regression(pct: float) -> bool:
  function _is_improvement (line 413) | def _is_improvement(pct: float) -> bool:
  function _ansi_red (line 417) | def _ansi_red(s: str) -> str:
  function _ansi_green (line 421) | def _ansi_green(s: str) -> str:
  function _colorize_delta (line 425) | def _colorize_delta(delta_str: str, pct: float, interactive: bool) -> str:
  function _geometric_mean (line 444) | def _geometric_mean(values: list[float]) -> float:
  function _per_run_geometric_means (line 452) | def _per_run_geometric_means(
  function print_results (line 475) | def print_results(results: dict) -> None:
  function print_comparison (line 511) | def print_comparison(current: dict, baseline: dict) -> None:
  function _print_comparison_row (line 560) | def _print_comparison_row(
  function _get_wavm_version (line 588) | def _get_wavm_version(source_dir: Path) -> str:
  function run_benchmarks (line 595) | def run_benchmarks(
  function cmd_benchmark (line 677) | def cmd_benchmark(args: argparse.Namespace, ctx: CommandContext) -> int:
  function cmd_benchmark_compile (line 728) | def cmd_benchmark_compile(args: argparse.Namespace, ctx: CommandContext)...
  function register_benchmark_commands (line 751) | def register_benchmark_commands(subparsers: argparse._SubParsersAction) ...

FILE: Build/lib/build.py
  class WAVMConfigTemplate (line 39) | class WAVMConfigTemplate:
  class WAVMConfig (line 61) | class WAVMConfig:
  function get_build_stamp (line 158) | def get_build_stamp(config_hash: str, llvm_commit: str) -> str:
  function read_build_stamp (line 163) | def read_build_stamp(build_dir: Path) -> Optional[str]:
  function write_build_stamp (line 171) | def write_build_stamp(build_dir: Path, stamp: str) -> None:
  function hash_config (line 177) | def hash_config(cmake_args: list[str]) -> str:
  function get_config_string (line 183) | def get_config_string(cmake_args: list[str]) -> str:
  function needs_cmake_configure (line 188) | def needs_cmake_configure(build_dir: Path, cmake_args: list[str]) -> bool:
  function write_cmake_config_args (line 214) | def write_cmake_config_args(build_dir: Path, cmake_args: list[str]) -> N...
  function get_applicable_wavm_configs (line 227) | def get_applicable_wavm_configs() -> list[WAVMConfig]:
  function find_wavm_config (line 304) | def find_wavm_config(config_name: str) -> tuple[Optional[WAVMConfig], li...
  function get_lint_config (line 314) | def get_lint_config() -> WAVMConfig:
  function needs_aslr_workaround (line 330) | def needs_aslr_workaround(config: WAVMConfig) -> bool:
  class ConfigureWAVMTask (line 349) | class ConfigureWAVMTask(Task):
    method __init__ (line 352) | def __init__(
    method run (line 379) | def run(self) -> TaskResult:
  class BuildWAVMTask (line 434) | class BuildWAVMTask(Task):
    method __init__ (line 437) | def __init__(
    method run (line 456) | def run(self) -> TaskResult:
  function create_wavm_configure_task (line 466) | def create_wavm_configure_task(
  function create_wavm_build_tasks (line 500) | def create_wavm_build_tasks(
  function build_single_config (line 526) | def build_single_config(
  function cmd_list_configs (line 572) | def cmd_list_configs(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_list_configs (line 581) | def register_list_configs(subparsers: argparse._SubParsersAction) -> None:
  function cmd_package (line 587) | def cmd_package(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_package (line 623) | def register_package(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/context.py
  class CommandContext (line 8) | class CommandContext:

FILE: Build/lib/coverage.py
  function find_coverage_tool (line 15) | def find_coverage_tool(tool_name: str, llvm_toolchain_task: Optional[Tas...
  function find_instrumented_binaries (line 35) | def find_instrumented_binaries(build_dir: Path) -> list[Path]:
  class CoverageReportTask (line 66) | class CoverageReportTask(Task):
    method __init__ (line 69) | def __init__(
    method run (line 93) | def run(self) -> TaskResult:
  function merge_lcov_files (line 217) | def merge_lcov_files(lcov_paths: list[Path], output_path: Path) -> None:
  function cmd_merge_coverage (line 262) | def cmd_merge_coverage(args: argparse.Namespace, ctx: CommandContext) ->...
  function register_merge_coverage (line 296) | def register_merge_coverage(subparsers: argparse._SubParsersAction) -> N...

FILE: Build/lib/cpp_files.py
  function discover_cpp_files (line 7) | def discover_cpp_files(source_dir: Path) -> list[Path]:

FILE: Build/lib/format.py
  class ClangFormatTask (line 15) | class ClangFormatTask(Task):
    method __init__ (line 18) | def __init__(
    method run (line 38) | def run(self) -> TaskResult:
  class DiscoverFormatFilesTask (line 102) | class DiscoverFormatFilesTask(Task):
    method __init__ (line 105) | def __init__(
    method run (line 121) | def run(self) -> TaskResult:
  function create_format_tasks (line 142) | def create_format_tasks(
  function cmd_format (line 166) | def cmd_format(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_format (line 175) | def register_format(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/fuzz.py
  class FuzzerConfig (line 26) | class FuzzerConfig:
  function get_libfuzzer_config (line 75) | def get_libfuzzer_config() -> WAVMConfig:
  function build_libfuzzer (line 95) | def build_libfuzzer(
  function generate_seed_corpus (line 123) | def generate_seed_corpus(
  function _count_files (line 169) | def _count_files(dir_path: Path) -> int:
  function run_fuzzer (line 176) | def run_fuzzer(
  function translate_compile_model_corpus (line 270) | def translate_compile_model_corpus(build_dir: Path, fuzz_dir: Path) -> N...
  function reduce_corpus (line 303) | def reduce_corpus(fc: FuzzerConfig, build_dir: Path, fuzz_dir: Path) -> ...
  function _needs_seed_corpus (line 343) | def _needs_seed_corpus(fuzz_dir: Path) -> bool:
  function _resolve_targets (line 350) | def _resolve_targets(target_list: Optional[list[str]]) -> list[str]:
  function _snapshot_corpus_counts (line 364) | def _snapshot_corpus_counts(fuzz_dir: Path, targets: list[str]) -> dict[...
  function _print_final_report (line 372) | def _print_final_report(
  function cmd_fuzz (line 407) | def cmd_fuzz(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_fuzz_commands (line 494) | def register_fuzz_commands(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/lint.py
  class PythonLintTask (line 14) | class PythonLintTask(Task):
    method __init__ (line 17) | def __init__(self, source_dir: Path, tool: str, args: list[str]):
    method run (line 26) | def run(self) -> TaskResult:
  function create_lint_tasks (line 36) | def create_lint_tasks(
  function cmd_lint (line 63) | def cmd_lint(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_lint (line 69) | def register_lint(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/llvm.py
  class LLVMConfig (line 19) | class LLVMConfig:
  function get_applicable_llvm_configs (line 43) | def get_applicable_llvm_configs() -> list[LLVMConfig]:
  function get_platform_name (line 69) | def get_platform_name() -> str:
  function _get_release_tag_for_commit (line 85) | def _get_release_tag_for_commit(commit_hash: str) -> str:
  function get_llvm_download_url (line 90) | def get_llvm_download_url(release_tag: str, config_name: str) -> str:
  class CloneWAVMLLVMTask (line 103) | class CloneWAVMLLVMTask(Task):
    method __init__ (line 113) | def __init__(self, scratch_dir: Path, offline: bool = False):
    method run (line 121) | def run(self) -> TaskResult:
  class DownloadLLVMTask (line 178) | class DownloadLLVMTask(Task):
    method __init__ (line 185) | def __init__(
    method run (line 201) | def run(self) -> TaskResult:
  class UseLocalLLVMTask (line 236) | class UseLocalLLVMTask(Task):
    method __init__ (line 239) | def __init__(self, config: LLVMConfig, scratch_dir: Path):
    method run (line 248) | def run(self) -> TaskResult:
  class BuildLLVMTask (line 260) | class BuildLLVMTask(Task):
    method __init__ (line 270) | def __init__(
    method run (line 293) | def run(self) -> TaskResult:
  class _LLVMState (line 332) | class _LLVMState:
  function _init_llvm (line 341) | def _init_llvm(
  function get_llvm_task (line 357) | def get_llvm_task(
  function get_llvm_toolchain_task (line 402) | def get_llvm_toolchain_task(

FILE: Build/lib/output.py
  class Output (line 8) | class Output:
    method __init__ (line 11) | def __init__(self) -> None:
    method _get_terminal_width (line 20) | def _get_terminal_width(self) -> int:
    method _write_atomic (line 26) | def _write_atomic(self, data: str, file: io.TextIOWrapper) -> None:
    method _build_clear (line 35) | def _build_clear(self) -> str:
    method _build_status (line 42) | def _build_status(self, lines: list[str]) -> str:
    method status (line 54) | def status(self, *lines: str) -> None:
    method clear_status (line 68) | def clear_status(self) -> None:
    method print (line 76) | def print(self, msg: str) -> None:
    method error (line 86) | def error(self, msg: str) -> None:
    method verbose (line 92) | def verbose(self, msg: str) -> None:

FILE: Build/lib/platform.py
  function get_wavm_bin_path (line 52) | def get_wavm_bin_path(build_dir: Union[str, Path]) -> Path:
  function find_vcvarsall (line 62) | def find_vcvarsall() -> Optional[Path]:
  function get_host_arch (line 89) | def get_host_arch() -> str:
  function set_target_arch (line 136) | def set_target_arch(arch: str) -> None:
  function get_target_arch (line 144) | def get_target_arch() -> str:
  function is_cross_compiling (line 149) | def is_cross_compiling() -> bool:
  function is_rosetta (line 154) | def is_rosetta() -> bool:
  function get_cross_compile_cmake_args (line 159) | def get_cross_compile_cmake_args() -> list[str]:
  function get_build_dir (line 167) | def get_build_dir(work_dir: Path, subdir: str, config_name: str) -> Path:
  function init_env (line 182) | def init_env() -> None:
  function _decode_text (line 259) | def _decode_text(data: bytes) -> str:
  class CommandResult (line 264) | class CommandResult:
    method __init__ (line 267) | def __init__(
    method from_completed (line 290) | def from_completed(
    method from_timeout (line 307) | def from_timeout(
    method output (line 333) | def output(self) -> str:
    method format_failure (line 342) | def format_failure(
    method _format_reproducible_command (line 373) | def _format_reproducible_command(self) -> str:
    method _format_posix_command (line 380) | def _format_posix_command(self) -> str:
    method _format_windows_command (line 398) | def _format_windows_command(self) -> str:
    method _get_extra_env_vars (line 422) | def _get_extra_env_vars(self) -> list[tuple[str, str]]:
  function run_command (line 433) | def run_command(
  function _download_with_retry (line 469) | def _download_with_retry(url: str, dest: Path) -> None:
  function download_and_extract (line 485) | def download_and_extract(url: str, dest_dir: Path) -> None:
  function get_compiler_major_version (line 529) | def get_compiler_major_version(
  function get_gcc_clang_major_version (line 547) | def get_gcc_clang_major_version(compiler: str) -> Optional[int]:
  function get_msvc_major_version (line 552) | def get_msvc_major_version() -> Optional[int]:

FILE: Build/lib/run.py
  function cmd_run (line 12) | def cmd_run(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_run (line 42) | def register_run(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/task_graph.py
  class TaskState (line 15) | class TaskState(Enum):
  class TaskResult (line 28) | class TaskResult:
  class Task (line 38) | class Task:
    method __init__ (line 41) | def __init__(
    method run (line 56) | def run(self) -> TaskResult:
  function _format_duration (line 66) | def _format_duration(seconds: float) -> str:
  function _update_states (line 71) | def _update_states(tasks: list[Task]) -> None:
  function _get_ready_tasks (line 102) | def _get_ready_tasks(tasks: list[Task]) -> list[Task]:
  function _update_status (line 109) | def _update_status(tasks: list[Task], start_time: float) -> None:
  function execute (line 160) | def execute(demanded_tasks: list[Task], suppress_summary: bool = False) ...

FILE: Build/lib/test.py
  function _wavm_version_expected_output (line 61) | def _wavm_version_expected_output() -> str:
  function get_tests (line 77) | def get_tests() -> list[TestDef]:
  class WASTTestDir (line 358) | class WASTTestDir:
  class TestHistoryEntry (line 429) | class TestHistoryEntry:
  function load_test_history (line 450) | def load_test_history(scratch_dir: Path) -> None:
  function save_test_history (line 469) | def save_test_history() -> None:
  function update_test_history (line 486) | def update_test_history(
  function get_test_priority (line 495) | def get_test_priority(config_name: str, test_name: str) -> tuple[int, fl...
  function is_gdb_available (line 520) | def is_gdb_available() -> bool:
  class RunTestTask (line 525) | class RunTestTask(Task):
    method __init__ (line 528) | def __init__(
    method run (line 557) | def run(self) -> TaskResult:
    method _run_steps (line 577) | def _run_steps(self, context: TestContext) -> TestResult:
  class DiscoverWASTTestsTask (line 587) | class DiscoverWASTTestsTask(Task):
    method __init__ (line 590) | def __init__(self, source_dir: Path, trace_tests: bool = False):
    method run (line 611) | def run(self) -> TaskResult:
  class CloneFuzzCorporaTask (line 655) | class CloneFuzzCorporaTask(Task):
    method __init__ (line 658) | def __init__(self, working_dir: Path, offline: bool = False):
    method run (line 668) | def run(self) -> TaskResult:
  class CreateTestTasksTask (line 696) | class CreateTestTasksTask(Task):
    method __init__ (line 699) | def __init__(
    method run (line 733) | def run(self) -> TaskResult:
  function setup_test_tasks (line 837) | def setup_test_tasks(
  function cmd_test (line 919) | def cmd_test(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_test (line 983) | def register_test(subparsers: argparse._SubParsersAction) -> None:
  function cmd_test_install (line 998) | def cmd_test_install(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_test_install (line 1026) | def register_test_install(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/test_def.py
  class TestContext (line 16) | class TestContext:
  class TestResult (line 29) | class TestResult:
  class TestStep (line 37) | class TestStep:
    method run (line 52) | def run(
  class TestDef (line 137) | class TestDef:

FILE: Build/lib/tidy.py
  class ClangTidyTask (line 16) | class ClangTidyTask(Task):
    method __init__ (line 19) | def __init__(
    method run (line 40) | def run(self) -> TaskResult:
  class DiscoverTidyFilesTask (line 70) | class DiscoverTidyFilesTask(Task):
    method __init__ (line 73) | def __init__(
    method run (line 92) | def run(self) -> TaskResult:
  function create_tidy_tasks (line 126) | def create_tidy_tasks(
  function cmd_tidy (line 152) | def cmd_tidy(args: argparse.Namespace, ctx: CommandContext) -> int:
  function register_tidy (line 171) | def register_tidy(subparsers: argparse._SubParsersAction) -> None:

FILE: Build/lib/toolchain.py
  class CMakeVarArg (line 64) | class CMakeVarArg:
    method to_arg (line 70) | def to_arg(self) -> str:
  function build_cmake_cmd (line 76) | def build_cmake_cmd(args: list[Union[str, Path, CMakeVarArg]]) -> list[s...
  function is_command_available (line 98) | def is_command_available(command: str) -> bool:
  class ToolchainScope (line 103) | class ToolchainScope(Enum):
  function _get_wavm_llvm_compiler_cmake_args (line 110) | def _get_wavm_llvm_compiler_cmake_args(llvm_dir: Path) -> list[CMakeVarA...
  function _get_wavm_llvm_linker_cmake_args (line 135) | def _get_wavm_llvm_linker_cmake_args(llvm_dir: Path) -> list[CMakeVarArg]:
  function _get_wavm_llvm_all_cmake_args (line 143) | def _get_wavm_llvm_all_cmake_args(llvm_dir: Path) -> list[CMakeVarArg]:
  class Toolchain (line 148) | class Toolchain:
    method __init__ (line 156) | def __init__(
    method identity (line 174) | def identity(self) -> str:
    method lto_mode (line 183) | def lto_mode(self) -> str:
    method supports_coverage (line 195) | def supports_coverage(self) -> bool:
    method get_or_create_prerequisite_tasks (line 198) | def get_or_create_prerequisite_tasks(
    method get_cmake_args (line 216) | def get_cmake_args(self) -> list[CMakeVarArg]:
  function detect_toolchains (line 235) | def detect_toolchains() -> list[Toolchain]:
  function get_primary_toolchain (line 360) | def get_primary_toolchain(compiler: str) -> Toolchain:

FILE: Build/lib/wasi.py
  function get_wasi_sdk_platform (line 20) | def get_wasi_sdk_platform() -> str:
  class DownloadWasiSdkTask (line 40) | class DownloadWasiSdkTask(Task):
    method __init__ (line 43) | def __init__(self, working_dir: Path, offline: bool = False):
    method run (line 52) | def run(self) -> TaskResult:
  class CompileWasiTestTask (line 96) | class CompileWasiTestTask(Task):
    method __init__ (line 99) | def __init__(self, cpp_file: Path, output_dir: Path, wasi_sdk_task: Do...
    method run (line 109) | def run(self) -> TaskResult:

FILE: Build/lib/workspace.py
  function _add_unique (line 16) | def _add_unique(items: list[str], value: str) -> None:
  function generate_workspace_file (line 22) | def generate_workspace_file(
  function cmd_setup_workspace (line 72) | def cmd_setup_workspace(args: argparse.Namespace, ctx: CommandContext) -...
  function register_setup_workspace (line 103) | def register_setup_workspace(subparsers: argparse._SubParsersAction) -> ...

FILE: Examples/embedder/c/embedder-example.c
  function handle_trap (line 13) | static void handle_trap(wasm_trap_t* trap)
  function own (line 30) | static own wasm_trap_t* hello_callback(const wasm_val_t args[], wasm_val...
  function main (line 64) | int main(int argc, char** argv)

FILE: Examples/embedder/cpp-wasi/embedder-example.cpp
  function readFile (line 27) | static bool readFile(const char* path, std::vector<U8>& outBytes)
  function main (line 78) | int main(int argc, char** argv)

FILE: Examples/embedder/cpp/embedder-example.cpp
  function main (line 31) | int main(int argc, char** argv)

FILE: Include/WAVM/DWARF/Constants.h
  function namespace (line 5) | namespace WAVM { namespace DWARF {

FILE: Include/WAVM/DWARF/DWARF.h
  function namespace (line 6) | namespace WAVM { namespace DWARF {

FILE: Include/WAVM/DWARF/Sections.h
  function namespace (line 5) | namespace WAVM { namespace DWARF {

FILE: Include/WAVM/IR/FeatureSpec.h
  function namespace (line 55) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/IR.h
  function namespace (line 7) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/Module.h
  function namespace (line 14) | namespace WAVM { namespace IR {
  type InitializerExpressionBase (line 92) | typedef InitializerExpressionBase<Uptr> InitializerExpression;
  type FunctionDef (line 95) | struct FunctionDef
  type TableDef (line 104) | struct TableDef
  type MemoryDef (line 110) | struct MemoryDef
  type GlobalDef (line 116) | struct GlobalDef
  type ExceptionTypeDef (line 123) | struct ExceptionTypeDef
  type Import (line 136) | typedef Import<IndexedFunctionType> FunctionImport;
  type Import (line 137) | typedef Import<TableType> TableImport;
  type Import (line 138) | typedef Import<MemoryType> MemoryImport;
  type Import (line 139) | typedef Import<GlobalType> GlobalImport;
  type Import (line 140) | typedef Import<ExceptionType> ExceptionTypeImport;
  type Export (line 143) | struct Export
  type KindAndIndex (line 154) | struct KindAndIndex
  type DataSegment (line 167) | struct DataSegment
  function switch (line 176) | struct ElemExpr
  type ElemSegment (line 234) | struct ElemSegment
  function OrderedSectionID (line 270) | enum class OrderedSectionID : U8

FILE: Include/WAVM/IR/OperatorPrinter.h
  function namespace (line 10) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/OperatorSignatures.h
  function namespace (line 10) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/Operators.h
  function namespace (line 12) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/RandomModule.h
  function namespace (line 3) | namespace WAVM {
  function namespace (line 7) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/Types.h
  function namespace (line 13) | namespace WAVM { namespace Runtime {
  function namespace (line 18) | namespace WAVM { namespace IR {
  function std (line 552) | inline std::string asString(const GlobalType& globalType)
  type ExceptionType (line 561) | struct ExceptionType
  function std (line 575) | inline std::string asString(const ExceptionType& exceptionType)
  function ExternKind (line 581) | enum class ExternKind : U8
  function std (line 644) | inline std::string asString(const ExternType& objectType)
  function ReferenceType (line 660) | inline ReferenceType asReferenceType(const ExternKind kind)
  function ReferenceType (line 675) | inline ReferenceType asReferenceType(const ExternType& type)
  function namespace (line 684) | namespace WAVM {
  function FunctionType (line 693) | struct Hash<IR::FunctionType>

FILE: Include/WAVM/IR/Validate.h
  function namespace (line 7) | namespace WAVM { namespace IR {

FILE: Include/WAVM/IR/Value.h
  function namespace (line 11) | namespace WAVM { namespace Runtime {
  function namespace (line 16) | namespace WAVM { namespace IR {
  function UntaggedValue (line 48) | struct Value : UntaggedValue
  function std (line 118) | inline std::string asString(const std::vector<Value>& values)

FILE: Include/WAVM/Inline/BasicTypes.h
  function namespace (line 8) | namespace WAVM {

FILE: Include/WAVM/Inline/CLI.h
  function namespace (line 15) | namespace WAVM {

FILE: Include/WAVM/Inline/DenseStaticIntSet.h
  function namespace (line 8) | namespace WAVM {

FILE: Include/WAVM/Inline/Errors.h
  function namespace (line 6) | namespace WAVM { namespace Errors {

FILE: Include/WAVM/Inline/FixedString.h
  function namespace (line 6) | namespace WAVM {
  function assign (line 36) | void assign(const char* str, Uptr len)
  function operator (line 44) | operator const char*() const { return data; }
  function Uptr (line 52) | static constexpr Uptr capacity() { return N; }

FILE: Include/WAVM/Inline/FloatComponents.h
  function namespace (line 5) | namespace WAVM {

FILE: Include/WAVM/Inline/Hash.h
  function namespace (line 17) | namespace WAVM {
  function I8 (line 73) | struct Hash<I8>
  function I16 (line 81) | struct Hash<I16>
  function I32 (line 89) | struct Hash<I32>
  function I64 (line 97) | struct Hash<I64>
  function string_view (line 110) | struct Hash<std::string_view>
  function areKeysEqual (line 130) | static bool areKeysEqual(const Key& left, const Key& right) { return lef...
  function Uptr (line 131) | static Uptr getKeyHash(const Key& key) { return Hash<Key>()(key); }
  function string (line 134) | struct DefaultHashPolicy<std::string>

FILE: Include/WAVM/Inline/HashMap.h
  function namespace (line 13) | namespace WAVM {

FILE: Include/WAVM/Inline/HashSet.h
  function namespace (line 13) | namespace WAVM {

FILE: Include/WAVM/Inline/HashTable.h
  function namespace (line 11) | namespace WAVM {
  function Bucket (line 133) | Bucket* getBuckets() const { return buckets; }

FILE: Include/WAVM/Inline/I128.h
  function namespace (line 13) | namespace WAVM {

FILE: Include/WAVM/Inline/Impl/HashMapImpl.h
  function namespace (line 14) | namespace WAVM {

FILE: Include/WAVM/Inline/Impl/HashSetImpl.h
  function namespace (line 13) | namespace WAVM {

FILE: Include/WAVM/Inline/Impl/HashTableImpl.h
  function namespace (line 13) | namespace WAVM {
  function Element (line 245) | Element evictedElement{std::move(evictedBucket.storage.get())};

FILE: Include/WAVM/Inline/Impl/I128Impl.h
  function namespace (line 52) | namespace WAVM {
  function I128 (line 209) | inline I128 abs(I128 a)
  function addAndCheckOverflow (line 222) | inline bool addAndCheckOverflow(I128 a, I128 b, I128* out)
  function I128 (line 240) | inline I128 addmod127(I128 a, I128 b)
  function mulAndCheckOverflow (line 256) | inline bool mulAndCheckOverflow(I128 a, I128 b, I128* out)
  function I128 (line 322) | inline I128 mulmod127(I128 a, I128 b)
  function I128 (line 329) | inline I128 operator*(I128 a, I128 b)
  function I128 (line 473) | inline I128 I128::udivmod(I128 n, I128 d, I128& outRemainder)
  function ToCharsResult (line 651) | inline ToCharsResult toChars(char* outBegin, char* outEnd, I128 value)

FILE: Include/WAVM/Inline/Impl/OptionalStorage.h
  function namespace (line 7) | namespace WAVM {
  function destruct (line 45) | void destruct() {}
  function namespace (line 62) | namespace OptionalStorageAssertions {

FILE: Include/WAVM/Inline/IndexMap.h
  function namespace (line 7) | namespace WAVM {
  function removeOrFail (line 55) | void removeOrFail(Index index)
  function contains (line 63) | bool contains(Index index) const
  function Element (line 72) | const Element& operator[](Index index) const
  function Element (line 88) | const Element* get(Index index) const
  function Element (line 94) | Element* get(Index index)
  type Iterator (line 107) | struct Iterator

FILE: Include/WAVM/Inline/InlineArray.h
  function namespace (line 8) | namespace WAVM {
  function Element (line 51) | const Element& operator[](Uptr index) const
  function Iterator (line 82) | Iterator end() { return Iterator{elements + numElements}; }

FILE: Include/WAVM/Inline/IntCasts.h
  function namespace (line 8) | namespace WAVM {

FILE: Include/WAVM/Inline/IntrusiveSharedPtr.h
  function namespace (line 3) | namespace WAVM {
  function operator (line 66) | constexpr operator Pointee*() const { return value; }
  type AdoptConstructorSelector (line 73) | enum AdoptConstructorSelector
  function IntrusiveSharedPtr (line 78) | constexpr IntrusiveSharedPtr(AdoptConstructorSelector, Pointee* inValue)...

FILE: Include/WAVM/Inline/IsNameChar.h
  function namespace (line 3) | namespace WAVM {

FILE: Include/WAVM/Inline/LEB128.h
  function namespace (line 12) | namespace WAVM { namespace Serialization {

FILE: Include/WAVM/Inline/RandomStream.h
  function namespace (line 7) | namespace WAVM {

FILE: Include/WAVM/Inline/Serialization.h
  function namespace (line 13) | namespace WAVM { namespace Serialization {
  function U8 (line 105) | inline const U8* peek(Uptr numBytes)
  function U8 (line 113) | inline const U8* tryAdvance(Uptr numBytes)
  function InputStream (line 145) | struct MemoryInputStream : InputStream

FILE: Include/WAVM/Inline/StringBuilder.h
  function namespace (line 15) | namespace WAVM {
  function StringBuilderBase (line 146) | struct StringBuilder : StringBuilderBase
  function virtual (line 206) | virtual bool extendBuffer(Uptr numChars) override

FILE: Include/WAVM/Inline/Time.h
  function namespace (line 5) | namespace WAVM {
  function friend (line 11) | friend bool isInfinity(Time time) { return isNaN(time.ns); }

FILE: Include/WAVM/Inline/Timing.h
  function namespace (line 9) | namespace WAVM { namespace Timing {

FILE: Include/WAVM/Inline/UnalignedArrayView.h
  function namespace (line 8) | namespace WAVM {

FILE: Include/WAVM/Inline/Unicode.h
  function namespace (line 6) | namespace WAVM { namespace Unicode {

FILE: Include/WAVM/Inline/xxhash/xxh3.h
  type xxh_u64x2 (line 366) | typedef __vector unsigned long long xxh_u64x2;
  type xxh_u8x16 (line 367) | typedef __vector unsigned char xxh_u8x16;
  type xxh_u32x4 (line 368) | typedef __vector unsigned xxh_u32x4;
  function XXH_FORCE_INLINE (line 387) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val)
  function XXH_FORCE_INLINE (line 399) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)
  function XXH_FORCE_INLINE (line 426) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b)
  function XXH_FORCE_INLINE (line 432) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)
  function XXH128_hash_t (line 524) | static XXH128_hash_t
  function xxh_u64 (line 639) | static xxh_u64
  function XXH_FORCE_INLINE (line 647) | XXH_FORCE_INLINE xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
  function XXH64_hash_t (line 657) | static XXH64_hash_t XXH3_avalanche(xxh_u64 h64)
  function XXH64_hash_t (line 670) | static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
  function XXH_FORCE_INLINE (line 714) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 736) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 752) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 769) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 806) | XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
  function XXH_FORCE_INLINE (line 839) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_NO_INLINE (line 869) | XXH_NO_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 934) | XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)
  type xxh_i64 (line 948) | typedef int64_t xxh_i64;
  type xxh_i64 (line 951) | typedef long long xxh_i64;
  function XXH3_accumulate_512_avx512 (line 983) | void
  function XXH3_scrambleAcc_avx512 (line 1032) | void
  function XXH3_initCustomSecret_avx512 (line 1056) | void
  function XXH3_accumulate_512_avx2 (line 1088) | void
  function XXH3_scrambleAcc_avx2 (line 1122) | void
  function XXH3_initCustomSecret_avx2 (line 1151) | void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64...
  function XXH3_accumulate_512_sse2 (line 1194) | void
  function XXH3_scrambleAcc_sse2 (line 1229) | void
  function XXH3_initCustomSecret_sse2 (line 1258) | void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64...
  function XXH_FORCE_INLINE (line 1293) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1330) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1387) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1419) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1453) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1471) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1488) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1615) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1632) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 1665) | XXH_FORCE_INLINE xxh_u64
  function XXH64_hash_t (line 1673) | static XXH64_hash_t
  function XXH_FORCE_INLINE (line 1703) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_NO_INLINE (line 1724) | XXH_NO_INLINE XXH64_hash_t
  function XXH_NO_INLINE (line 1739) | XXH_NO_INLINE XXH64_hash_t
  function XXH_FORCE_INLINE (line 1758) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_NO_INLINE (line 1779) | XXH_NO_INLINE XXH64_hash_t
  type XXH64_hash_t (line 1789) | typedef XXH64_hash_t (*XXH3_hashLong64_f)(const xxh_u8* XXH_RESTRICT, si...
  function XXH_FORCE_INLINE (line 1792) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_PUBLIC_API (line 1817) | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* input, size_t len)
  function XXH_PUBLIC_API (line 1822) | XXH_PUBLIC_API XXH64_hash_t
  function XXH_PUBLIC_API (line 1828) | XXH_PUBLIC_API XXH64_hash_t
  function XXH_alignedFree (line 1891) | static void XXH_alignedFree(void* p)
  function XXH_PUBLIC_API (line 1902) | XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
  function XXH_PUBLIC_API (line 1907) | XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)
  function XXH_PUBLIC_API (line 1913) | XXH_PUBLIC_API void
  function XXH3_64bits_reset_internal (line 1919) | static void
  function XXH_PUBLIC_API (line 1942) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 1950) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 1960) | XXH_PUBLIC_API XXH_errorcode
  function XXH_FORCE_INLINE (line 1973) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 2000) | XXH_FORCE_INLINE XXH_errorcode
  function XXH_PUBLIC_API (line 2069) | XXH_PUBLIC_API XXH_errorcode
  function XXH_FORCE_INLINE (line 2077) | XXH_FORCE_INLINE void
  function XXH_PUBLIC_API (line 2111) | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
  function XXH_PUBLIC_API (line 2131) | XXH_PUBLIC_API void
  function XXH_FORCE_INLINE (line 2191) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2220) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2247) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2322) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2341) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2353) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_NO_INLINE (line 2386) | XXH_NO_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2435) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_NO_INLINE (line 2463) | XXH_NO_INLINE XXH128_hash_t
  function XXH_NO_INLINE (line 2476) | XXH_NO_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 2486) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_NO_INLINE (line 2507) | XXH_NO_INLINE XXH128_hash_t
  type XXH128_hash_t (line 2516) | typedef XXH128_hash_t (*XXH3_hashLong128_f)(const xxh_u8* XXH_RESTRICT, ...
  function XXH_FORCE_INLINE (line 2519) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_PUBLIC_API (line 2543) | XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* input, size_t len)
  function XXH_PUBLIC_API (line 2550) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 2558) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 2566) | XXH_PUBLIC_API XXH128_hash_t
  function XXH3_128bits_reset_internal (line 2580) | static void
  function XXH_PUBLIC_API (line 2588) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 2596) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 2606) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 2616) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 2623) | XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* st...
  function XXH_PUBLIC_API (line 2653) | XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)
  function XXH_PUBLIC_API (line 2663) | XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2)
  function XXH_PUBLIC_API (line 2675) | XXH_PUBLIC_API void
  function XXH_PUBLIC_API (line 2687) | XXH_PUBLIC_API XXH128_hash_t

FILE: Include/WAVM/Inline/xxhash/xxhash.h
  type XXH_errorcode (line 233) | typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
  type XXH32_hash_t (line 243) | typedef uint32_t XXH32_hash_t;
  type XXH32_hash_t (line 247) | typedef unsigned int XXH32_hash_t;
  type XXH32_hash_t (line 250) | typedef unsigned long XXH32_hash_t;
  type XXH32_state_t (line 295) | typedef struct XXH32_state_s XXH32_state_t;
  type XXH32_canonical_t (line 325) | typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
  type XXH64_hash_t (line 338) | typedef uint64_t XXH64_hash_t;
  type XXH64_hash_t (line 341) | typedef unsigned long long XXH64_hash_t;
  type XXH64_state_t (line 360) | typedef struct XXH64_state_s XXH64_state_t;
  type XXH64_canonical_t (line 370) | typedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_can...
  type XXH32_state_s (line 397) | struct XXH32_state_s {
  type XXH64_state_s (line 412) | struct XXH64_state_s {
  type XXH3_state_t (line 551) | typedef struct XXH3_state_s XXH3_state_t;
  type XXH3_state_s (line 555) | struct XXH3_state_s {
  type XXH128_hash_t (line 633) | typedef struct {
  type XXH128_canonical_t (line 672) | typedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_c...
  function XXH_free (line 883) | static void XXH_free(void* p) { free(p); }
  type xxh_u8 (line 960) | typedef uint8_t xxh_u8;
  type xxh_u8 (line 962) | typedef unsigned char xxh_u8;
  type XXH32_hash_t (line 964) | typedef XXH32_hash_t xxh_u32;
  function xxh_u32 (line 985) | static xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*)...
  type unalign (line 996) | typedef union { xxh_u32 u32; } __attribute__((packed)) unalign;
  function xxh_u32 (line 998) | static xxh_u32 XXH_read32(const void* ptr)
  function xxh_u32 (line 1010) | static xxh_u32 XXH_read32(const void* memPtr)
  type XXH_endianess (line 1021) | typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
  function XXH_isLittleEndian (line 1047) | static int XXH_isLittleEndian(void)
  function xxh_u32 (line 1092) | static xxh_u32 XXH_swap32 (xxh_u32 x)
  type XXH_alignment (line 1105) | typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
  function XXH_FORCE_INLINE (line 1114) | XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr)
  function XXH_FORCE_INLINE (line 1123) | XXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr)
  function XXH_FORCE_INLINE (line 1133) | XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr)
  function xxh_u32 (line 1138) | static xxh_u32 XXH_readBE32(const void* ptr)
  function XXH_FORCE_INLINE (line 1144) | XXH_FORCE_INLINE xxh_u32
  function XXH_versionNumber (line 1158) | XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NU...
  function xxh_u32 (line 1178) | static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
  function xxh_u32 (line 1235) | static xxh_u32 XXH32_avalanche(xxh_u32 h32)
  function xxh_u32 (line 1247) | static xxh_u32
  function XXH_FORCE_INLINE (line 1326) | XXH_FORCE_INLINE xxh_u32
  function XXH_PUBLIC_API (line 1365) | XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_...
  function XXH_PUBLIC_API (line 1389) | XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
  function XXH_PUBLIC_API (line 1393) | XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
  function XXH_PUBLIC_API (line 1399) | XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32...
  function XXH_PUBLIC_API (line 1404) | XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_...
  function XXH_PUBLIC_API (line 1418) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 1482) | XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* state)
  function XXH_PUBLIC_API (line 1516) | XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH3...
  function XXH_PUBLIC_API (line 1523) | XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonica...
  type XXH64_hash_t (line 1537) | typedef XXH64_hash_t xxh_u64;
  function xxh_u64 (line 1580) | static xxh_u64 XXH_read64(const void* memPtr) { return *(const xxh_u64*)...
  type unalign64 (line 1591) | typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) unal...
  function xxh_u64 (line 1593) | static xxh_u64 XXH_read64(const void* ptr)
  function xxh_u64 (line 1605) | static xxh_u64 XXH_read64(const void* memPtr)
  function xxh_u64 (line 1619) | static xxh_u64 XXH_swap64 (xxh_u64 x)
  function XXH_FORCE_INLINE (line 1636) | XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr)
  function XXH_FORCE_INLINE (line 1649) | XXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr)
  function XXH_FORCE_INLINE (line 1663) | XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr)
  function xxh_u64 (line 1668) | static xxh_u64 XXH_readBE64(const void* ptr)
  function XXH_FORCE_INLINE (line 1674) | XXH_FORCE_INLINE xxh_u64
  function xxh_u64 (line 1700) | static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
  function xxh_u64 (line 1708) | static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)
  function xxh_u64 (line 1716) | static xxh_u64 XXH64_avalanche(xxh_u64 h64)
  function xxh_u64 (line 1729) | static xxh_u64
  function XXH_FORCE_INLINE (line 1864) | XXH_FORCE_INLINE xxh_u64
  function XXH_PUBLIC_API (line 1907) | XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t len, XXH64_...
  function XXH_PUBLIC_API (line 1930) | XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
  function XXH_PUBLIC_API (line 1934) | XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
  function XXH_PUBLIC_API (line 1940) | XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64...
  function XXH_PUBLIC_API (line 1945) | XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_...
  function XXH_PUBLIC_API (line 1958) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 2019) | XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* state)
  function XXH_PUBLIC_API (line 2046) | XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH6...
  function XXH_PUBLIC_API (line 2053) | XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonica...

FILE: Include/WAVM/LLVMJIT/LLVMJIT.h
  function namespace (line 14) | namespace WAVM { namespace IR {
  function namespace (line 21) | namespace WAVM { namespace Runtime {
  type class (line 30) | enum class
  function TargetOS (line 36) | enum class TargetOS

FILE: Include/WAVM/Logging/Logging.h
  function namespace (line 8) | namespace WAVM { namespace Log {

FILE: Include/WAVM/NFA/NFA.h
  function namespace (line 9) | namespace WAVM { namespace NFA {

FILE: Include/WAVM/ObjectCache/ObjectCache.h
  function namespace (line 6) | namespace WAVM { namespace Runtime {
  function namespace (line 10) | namespace WAVM { namespace ObjectCache {

FILE: Include/WAVM/ObjectLinker/ObjectLinker.h
  function namespace (line 11) | namespace WAVM { namespace ObjectLinker {

FILE: Include/WAVM/Platform/CPU.h
  function X86CPURegister (line 129) | enum class X86CPURegister

FILE: Include/WAVM/Platform/Clock.h
  function namespace (line 5) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/ConditionVariable.h
  function namespace (line 7) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Diagnostics.h
  function namespace (line 8) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Error.h
  function namespace (line 7) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/File.h
  function namespace (line 6) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Intrinsic.h
  function namespace (line 14) | namespace WAVM {

FILE: Include/WAVM/Platform/Memory.h
  function namespace (line 5) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Mutex.h
  function namespace (line 11) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/RWMutex.h
  function namespace (line 8) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Random.h
  function namespace (line 5) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Signal.h
  function namespace (line 7) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Thread.h
  function namespace (line 5) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/Platform/Unwind.h
  function namespace (line 8) | namespace WAVM {
  function namespace (line 12) | namespace WAVM { namespace Platform {

FILE: Include/WAVM/RegExp/RegExp.h
  function namespace (line 5) | namespace WAVM { namespace RegExp {

FILE: Include/WAVM/Runtime/Intrinsics.h
  function namespace (line 9) | namespace WAVM { namespace Runtime {
  function namespace (line 13) | namespace WAVM { namespace Intrinsics {

FILE: Include/WAVM/Runtime/Linker.h
  function namespace (line 9) | namespace WAVM { namespace Runtime {

FILE: Include/WAVM/Runtime/Runtime.h
  function namespace (line 19) | namespace WAVM {
  function namespace (line 55) | namespace WAVM { namespace Runtime {

FILE: Include/WAVM/RuntimeABI/RuntimeABI.h
  function namespace (line 18) | namespace WAVM { namespace LLVMJIT {
  type Compartment (line 24) | struct Compartment
  type Context (line 25) | struct Context
  type ExceptionType (line 26) | struct ExceptionType
  type Object (line 27) | struct Object
  type Table (line 28) | struct Table
  type Memory (line 29) | struct Memory
  function ObjectKind (line 33) | enum class ObjectKind : U8

FILE: Include/WAVM/ThreadTest/ThreadTest.h
  function namespace (line 3) | namespace WAVM { namespace Runtime {
  function namespace (line 8) | namespace WAVM { namespace ThreadTest {

FILE: Include/WAVM/VFS/SandboxFS.h
  function namespace (line 6) | namespace WAVM { namespace VFS {

FILE: Include/WAVM/VFS/VFS.h
  type class (line 9) | enum class
  type class (line 17) | enum class
  function SeekOrigin (line 26) | enum class SeekOrigin

FILE: Include/WAVM/WASI/WASI.h
  function namespace (line 10) | namespace WAVM { namespace VFS {
  function namespace (line 15) | namespace WAVM { namespace Runtime {
  function namespace (line 19) | namespace WAVM { namespace WASI {

FILE: Include/WAVM/WASI/WASIABI.h
  type __wasi_intptr_t (line 14) | typedef int32_t __wasi_intptr_t;
  type __wasi_uintptr_t (line 15) | typedef uint32_t __wasi_uintptr_t;
  type __wasi_size_t (line 16) | typedef uint32_t __wasi_size_t;
  type __wasi_void_ptr_t (line 17) | typedef uint32_t __wasi_void_ptr_t;
  type __wasi_advice_t (line 28) | typedef uint8_t __wasi_advice_t;
  type __wasi_clockid_t (line 36) | typedef uint32_t __wasi_clockid_t;
  type __wasi_device_t (line 42) | typedef uint64_t __wasi_device_t;
  type __wasi_dircookie_t (line 44) | typedef uint64_t __wasi_dircookie_t;
  type __wasi_dirnamlen_t (line 47) | typedef uint32_t __wasi_dirnamlen_t;
  type __wasi_errno_t (line 49) | typedef uint16_t __wasi_errno_t;
  type __wasi_eventrwflags_t (line 128) | typedef uint16_t __wasi_eventrwflags_t;
  type __wasi_eventtype_t (line 131) | typedef uint8_t __wasi_eventtype_t;
  type __wasi_exitcode_t (line 136) | typedef uint32_t __wasi_exitcode_t;
  type __wasi_fd_t (line 138) | typedef uint32_t __wasi_fd_t;
  type __wasi_fdflags_t (line 140) | typedef uint16_t __wasi_fdflags_t;
  type __wasi_filedelta_t (line 147) | typedef int64_t __wasi_filedelta_t;
  type __wasi_filesize_t (line 149) | typedef uint64_t __wasi_filesize_t;
  type __wasi_filetype_t (line 151) | typedef uint8_t __wasi_filetype_t;
  type __wasi_fstflags_t (line 161) | typedef uint16_t __wasi_fstflags_t;
  type __wasi_inode_t (line 167) | typedef uint64_t __wasi_inode_t;
  type __wasi_linkcount_t (line 169) | typedef uint64_t __wasi_linkcount_t;
  type __wasi_lookupflags_t (line 171) | typedef uint32_t __wasi_lookupflags_t;
  type __wasi_oflags_t (line 174) | typedef uint16_t __wasi_oflags_t;
  type __wasi_riflags_t (line 180) | typedef uint16_t __wasi_riflags_t;
  type __wasi_rights_t (line 184) | typedef uint64_t __wasi_rights_t;
  type __wasi_roflags_t (line 215) | typedef uint16_t __wasi_roflags_t;
  type __wasi_sdflags_t (line 218) | typedef uint8_t __wasi_sdflags_t;
  type __wasi_siflags_t (line 222) | typedef uint16_t __wasi_siflags_t;
  type __wasi_signal_t (line 224) | typedef uint8_t __wasi_signal_t;
  type __wasi_subclockflags_t (line 257) | typedef uint16_t __wasi_subclockflags_t;
  type __wasi_timestamp_t (line 260) | typedef uint64_t __wasi_timestamp_t;
  type __wasi_userdata_t (line 262) | typedef uint64_t __wasi_userdata_t;
  type __wasi_whence_t (line 264) | typedef uint8_t __wasi_whence_t;
  type __wasi_preopentype_t (line 269) | typedef uint8_t __wasi_preopentype_t;
  type __wasi_dirent_t (line 272) | typedef struct __wasi_dirent_t
  type __wasi_event_t (line 286) | typedef struct __wasi_event_t
  type __wasi_prestat_t (line 308) | typedef struct __wasi_prestat_t
  type __wasi_fdstat_t (line 333) | typedef struct __wasi_fdstat_t
  type __wasi_filestat_t (line 347) | typedef struct __wasi_filestat_t
  type __wasi_ciovec_t (line 369) | typedef struct __wasi_ciovec_t
  type __wasi_iovec_t (line 388) | typedef struct __wasi_iovec_t
  type __wasi_subscription_t (line 407) | typedef struct __wasi_subscription_t

FILE: Include/WAVM/WASM/WASM.h
  function namespace (line 8) | namespace WAVM { namespace IR {
  function namespace (line 12) | namespace WAVM { namespace WASM {

FILE: Include/WAVM/WASTParse/TestScript.h
  function namespace (line 16) | namespace WAVM { namespace WAST {

FILE: Include/WAVM/WASTParse/WASTParse.h
  function namespace (line 8) | namespace WAVM { namespace IR {
  function namespace (line 12) | namespace WAVM { namespace WAST {
  type Error (line 43) | struct Error

FILE: Include/WAVM/WASTPrint/WASTPrint.h
  function namespace (line 5) | namespace WAVM { namespace IR {
  function namespace (line 9) | namespace WAVM { namespace WAST {

FILE: Include/WAVM/wavm-c/wavm-c.h
  type wasm_config_t (line 28) | typedef struct wasm_config_t wasm_config_t;
  type wasm_engine_t (line 29) | typedef struct wasm_engine_t wasm_engine_t;
  type wasm_compartment_t (line 30) | typedef struct wasm_compartment_t wasm_compartment_t;
  type wasm_store_t (line 31) | typedef struct wasm_store_t wasm_store_t;
  type wasm_valtype_t (line 32) | typedef struct wasm_valtype_t wasm_valtype_t;
  type wasm_functype_t (line 33) | typedef struct wasm_functype_t wasm_functype_t;
  type wasm_tabletype_t (line 34) | typedef struct wasm_tabletype_t wasm_tabletype_t;
  type wasm_memorytype_t (line 35) | typedef struct wasm_memorytype_t wasm_memorytype_t;
  type wasm_globaltype_t (line 36) | typedef struct wasm_globaltype_t wasm_globaltype_t;
  type wasm_externtype_t (line 37) | typedef struct wasm_externtype_t wasm_externtype_t;
  type wasm_ref_t (line 38) | typedef struct wasm_ref_t wasm_ref_t;
  type wasm_trap_t (line 39) | typedef struct wasm_trap_t wasm_trap_t;
  type wasm_foreign_t (line 40) | typedef struct wasm_foreign_t wasm_foreign_t;
  type wasm_module_t (line 41) | typedef struct wasm_module_t wasm_module_t;
  type wasm_func_t (line 42) | typedef struct wasm_func_t wasm_func_t;
  type wasm_table_t (line 43) | typedef struct wasm_table_t wasm_table_t;
  type wasm_memory_t (line 44) | typedef struct wasm_memory_t wasm_memory_t;
  type wasm_global_t (line 45) | typedef struct wasm_global_t wasm_global_t;
  type wasm_extern_t (line 46) | typedef struct wasm_extern_t wasm_extern_t;
  type wasm_instance_t (line 47) | typedef struct wasm_instance_t wasm_instance_t;
  type wasm_shared_module_t (line 49) | typedef struct wasm_shared_module_t wasm_shared_module_t;
  type wasm_shared_func_t (line 50) | typedef struct wasm_shared_func_t wasm_shared_func_t;
  type wasm_shared_table_t (line 51) | typedef struct wasm_shared_table_t wasm_shared_table_t;
  type wasm_shared_memory_t (line 52) | typedef struct wasm_shared_memory_t wasm_shared_memory_t;
  type wasm_shared_foreign_t (line 53) | typedef struct wasm_shared_foreign_t wasm_shared_foreign_t;
  type wasm_float32_t (line 63) | typedef float wasm_float32_t;
  type wasm_float64_t (line 64) | typedef double wasm_float64_t;
  type wasm_mutability_t (line 158) | typedef uint8_t wasm_mutability_t;
  type wasm_mutability_enum (line 159) | enum wasm_mutability_enum
  type wasm_shared_t (line 165) | typedef uint8_t wasm_shared_t;
  type wasm_shared_enum (line 166) | enum wasm_shared_enum
  type wasm_index_t (line 172) | typedef uint8_t wasm_index_t;
  type wasm_index_enum (line 173) | enum wasm_index_enum
  type wasm_limits_t (line 179) | typedef struct wasm_limits_t
  type wasm_valkind_enum (line 199) | enum wasm_valkind_enum
  function WASM_IGNORE_UNUSED (line 214) | WASM_IGNORE_UNUSED static inline bool wasm_valkind_is_num(wasm_valkind_t k)
  function WASM_IGNORE_UNUSED (line 218) | WASM_IGNORE_UNUSED static inline bool wasm_valkind_is_ref(wasm_valkind_t k)
  function WASM_IGNORE_UNUSED (line 223) | WASM_IGNORE_UNUSED static inline bool wasm_valtype_is_num(const wasm_val...
  function WASM_IGNORE_UNUSED (line 227) | WASM_IGNORE_UNUSED static inline bool wasm_valtype_is_ref(const wasm_val...
  type wasm_externkind_enum (line 287) | enum wasm_externkind_enum
  type wasm_import_t (line 319) | typedef struct wasm_import_t
  type wasm_export_t (line 330) | typedef struct wasm_export_t
  type wasm_v128_t (line 343) | typedef struct wasm_v128_t
  type wasm_val_t (line 348) | typedef union wasm_val_t
  type wasm_frame_t (line 399) | struct wasm_frame_t
  type own (line 457) | typedef own wasm_trap_t* (*wasm_func_callback_with_env_t)(void* env,
  function wasm_valtype_t (line 588) | wasm_valtype_t* wasm_valtype_new_i32()
  function wasm_valtype_t (line 592) | wasm_valtype_t* wasm_valtype_new_i64()
  function wasm_valtype_t (line 596) | wasm_valtype_t* wasm_valtype_new_f32()
  function wasm_valtype_t (line 600) | wasm_valtype_t* wasm_valtype_new_f64()
  function wasm_valtype_t (line 604) | wasm_valtype_t* wasm_valtype_new_v128()
  function wasm_valtype_t (line 609) | wasm_valtype_t* wasm_valtype_new_externref()
  function wasm_valtype_t (line 613) | wasm_valtype_t* wasm_valtype_new_funcref()
  function wasm_functype_t (line 620) | wasm_functype_t* wasm_functype_new_0_0()
  function wasm_functype_t (line 625) | wasm_functype_t* wasm_functype_new_1_0(own wasm_valtype_t* p)
  function wasm_functype_t (line 631) | wasm_functype_t* wasm_functype_new_2_0(own wasm_valtype_t* p1,
  function wasm_functype_t (line 638) | wasm_functype_t* wasm_functype_new_3_0(own wasm_valtype_t* p1,
  function wasm_functype_t (line 646) | wasm_functype_t* wasm_functype_new_0_1(own wasm_valtype_t* r)
  function wasm_functype_t (line 652) | wasm_functype_t* wasm_functype_new_1_1(own wasm_valtype_t* p,
  function wasm_functype_t (line 660) | wasm_functype_t* wasm_functype_new_2_1(own wasm_valtype_t* p1,
  function wasm_functype_t (line 669) | wasm_functype_t* wasm_functype_new_3_1(own wasm_valtype_t* p1,
  function wasm_functype_t (line 679) | wasm_functype_t* wasm_functype_new_0_2(own wasm_valtype_t* r1,
  function wasm_functype_t (line 686) | wasm_functype_t* wasm_functype_new_1_2(own wasm_valtype_t* p,
  function wasm_functype_t (line 695) | wasm_functype_t* wasm_functype_new_2_2(own wasm_valtype_t* p1,
  function wasm_functype_t (line 705) | wasm_functype_t* wasm_functype_new_3_2(own wasm_valtype_t* p1,

FILE: Lib/DWARF/DWARF.cpp
  function skipForm (line 96) | static bool skipForm(U8 form,
  function Uptr (line 199) | static Uptr lookupAddrx(Uptr index,
  function Uptr (line 224) | static Uptr readAddrFormValue(U8 form,
  function Uptr (line 451) | static Uptr readRefValue(U8 form, InputStream& stream, U8 dwarfFormat)
  type AbbrevAttr (line 501) | struct AbbrevAttr
  type AbbrevEntry (line 508) | struct AbbrevEntry
  function findAbbrev (line 519) | static bool findAbbrev(const U8* debugAbbrev,
  function readDIENames (line 591) | static void readDIENames(const U8* debugInfo,
  function Uptr (line 656) | static Uptr lookupLineAtAddress(const U8* debugLine,
  function Uptr (line 894) | Uptr DWARF::getSourceLocations(const Sections& sections,

FILE: Lib/IR/DisassemblyNames.cpp
  type NameSubsectionType (line 16) | enum class NameSubsectionType : U8
  function deserializeNameMap (line 32) | static void deserializeNameMap(InputStream& stream,
  function serializeNameMap (line 54) | static void serializeNameMap(OutputStream& stream, const std::vector<std...
  function deserializeNameSubsection (line 75) | static void deserializeNameSubsection(const Module& module,
  function serializeNameSubsection (line 296) | void serializeNameSubsection(OutputStream& stream,

FILE: Lib/IR/FloatPrinting.cpp
  function floatAsString (line 10) | static std::string floatAsString(Float f)

FILE: Lib/IR/Module.cpp
  function OrderedSectionID (line 57) | OrderedSectionID IR::getMaxPresentSection(const Module& module, OrderedS...

FILE: Lib/IR/RandomModule.cpp
  type ModuleState (line 28) | struct ModuleState
    method ModuleState (line 37) | ModuleState(Module& inModule, RandomStream& inRandom) : module(inModul...
  type FunctionState (line 42) | struct FunctionState
    type ControlContext (line 44) | struct ControlContext
      type Type (line 46) | enum class Type : U8
    method FunctionState (line 83) | FunctionState(ModuleState& inModuleState,
    method doesStackMatchParams (line 98) | bool doesStackMatchParams(const TypeTupleOrOpTypeTuple& params,
    method isOpSignatureAllowed (line 120) | bool isOpSignatureAllowed(const OpSignature& sig) const
    method applyOpSignature (line 129) | void applyOpSignature(const OpSignature& sig)
    method emitControlEnd (line 138) | void emitControlEnd()
  type ImmTypeAsValue (line 171) | struct ImmTypeAsValue
  function isImmValid (line 177) | bool isImmValid(const FunctionState&, ImmTypeAsValue<Imm>) { return true; }
  function generateImm (line 179) | static void generateImm(const FunctionState& state, RandomStream& random...
  function isImmValid (line 181) | static bool isImmValid(const FunctionState& state, ImmTypeAsValue<Functi...
  function generateImm (line 185) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 191) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 196) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 201) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 207) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 213) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 219) | static void generateImm(const FunctionState& state, RandomStream& random...
  function generateImm (line 225) | static void generateImm(const FunctionState& state,
  function generateImm (line 233) | static void generateImm(const FunctionState& state,
  function isImmValid (line 243) | static bool isImmValid(const FunctionState& state, ImmTypeAsValue<DataSe...
  function generateImm (line 247) | static void generateImm(const FunctionState& state, RandomStream& random...
  function isImmValid (line 253) | static bool isImmValid(const FunctionState& state, ImmTypeAsValue<ElemSe...
  function generateImm (line 257) | static void generateImm(const FunctionState& state, RandomStream& random...
  function getValidEmitters (line 264) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 280) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 300) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 325) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 345) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 376) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 406) | void getValidEmitters(
  function getValidEmitters (line 440) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 469) | void getValidEmitters(FunctionState& state,
  function getValidEmitters (line 493) | void getValidEmitters(FunctionState& state,
  type OperatorInfo (line 512) | struct OperatorInfo
  function OperatorInfo (line 519) | static const OperatorInfo operatorInfos[]{
  function ValueType (line 530) | static ValueType generateValueType(RandomStream& random)
  function FunctionType (line 545) | static FunctionType generateFunctionType(RandomStream& random)
  function IndexType (line 564) | static IndexType generateIndexType(RandomStream& random)
  function ReferenceType (line 574) | static ReferenceType generateRefType(RandomStream& random)
  function ExternKind (line 584) | static ExternKind generateExternKind(RandomStream& random)
  function FunctionType (line 597) | FunctionType generateBlockSig(RandomStream& random, TypeTuple params)
  function IndexedBlockType (line 610) | IndexedBlockType getIndexedBlockType(ModuleState& moduleState, const Fun...
  function InitializerExpression (line 1060) | static InitializerExpression generateInitializerExpression(Module& module,

FILE: Lib/IR/Types.cpp
  type TypeTupleHashPolicy (line 15) | struct TypeTupleHashPolicy
    method areKeysEqual (line 17) | static bool areKeysEqual(TypeTuple left, TypeTuple right)
    method Uptr (line 26) | static Uptr getKeyHash(TypeTuple typeTuple) { return typeTuple.getHash...
  type FunctionTypeHashPolicy (line 29) | struct FunctionTypeHashPolicy
    method areKeysEqual (line 31) | static bool areKeysEqual(FunctionType left, FunctionType right)
    method Uptr (line 35) | static Uptr getKeyHash(FunctionType functionType) { return functionTyp...
  type GlobalUniqueTypeTuples (line 66) | struct GlobalUniqueTypeTuples
    method GlobalUniqueTypeTuples (line 78) | static GlobalUniqueTypeTuples& get()
    method GlobalUniqueTypeTuples (line 85) | GlobalUniqueTypeTuples() = default;
  type GlobalUniqueFunctionTypes (line 115) | struct GlobalUniqueFunctionTypes
    method GlobalUniqueFunctionTypes (line 127) | static GlobalUniqueFunctionTypes& get()
    method GlobalUniqueFunctionTypes (line 134) | GlobalUniqueFunctionTypes() = default;

FILE: Lib/IR/Validate.cpp
  type WAVM (line 42) | namespace WAVM {
    type Hash<KindAndIndex> (line 43) | struct Hash<KindAndIndex>
      method Uptr (line 45) | Uptr operator()(const KindAndIndex& kindAndIndex, Uptr seed = 0) const
    type IR (line 55) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...
    type IR (line 1332) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...
  type WAVM (line 55) | namespace WAVM { namespace IR {
    type Hash<KindAndIndex> (line 43) | struct Hash<KindAndIndex>
      method Uptr (line 45) | Uptr operator()(const KindAndIndex& kindAndIndex, Uptr seed = 0) const
    type IR (line 55) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...
    type IR (line 1332) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...
  function validate (line 70) | static void validate(const IR::Module& module, IR::ValueType valueType)
  function validate (line 89) | static void validate(SizeConstraints size, U64 maxMax)
  function validate (line 96) | static void validate(const IR::Module& module, ReferenceType type)
  function validate (line 109) | static void validate(const Module& module, TableType type)
  function validate (line 122) | static void validate(const Module& module, MemoryType type)
  function validate (line 134) | static void validate(const Module& module, GlobalType type) { validate(m...
  function validate (line 136) | static void validate(const Module& module, TypeTuple typeTuple)
  function validateType (line 141) | void validateType(Type expectedType, Type actualType, const char* context)
  function validateExternKind (line 150) | static void validateExternKind(const Module& module, ExternKind externKind)
  function ValueType (line 169) | static ValueType validateGlobalIndex(const Module& module,
  function FunctionType (line 195) | static FunctionType validateFunctionIndex(const Module& module, Uptr fun...
  function validateFunctionRef (line 201) | static void validateFunctionRef(const ModuleValidationState& state, Uptr...
  function validateFunctionRefIsDeclared (line 206) | static void validateFunctionRefIsDeclared(const ModuleValidationState& s...
  function FunctionType (line 217) | static FunctionType validateBlockType(const Module& module, const Indexe...
  function FunctionType (line 246) | static FunctionType validateFunctionType(const Module& module, const Ind...
  function validateInitializer (line 257) | static void validateInitializer(const ModuleValidationState& state,
  type FunctionValidationContext (line 301) | struct FunctionValidationContext
    method FunctionValidationContext (line 305) | FunctionValidationContext(ModuleValidationState& inModuleValidationState,
    method Uptr (line 345) | Uptr getControlStackSize() { return controlStack.size(); }
    method validateNonEmptyControlStack (line 347) | void validateNonEmptyControlStack(const char* context)
    method traceOperator (line 356) | void traceOperator(const std::string& operatorDescription)
    method block (line 394) | void block(ControlStructureImm imm)
    method loop (line 402) | void loop(ControlStructureImm imm)
    method if_ (line 409) | void if_(ControlStructureImm imm)
    method else_ (line 418) | void else_(NoImm imm)
    method end (line 435) | void end(NoImm)
    method try_ (line 457) | void try_(ControlStructureImm imm)
    method validateCatch (line 465) | void validateCatch()
    method catch_ (line 483) | void catch_(ExceptionTypeImm imm)
    method catch_all (line 491) | void catch_all(NoImm)
    method return_ (line 497) | void return_(NoImm)
    method br (line 503) | void br(BranchImm imm)
    method br_table (line 508) | void br_table(BranchTableImm imm)
    method br_if (line 537) | void br_if(BranchImm imm)
    method unreachable (line 545) | void unreachable(NoImm) { enterUnreachable(); }
    method drop (line 546) | void drop(NoImm) { popAndValidateOperand("drop", ValueType::any); }
    method select (line 548) | void select(SelectImm imm)
    method local_get (line 579) | void local_get(GetOrSetVariableImm<false> imm)
    method local_set (line 583) | void local_set(GetOrSetVariableImm<false> imm)
    method local_tee (line 587) | void local_tee(GetOrSetVariableImm<false> imm)
    method global_get (line 594) | void global_get(GetOrSetVariableImm<true> imm)
    method global_set (line 599) | void global_set(GetOrSetVariableImm<true> imm)
    method table_get (line 606) | void table_get(TableImm imm)
    method table_set (line 613) | void table_set(TableImm imm)
    method table_grow (line 620) | void table_grow(TableImm imm)
    method table_fill (line 628) | void table_fill(TableImm imm)
    method throw_ (line 638) | void throw_(ExceptionTypeImm imm)
    method rethrow (line 647) | void rethrow(RethrowImm imm)
    method ref_null (line 656) | void ref_null(ReferenceTypeImm imm)
    method ref_is_null (line 662) | void ref_is_null(NoImm)
    method call (line 673) | void call(FunctionImm imm)
    method call_indirect (line 679) | void call_indirect(CallIndirectImm imm)
    method validateImm (line 691) | void validateImm(NoImm) {}
    method validateImm (line 693) | void validateImm(LiteralImm<nativeType> imm) {}
    method validateImm (line 695) | void validateImm(LoadOrStoreImm<naturalAlignmentLog2> imm)
    method validateImm (line 716) | void validateImm(LoadOrStoreLaneImm<naturalAlignmentLog2, numLanes> imm)
    method validateImm (line 722) | void validateImm(MemoryImm imm) { VALIDATE_INDEX(imm.memoryIndex, modu...
    method validateImm (line 723) | void validateImm(MemoryCopyImm imm)
    method validateImm (line 729) | void validateImm(TableImm imm) { VALIDATE_INDEX(imm.tableIndex, module...
    method validateImm (line 730) | void validateImm(TableCopyImm imm)
    method validateImm (line 740) | void validateImm(FunctionRefImm imm)
    method validateImm (line 746) | void validateImm(LaneIndexImm<numLanes> imm)
    method validateImm (line 751) | void validateImm(ShuffleImm<numLanes> imm)
    method validateImm (line 761) | void validateImm(AtomicLoadOrStoreImm<naturalAlignmentLog2> imm)
    method validateImm (line 769) | void validateImm(AtomicFenceImm imm)
    method validateImm (line 774) | void validateImm(DataSegmentAndMemImm imm)
    method validateImm (line 780) | void validateImm(DataSegmentImm imm)
    method validateImm (line 785) | void validateImm(ElemSegmentAndTableImm imm)
    method validateImm (line 808) | void validateImm(ElemSegmentImm imm)
    type ControlContext (line 842) | struct ControlContext
      type Type (line 844) | enum class Type : U8
    method pushControlStack (line 874) | void pushControlStack(ControlContext::Type type,
    method validateStackEmptyAtEndOfControlStructure (line 882) | void validateStackEmptyAtEndOfControlStructure()
    method enterUnreachable (line 899) | void enterUnreachable()
    method validateBranchDepth (line 907) | void validateBranchDepth(Uptr depth) const
    method ControlContext (line 913) | const ControlContext& getBranchTargetByDepth(Uptr depth) const
      type Type (line 844) | enum class Type : U8
    method ValueType (line 919) | ValueType validateLocalIndex(Uptr localIndex)
    method ValueType (line 925) | ValueType peekAndValidateOperand(const char* context,
    method popAndValidateOperandArray (line 961) | void popAndValidateOperandArray(const char* context, const ValueType* ...
    method popAndValidateOperandArray (line 971) | void popAndValidateOperandArray(const char* context, const ValueType (...
    method popAndValidateOperands (line 977) | void popAndValidateOperands(const char* context, OperandTypes... opera...
    method ValueType (line 983) | ValueType popAndValidateOperand(const char* context, const ValueType e...
    method popAndValidateTypeTuple (line 993) | void popAndValidateTypeTuple(const char* context, TypeTuple expectedTy...
    method popAndValidateOpParams (line 998) | void popAndValidateOpParams(const char* context, OpTypeTuple expectedT...
    method peekAndValidateTypeTuple (line 1003) | void peekAndValidateTypeTuple(const char* context, TypeTuple expectedT...
    method pushOperand (line 1012) | void pushOperand(ValueType type) { stack.push_back(type); }
    method pushOperandTuple (line 1013) | void pushOperandTuple(TypeTuple typeTuple)
    method pushOpResults (line 1017) | void pushOpResults(OpTypeTuple results)
  type WAVM (line 1332) | namespace WAVM { namespace IR {
    type Hash<KindAndIndex> (line 43) | struct Hash<KindAndIndex>
      method Uptr (line 45) | Uptr operator()(const KindAndIndex& kindAndIndex, Uptr seed = 0) const
    type IR (line 55) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...
    type IR (line 1332) | namespace IR {
      type ModuleValidationState (line 56) | struct ModuleValidationState
        method ModuleValidationState (line 61) | ModuleValidationState(const IR::Module& inModule) : module(inModul...
      type CodeValidationStreamImpl (line 1333) | struct CodeValidationStreamImpl
        method CodeValidationStreamImpl (line 1338) | CodeValidationStreamImpl(ModuleValidationState& moduleValidationSt...

FILE: Lib/LLVMJIT/Disassembler.cpp
  type LLVMJIT::Disassembler (line 23) | struct LLVMJIT::Disassembler
    method Disassembler (line 29) | Disassembler(LLVMDisasmContextRef inContext, TargetArch inArch)
    method Disassembler (line 38) | Disassembler(const Disassembler&) = delete;
    method Disassembler (line 39) | Disassembler& operator=(const Disassembler&) = delete;
  function Uptr (line 74) | Uptr LLVMJIT::findInstructionBoundary(const std::shared_ptr<Disassembler...

FILE: Lib/LLVMJIT/EmitContext.h
  function namespace (line 32) | namespace WAVM { namespace LLVMJIT {
  function reloadMemoryBases (line 93) | void reloadMemoryBases()
  function initContextVariables (line 125) | void initContextVariables(llvm::Value* initialContextPointer, llvm::Type...
  function ValueVector (line 147) | ValueVector emitRuntimeIntrinsic(const char* intrinsicName,

FILE: Lib/LLVMJIT/EmitConvert.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 22) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS

FILE: Lib/LLVMJIT/EmitCore.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 24) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS

FILE: Lib/LLVMJIT/EmitFunction.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 32) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS
  function PHIVector (line 46) | PHIVector EmitFunctionContext::createPHIs(llvm::BasicBlock* basicBlock, ...
  type UnreachableOpVisitor (line 242) | struct UnreachableOpVisitor
    method UnreachableOpVisitor (line 246) | UnreachableOpVisitor(EmitFunctionContext& inContext)
    method block (line 258) | void block(ControlStructureImm) { ++unreachableControlDepth; }
    method loop (line 259) | void loop(ControlStructureImm) { ++unreachableControlDepth; }
    method if_ (line 260) | void if_(ControlStructureImm) { ++unreachableControlDepth; }
    method else_ (line 264) | void else_(NoImm imm)
    method end (line 268) | void end(NoImm imm)
    method try_ (line 277) | void try_(ControlStructureImm imm) { ++unreachableControlDepth; }
    method catch_ (line 278) | void catch_(ExceptionTypeImm imm)
    method catch_all (line 282) | void catch_all(NoImm imm)

FILE: Lib/LLVMJIT/EmitFunctionContext.h
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 24) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS

FILE: Lib/LLVMJIT/EmitMem.cpp
  type BoundsCheckOp (line 33) | enum class BoundsCheckOp
  function emitLoadLane (line 394) | static void emitLoadLane(EmitFunctionContext& functionContext,
  function emitStoreLane (line 424) | static void emitStoreLane(EmitFunctionContext& functionContext,
  function emitLoadInterleaved (line 471) | static void emitLoadInterleaved(EmitFunctionContext& functionContext,
  function emitStoreInterleaved (line 538) | static void emitStoreInterleaved(EmitFunctionContext& functionContext,

FILE: Lib/LLVMJIT/EmitModule.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 27) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS

FILE: Lib/LLVMJIT/EmitModuleContext.h
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 19) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS

FILE: Lib/LLVMJIT/GDBRegistration.cpp
  type JITCodeEntry (line 12) | struct JITCodeEntry
  type JITDescriptor (line 20) | struct JITDescriptor
  function WAVM_GDB_VISIBLE (line 37) | WAVM_GDB_VISIBLE WAVM_FORCENOINLINE void __jit_debug_register_code()
  type WAVM (line 50) | namespace WAVM { namespace LLVMJIT {
    type LLVMJIT (line 50) | namespace LLVMJIT {
      function unregisterObjectWithGDB (line 74) | void unregisterObjectWithGDB(void* handle)

FILE: Lib/LLVMJIT/LLVMCompile.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 28) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS
  function printModule (line 38) | static std::string printModule(const llvm::Module& llvmModule)
  type LLVMArrayOutputStream (line 47) | struct LLVMArrayOutputStream : llvm::raw_pwrite_stream
    method LLVMArrayOutputStream (line 49) | LLVMArrayOutputStream() { SetUnbuffered(); }
    method flush (line 53) | void flush() = delete;
    method write_impl (line 58) | virtual void write_impl(const char* data, size_t numBytes) override
    method pwrite_impl (line 64) | virtual void pwrite_impl(const char* data, size_t numBytes, U64 offset...
    method U64 (line 69) | virtual U64 current_pos() const override { return output.size(); }
  function optimizeLLVMModule (line 75) | static void optimizeLLVMModule(llvm::Module& llvmModule,
  function getAndValidateTargetMachine (line 166) | static std::unique_ptr<llvm::TargetMachine> getAndValidateTargetMachine(

FILE: Lib/LLVMJIT/LLVMJIT.cpp
  type LLVMRuntimeSymbols (line 41) | namespace LLVMRuntimeSymbols {
  function globalInitLLVM (line 94) | static bool globalInitLLVM()
  function globalInitLLVMOnce (line 112) | static void globalInitLLVMOnce()
  function TargetSpec (line 248) | TargetSpec LLVMJIT::getHostTargetSpec()
  function TargetValidationResult (line 320) | TargetValidationResult LLVMJIT::validateTargetMachine(
  function TargetValidationResult (line 353) | TargetValidationResult LLVMJIT::validateTarget(const TargetSpec& targetS...
  function Version (line 361) | Version LLVMJIT::getVersion()

FILE: Lib/LLVMJIT/LLVMJITPrivate.h
  function namespace (line 56) | namespace WAVM { namespace LLVMJIT {

FILE: Lib/LLVMJIT/LLVMModule.cpp
  type WAVM (line 36) | namespace WAVM { namespace Runtime {
    type Runtime (line 36) | namespace Runtime {
      type ExceptionType (line 37) | struct ExceptionType
  type LLVMJIT::GlobalModuleState (line 40) | struct LLVMJIT::GlobalModuleState
    method GlobalModuleState (line 52) | GlobalModuleState() {}
  type LLVMJIT::ModuleMemoryManager (line 57) | struct LLVMJIT::ModuleMemoryManager
    method ModuleMemoryManager (line 59) | ModuleMemoryManager() : imageBase(nullptr), numPages(0) {}
  function Uptr (line 319) | Uptr LLVMJIT::getInstructionSourceByAddress(Uptr address,

FILE: Lib/LLVMJIT/Thunk.cpp
  function POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS (line 30) | POP_DISABLE_WARNINGS_FOR_LLVM_HEADERS
  type InvokeThunkCache (line 42) | struct InvokeThunkCache
    method InvokeThunkCache (line 49) | static InvokeThunkCache& get()
    method InvokeThunkCache (line 56) | InvokeThunkCache() {}
  function InvokeThunkPointer (line 59) | InvokeThunkPointer LLVMJIT::getInvokeThunk(FunctionType functionType)

FILE: Lib/NFA/NFA.cpp
  type NFAState (line 20) | struct NFAState
  type WAVM (line 26) | namespace WAVM { namespace NFA {
    type NFA (line 26) | namespace NFA {
      type Builder (line 27) | struct Builder
  function addUnique (line 35) | void addUnique(std::vector<Element>& vector, const Element& element)
  function Builder (line 44) | Builder* NFA::createBuilder()
  function StateIndex (line 51) | StateIndex NFA::addState(Builder* builder)
  function StateIndex (line 73) | StateIndex NFA::getNonTerminalEdge(Builder* builder, StateIndex initialS...
  type DFAState (line 87) | struct DFAState
    method DFAState (line 90) | DFAState()
  function convertToDFA (line 99) | static std::vector<DFAState> convertToDFA(Builder* builder)
  type StateTransitionsByChar (line 303) | struct StateTransitionsByChar
    method StateTransitionsByChar (line 308) | StateTransitionsByChar(U8 inC, Uptr inNumStates)
    method StateTransitionsByChar (line 312) | StateTransitionsByChar(StateTransitionsByChar&& inMove) noexcept
  function nibbleToHexChar (line 434) | static char nibbleToHexChar(U8 value) { return value < 10 ? ('0' + value...
  function escapeString (line 436) | static std::string escapeString(const std::string& string)
  function getGraphEdgeCharLabel (line 459) | static std::string getGraphEdgeCharLabel(Uptr charIndex)
  function getGraphEdgeLabel (line 476) | static std::string getGraphEdgeLabel(const CharSet& charSet)

FILE: Lib/ObjectCache/ObjectCache.cpp
  type ModuleKey (line 45) | struct ModuleKey {
    method ModuleKey (line 54) | ModuleKey() = default;
    method ModuleKey (line 55) | ModuleKey(U64 codeKey, U8 inModuleHashBytes[16])
    method U64 (line 61) | U64 getCodeKey() const
  type TimeKey (line 72) | struct TimeKey {
    method TimeKey (line 75) | TimeKey() = default;
    method TimeKey (line 76) | TimeKey(const Time& time)
    method Time (line 85) | Time getTime() const
  type Metadata (line 97) | struct Metadata { TimeKey lastAccessTimeKey; }
  function MDB_val (line 103) | MDB_val asMDBVal(const Value& value)
  function fromMDBVal (line 110) | void fromMDBVal(const MDB_val& mdbVal, Value& outValue)
  function MDB_val (line 116) | MDB_val asMDBVal<std::vector<U8>>(const std::vector<U8>& bytes)
  function MDB_val (line 129) | MDB_val asMDBVal<MDB_val>(const MDB_val& val) { return val; }
  type Database (line 137) | struct Database
    type Exception (line 140) | struct Exception
      type Type (line 142) | enum class Type
      method Exception (line 150) | Exception(Type inType) : type(inType) {}
    method Database (line 165) | Database(MDB_env* inEnv) : env(inEnv) {}
    method MDB_txn (line 170) | MDB_txn* beginTxn(unsigned int flags = 0, MDB_txn* parentTxn = nullptr)
    method MDB_dbi (line 189) | MDB_dbi openTable(MDB_txn* txn, const char* name, unsigned int flags)
    method tryGetKeyValue (line 201) | static bool tryGetKeyValue(MDB_txn* txn, MDB_dbi dbi, const Key& key, ...
    method getKeyValue (line 217) | static void getKeyValue(MDB_txn* txn, MDB_dbi dbi, const Key& key, Val...
    method tryPutKeyValue (line 231) | static bool tryPutKeyValue(MDB_txn* txn, MDB_dbi dbi, const Key& key, ...
    method putKeyValue (line 246) | static void putKeyValue(MDB_txn* txn, MDB_dbi dbi, const Key& key, con...
    method tryDeleteKey (line 256) | static bool tryDeleteKey(MDB_txn* txn, MDB_dbi dbi, const Key& key)
    method deleteKey (line 271) | static void deleteKey(MDB_txn* txn, MDB_dbi dbi, const Key& key)
    method MDB_cursor (line 277) | static MDB_cursor* openCursor(MDB_txn* txn, MDB_dbi dbi)
    method tryGetCursor (line 290) | static bool tryGetCursor(MDB_cursor* cursor, Key& outKey, Value& outVa...
    method closeCursor (line 304) | static void closeCursor(MDB_cursor* cursor) { mdb_cursor_close(cursor); }
    method dropDB (line 307) | static void dropDB(MDB_txn* txn, MDB_dbi dbi)
  type ScopedTxn (line 317) | struct ScopedTxn
    method ScopedTxn (line 319) | ScopedTxn(MDB_txn* inTxn) : txn(inTxn) {}
    method abort (line 328) | void abort()
    method commit (line 335) | void commit()
  function logModuleHash (line 356) | static void logModuleHash(const char* prefix, const U8 moduleHashBytes[16])
  type LMDBObjectCache (line 380) | struct LMDBObjectCache : Runtime::ObjectCacheInterface
    method OpenResult (line 382) | OpenResult init(const char* path, Uptr maxBytes, U64 inCodeKey)
    method tryGetCachedObject (line 480) | bool tryGetCachedObject(U8 moduleHash[16],
    method addCachedObject (line 513) | void addCachedObject(U8 moduleHash[16],
    method dump (line 566) | void dump()
    method getCachedObject (line 646) | virtual std::vector<U8> getCachedObject(
    method evictLRU (line 707) | bool evictLRU()
  function OpenResult (line 738) | OpenResult ObjectCache::open(const char* path,

FILE: Lib/ObjectLinker/COFF.cpp
  type CoffFileHeader (line 24) | struct CoffFileHeader
  type CoffSectionHeader (line 35) | struct CoffSectionHeader
  type CoffSymbol (line 50) | struct CoffSymbol {
  type CoffRelocation (line 68) | struct CoffRelocation {
  function SectionAccess (line 162) | static SectionAccess getCOFFSectionAccess(U32 characteristics)
  function Uptr (line 169) | static Uptr getCOFFSectionAlignment(U32 characteristics)
  function getCOFFSymbolName (line 176) | static std::string getCOFFSymbolName(const CoffSymbol& sym,
  function applyCOFFX64Reloc (line 196) | static void applyCOFFX64Reloc(const CoffRelocation& rel,
  function U32 (line 287) | static U32 applyCOFFAArch64Reloc(const CoffRelocation& rel,
  function U32 (line 524) | static U32 applyCOFFReloc(Arch arch,
  function linkCOFFArch (line 547) | static void linkCOFFArch(U8* bytes,

FILE: Lib/ObjectLinker/ELF.cpp
  type Elf64_Ehdr (line 21) | struct Elf64_Ehdr
  type Elf64_Shdr (line 39) | struct Elf64_Shdr
  type Elf64_Sym (line 53) | struct Elf64_Sym
  type Elf64_Rela (line 63) | struct Elf64_Rela
  type Elf64_Rel (line 70) | struct Elf64_Rel
  function SectionAccess (line 184) | static SectionAccess getELFSectionAccess(U64 flags)
  function applyELFX64Reloc (line 191) | static void applyELFX64Reloc(U32 rtype,
  function applyELFAArch64Reloc (line 230) | static void applyELFAArch64Reloc(U32 rtype,
  function applyELFReloc (line 292) | static void applyELFReloc(Arch arch,
  function I64 (line 313) | static I64 readELFX64ImplicitAddend(U32 rtype, const U8* fixup)
  function linkELFArch (line 328) | static void linkELFArch(U8* bytes,

FILE: Lib/ObjectLinker/MachO.cpp
  type MachHeader64 (line 26) | struct MachHeader64
  type LoadCommand (line 38) | struct LoadCommand
  type SegmentCommand64 (line 44) | struct SegmentCommand64
  type MachOSection64 (line 59) | struct MachOSection64
  type SymtabCommand (line 75) | struct SymtabCommand
  type NList64 (line 85) | struct NList64
  type MachORelocationInfo (line 94) | struct MachORelocationInfo
  function U32 (line 143) | static U32 relocSymbolNum(const MachORelocationInfo& r) { return r.r_inf...
  function relocPcrel (line 144) | static bool relocPcrel(const MachORelocationInfo& r) { return (r.r_info ...
  function U32 (line 145) | static U32 relocLength(const MachORelocationInfo& r) { return (r.r_info ...
  function relocExtern (line 146) | static bool relocExtern(const MachORelocationInfo& r) { return (r.r_info...
  function U32 (line 147) | static U32 relocType(const MachORelocationInfo& r) { return (r.r_info >>...
  function SectionAccess (line 183) | static SectionAccess getMachOSectionAccess(const MachOSection64& sect)
  type CIEEncodings (line 193) | struct CIEEncodings
  function CIEEncodings (line 201) | static CIEEncodings parseCIEEncodings(const U8* ehFrame, Uptr ehFrameSiz...
  function correctEhFramePcRel64 (line 258) | static void correctEhFramePcRel64(U8* ehFrame,
  function parseAndCorrectEhFrameFDEs (line 291) | static void parseAndCorrectEhFrameFDEs(bool correctPcRelValues,
  function applyMachOSubtractor (line 370) | static void applyMachOSubtractor(U8* fixup,
  function U32 (line 399) | static U32 applyMachOX64Reloc(UnalignedArrayView<MachORelocationInfo> re...
  function U32 (line 486) | static U32 applyMachOAArch64Reloc(UnalignedArrayView<MachORelocationInfo...
  function U32 (line 588) | static U32 applyMachOReloc(Arch arch,
  function linkMachOArch (line 631) | static void linkMachOArch(U8* bytes,

FILE: Lib/ObjectLinker/ObjectLinker.cpp
  function ImageLayout (line 48) | ImageLayout ObjectLinker::layoutImage(const std::vector<SectionLayoutInf...
  function writeStub (line 253) | static void writeStub(Arch arch, U8* stub, Uptr targetAddr)
  function Uptr (line 277) | Uptr ObjectLinker::getOrCreateStub(ImageLayout& layout, Uptr targetAddr)
  function Uptr (line 299) | Uptr ObjectLinker::getOrCreateGotEntry(ImageLayout& layout, Uptr symbolA...

FILE: Lib/ObjectLinker/ObjectLinkerPrivate.h
  type LinkResult (line 19) | struct LinkResult
  function Arch (line 21) | enum class Arch

FILE: Lib/Platform/POSIX/ClockPOSIX.cpp
  function I128 (line 13) | static I128 timespecToNS(timespec t) { return I128(U64(t.tv_sec)) * 1000...
  function I128 (line 16) | static I128 timevalToNS(timeval t)
  function I128 (line 22) | static I128 getClockAsI128(clockid_t clockId)
  function I128 (line 29) | static I128 getClockResAsI128(clockid_t clockId)
  function mach_timebase_info_data_t (line 41) | static mach_timebase_info_data_t getTimebaseInfoData()
  function mach_timebase_info_data_t (line 48) | static mach_timebase_info_data_t getCachedTimebaseInfoData()
  function I128 (line 54) | static I128 getMachAbsoluteClock()
  function I128 (line 62) | static I128 getMachAbsoluteClockResolution()
  function Time (line 71) | Time Platform::getClockTime(Clock clock)
  function Time (line 98) | Time Platform::getClockResolution(Clock clock)

FILE: Lib/Platform/POSIX/DebugPersonality.cpp
  function Uptr (line 31) | static Uptr readEncodedPointer(MemoryInputStream& stream, const U8* lsda...
  type scan_results (line 125) | struct scan_results
  type __cxa_exception (line 139) | struct __cxa_exception
  function __cxa_exception (line 165) | static __cxa_exception* getExceptionHeader(_Unwind_Exception* unwind_exc...
  function scan_eh_tab (line 170) | static void scan_eh_tab(scan_results& results,
  function set_registers (line 339) | static void set_registers(_Unwind_Exception* unwind_exception,
  function saveResultsToExceptionHeader (line 381) | static void saveResultsToExceptionHeader(_Unwind_Exception* unwind_excep...
  function loadResultsFromExceptionHeader (line 399) | static void loadResultsFromExceptionHeader(_Unwind_Exception* unwind_exc...

FILE: Lib/Platform/POSIX/EHFrameDecode.cpp
  function parseFDE (line 18) | static bool parseFDE(const U8* fde,
  function isAdvanceLocOpcode (line 185) | static bool isAdvanceLocOpcode(U8 opcode)
  type DecodedCFIOp (line 191) | struct DecodedCFIOp
  function Uptr (line 200) | static Uptr parseCFIInstruction(MemoryInputStream& stream,
  function Uptr (line 328) | Uptr UnwindProcInfo::decodeUnwindOps(UnwindOp* outOps, Uptr maxOps) const
  function formatCompactUnwind (line 391) | static void formatCompactUnwind(U32 encoding, StringBuilderBase& sb)

FILE: Lib/Platform/POSIX/ErrorPOSIX.cpp
  function Mutex (line 19) | static Mutex& getErrorReportingMutex()
  function reportError (line 35) | static void reportError(const char* message, bool printCallStack, Uptr n...

FILE: Lib/Platform/POSIX/FilePOSIX.cpp
  type iovec (line 48) | struct iovec
  type iovec (line 49) | struct iovec
  type iovec (line 50) | struct iovec
  type iovec (line 51) | struct iovec
  type iovec (line 52) | struct iovec
  type iovec (line 55) | struct iovec
  type iovec (line 56) | struct iovec
  type iovec (line 57) | struct iovec
  type iovec (line 58) | struct iovec
  type iovec (line 59) | struct iovec
  function Result (line 62) | static Result asVFSResult(int error)
  function FileType (line 104) | static FileType getFileTypeFromMode(mode_t mode)
  function FileType (line 121) | static FileType getFileTypeFromDirEntType(U8 type)
  function I128 (line 139) | static I128 timeToNS(time_t time)
  function getFileInfoFromStatus (line 147) | static void getFileInfoFromStatus(const struct stat& status, FileInfo& o...
  function I32 (line 159) | static I32 translateVFDFlags(const VFDFlags& vfsFlags)
  type POSIXDirEntStream (line 193) | struct POSIXDirEntStream : DirEntStream
    method POSIXDirEntStream (line 195) | POSIXDirEntStream(DIR* inDir) : dir(inDir) {}
    method close (line 197) | virtual void close() override
    method getNext (line 203) | virtual bool getNext(DirEnt& outEntry) override
    method restart (line 232) | virtual void restart() override
    method U64 (line 239) | virtual U64 tell() override
    method seek (line 249) | virtual bool seek(U64 offset) override
  type POSIXFD (line 267) | struct POSIXFD : VFD
    method POSIXFD (line 271) | POSIXFD(I32 inFD) : fd(inFD) {}
    method Result (line 273) | virtual Result close() override
    method Result (line 290) | virtual Result seek(I64 offset, SeekOrigin origin, U64* outAbsoluteOff...
    method Result (line 311) | virtual Result readv(const IOReadBuffer* buffers,
    method Result (line 384) | virtual Result writev(const IOWriteBuffer* buffers,
    method Result (line 451) | virtual Result sync(SyncType syncType) override
    method Result (line 468) | virtual Result getVFDInfo(VFDInfo& outInfo) override
    method Result (line 508) | virtual Result setVFDFlags(const VFDFlags& vfsFlags) override
    method Result (line 514) | virtual Result setFileSize(U64 numBytes) override
    method Result (line 521) | virtual Result setFileTimes(bool setLastAccessTime,
    method Result (line 574) | virtual Result getFileInfo(FileInfo& outInfo) override
    method Result (line 584) | virtual Result openDir(DirEntStream*& outStream) override
  type POSIXStdFD (line 601) | struct POSIXStdFD : POSIXFD
    method POSIXStdFD (line 603) | POSIXStdFD(I32 inFD) : POSIXFD(inFD) {}
    method Result (line 605) | virtual Result close() override
  function VFD (line 617) | VFD* Platform::getStdFD(StdDevice device)
  type POSIXFS (line 628) | struct POSIXFS : HostFS
    method POSIXFS (line 650) | static POSIXFS& get()
    method POSIXFS (line 657) | POSIXFS() {}
  function HostFS (line 660) | HostFS& Platform::getHostFS() { return POSIXFS::get(); }
  function Result (line 662) | Result POSIXFS::open(const std::string& path,
  function Result (line 699) | Result POSIXFS::getFileInfo(const std::string& path, VFS::FileInfo& outI...
  function Result (line 709) | Result POSIXFS::setFileTimes(const std::string& path,
  function Result (line 758) | Result POSIXFS::openDir(const std::string& path, DirEntStream*& outStream)
  function Result (line 767) | Result POSIXFS::renameFile(const std::string& oldPath, const std::string...
  function Result (line 772) | Result POSIXFS::unlinkFile(const std::string& path)
  function Result (line 777) | Result POSIXFS::removeDir(const std::string& path)
  function Result (line 782) | Result POSIXFS::createDir(const std::string& path)

FILE: Lib/Platform/POSIX/MemoryPOSIX.cpp
  function Uptr (line 22) | static Uptr internalGetPreferredVirtualPageSizeLog2()
  function Uptr (line 29) | Uptr Platform::getBytesPerPageLog2()
  function U32 (line 35) | static U32 memoryAccessAsPOSIXFlag(MemoryAccess access)
  function isPageAligned (line 48) | static bool isPageAligned(U8* address)
  function U8 (line 54) | U8* Platform::allocateVirtualPages(Uptr numPages)
  function U8 (line 74) | U8* Platform::allocateAlignedVirtualPages(Uptr numPages,
  function Uptr (line 210) | Uptr Platform::getPeakMemoryUsageBytes()

FILE: Lib/Platform/POSIX/POSIXPrivate.h
  function namespace (line 12) | namespace WAVM { namespace Platform {

FILE: Lib/Platform/POSIX/RandomPOSIX.cpp
  function readDevRandom (line 15) | static void readDevRandom(U8* outRandomBytes, Uptr numBytes)

FILE: Lib/Platform/POSIX/SignalPOSIX.cpp
  type ScopedSignalContext (line 26) | struct ScopedSignalContext : SignalContext
    method link (line 30) | void link()
  function maskSignals (line 47) | static void maskSignals(int how)
  function signalHandler (line 57) | [[noreturn]] static void signalHandler(int signalNumber, siginfo_t* sign...
  type sigaction (line 118) | struct sigaction

FILE: Lib/Platform/POSIX/ThreadPOSIX.cpp
  type Platform::Thread (line 47) | struct Platform::Thread
  type CreateThreadArgs (line 52) | struct CreateThreadArgs
  function isAlignedLog2 (line 62) | static bool isAlignedLog2(void* pointer, Uptr alignmentLog2)
  function getGlibcVersion (line 102) | static void getGlibcVersion(unsigned long& outMajor, unsigned long& outM...
  function getThreadStack (line 121) | static void getThreadStack(pthread_t thread, U8*& outMinGuardAddr, U8*& ...
  function WAVM_NO_ASAN (line 171) | WAVM_NO_ASAN static void touchStackPages(U8* minAddr, Uptr numBytesPerPage)
  function WAVM_NO_ASAN (line 261) | WAVM_NO_ASAN static void* createThreadEntry(void* argsVoid)
  function I64 (line 303) | I64 Platform::joinThread(Thread* thread)
  function Uptr (line 311) | Uptr Platform::getNumberOfHardwareThreads() { return std::thread::hardwa...

FILE: Lib/Platform/POSIX/UnwindPOSIX.cpp
  type UnwindSections (line 44) | struct UnwindSections
  class DynamicUnwindRegistration (line 63) | class DynamicUnwindRegistration
    method DynamicUnwindRegistration (line 66) | static DynamicUnwindRegistration& getInstance()
    method registerSections (line 72) | void registerSections(Uptr codeStart,
    method deregisterSections (line 102) | void deregisterSections(Uptr codeStart)
    type RegisteredUnwindSections (line 122) | struct RegisteredUnwindSections
    method DynamicUnwindRegistration (line 132) | DynamicUnwindRegistration()
    method findSectionsCallback (line 162) | static int findSectionsCallback(Uptr addr, UnwindSections* info)
    method findSections (line 167) | int findSections(Uptr addr, UnwindSections* info)
  function UnwindRegistration (line 196) | UnwindRegistration* Platform::registerUnwindData(const U8* imageBase,
  function UnwindRegistration (line 221) | UnwindRegistration* Platform::registerUnwindData(const U8* imageBase,
  type UnwindStateImpl (line 242) | struct UnwindStateImpl
  function UnwindStateImpl (line 255) | static UnwindStateImpl& getImpl(U8* storage)
  function UnwindStateImpl (line 260) | static const UnwindStateImpl& getImpl(const U8* storage)
  function UnwindState (line 272) | UnwindState& UnwindState::operator=(const UnwindState& other)
  function UnwindState (line 278) | UnwindState& UnwindState::operator=(UnwindState&& other) noexcept
  function WAVM_FORCENOINLINE (line 286) | WAVM_FORCENOINLINE UnwindState UnwindState::capture(Uptr numFramesToSkip)
  function UnwindStepResult (line 314) | UnwindStepResult UnwindState::step()
  function getLibunwindReg (line 331) | static bool getLibunwindReg(const U8* storage, int libunwindReg, Uptr& o...
  function setUnwindCursorFromUContext (line 439) | static void setUnwindCursorFromUContext(unw_cursor_t& cursor, ucontext_t...
  function UnwindState (line 506) | UnwindState Platform::makeUnwindStateFromSignalContext(void* contextPtr)

FILE: Lib/Platform/Windows/ClockWindows.cpp
  function I128 (line 18) | static I128 fileTimeToI128(FILETIME fileTime)
  function FILETIME (line 23) | static FILETIME i128ToFileTime(I128 i128)
  function I128 (line 33) | static I128 getRealtimeClockOrigin()
  function I128 (line 49) | static const I128& getCachedRealtimeClockOrigin()
  function LARGE_INTEGER (line 55) | static LARGE_INTEGER getQPCFrequency()
  function LARGE_INTEGER (line 62) | static LARGE_INTEGER getCachedQPCFrequency()
  function Time (line 68) | Time Platform::fileTimeToWAVMRealTime(FILETIME fileTime)
  function FILETIME (line 73) | FILETIME Platform::wavmRealTimeToFileTime(Time realTime)
  function Time (line 78) | Time Platform::getClockTime(Clock clock)
  function Time (line 108) | Time Platform::getClockResolution(Clock clock)

FILE: Lib/Platform/Windows/DiagnosticsWindows.cpp
  type DbgHelp (line 21) | struct DbgHelp
    method DbgHelp (line 26) | static DbgHelp* get()
    method DbgHelp (line 39) | DbgHelp()
  function HMODULE (line 55) | static HMODULE getCurrentModule()
  function HMODULE (line 62) | static HMODULE getModuleFromBaseAddress(Uptr baseAddress)
  function getModuleName (line 67) | static void getModuleName(HMODULE module, char* outName, Uptr outNameSize)
  function trimModuleName (line 74) | static void trimModuleName(char* moduleName, Uptr moduleNameSize)

FILE: Lib/Platform/Windows/ErrorWindows.cpp
  function Mutex (line 20) | static Mutex& getErrorReportingMutex()
  function reportError (line 35) | static void reportError(const char* message, bool printCallStack, Uptr n...

FILE: Lib/Platform/Windows/FileWindows.cpp
  function Result (line 31) | static Result asVFSResult(DWORD windowsError)
  function LARGE_INTEGER (line 74) | static LARGE_INTEGER makeLargeInt(U64 u64)
  function Result (line 81) | static Result getFileType(HANDLE handle, FileType& outType)
  function Result (line 112) | static Result getFileInfoByHandle(HANDLE handle, FileInfo& outInfo)
  function getWindowsPath (line 137) | static bool getWindowsPath(const std::string& inString, std::wstring& ou...
  function getVFSPath (line 153) | static void getVFSPath(const wchar_t* inChars,
  function readDirEnts (line 174) | static bool readDirEnts(HANDLE handle, bool startFromBeginning, std::vec...
  type WindowsDirEntStream (line 214) | struct WindowsDirEntStream : DirEntStream
    method WindowsDirEntStream (line 216) | WindowsDirEntStream(HANDLE inHandle, std::vector<DirEnt>&& inDirEnts)
    method close (line 221) | virtual void close() override
    method getNext (line 230) | virtual bool getNext(DirEnt& outEntry) override
    method restart (line 251) | virtual void restart() override
    method U64 (line 258) | virtual U64 tell() override
    method seek (line 264) | virtual bool seek(U64 offset) override
  type WindowsFD (line 283) | struct WindowsFD : VFD
    method WindowsFD (line 285) | WindowsFD(HANDLE inHandle,
    method Result (line 301) | virtual Result close() override
    method Result (line 309) | virtual Result seek(I64 offset, SeekOrigin origin, U64* outAbsoluteOff...
    method Result (line 337) | virtual Result readv(const IOReadBuffer* buffers,
    method Result (line 413) | virtual Result writev(const IOWriteBuffer* buffers,
    method Result (line 480) | virtual Result sync(SyncType syncType) override
    method Result (line 487) | virtual Result getVFDInfo(VFDInfo& outInfo) override
    method Result (line 499) | virtual Result getFileInfo(FileInfo& outInfo) override
    method Result (line 506) | virtual Result setVFDFlags(const VFDFlags& flags) override
    method Result (line 541) | virtual Result setFileSize(U64 numBytes) override
    method Result (line 552) | virtual Result setFileTimes(bool setLastAccessTime,
    method Result (line 573) | virtual Result openDir(DirEntStream*& outStream) override
    method Result (line 620) | Result readImpl(void* buffer,
    method Result (line 648) | Result writeImpl(const void* buffer,
  type WindowsStdFD (line 676) | struct WindowsStdFD : WindowsFD
    method WindowsStdFD (line 678) | WindowsStdFD(HANDLE inHandle, DWORD inDesiredAccess, VFDSync inImplici...
    method Result (line 688) | virtual Result close()
  function VFD (line 695) | VFD* Platform::getStdFD(StdDevice device)
  type WindowsFS (line 713) | struct WindowsFS : HostFS
    method WindowsFS (line 735) | static WindowsFS& get()
    method WindowsFS (line 742) | WindowsFS() {}
  function HostFS (line 745) | HostFS& Platform::getHostFS() { return WindowsFS::get(); }
  function Result (line 747) | Result WindowsFS::open(const std::string& path,
  function Result (line 808) | Result WindowsFS::getFileInfo(const std::string& path, FileInfo& outInfo)
  function Result (line 834) | Result WindowsFS::setFileTimes(const std::string& path,
  function Result (line 875) | Result WindowsFS::renameFile(const std::string& oldPath, const std::stri...
  function Result (line 887) | Result WindowsFS::unlinkFile(const std::string& path)
  function Result (line 896) | Result WindowsFS::removeDir(const std::string& path)
  function Result (line 905) | Result WindowsFS::createDir(const std::string& path)
  function Result (line 915) | Result WindowsFS::openDir(const std::string& path, DirEntStream*& outStr...

FILE: Lib/Platform/Windows/MemoryWindows.cpp
  function Uptr (line 20) | static Uptr internalGetPreferredVirtualPageSizeLog2()
  function Uptr (line 29) | Uptr Platform::getBytesPerPageLog2()
  function U32 (line 35) | static U32 memoryAccessAsWin32Flag(MemoryAccess access)
  function isPageAligned (line 48) | static bool isPageAligned(U8* address)
  function U8 (line 54) | U8* Platform::allocateVirtualPages(Uptr numPages)
  function VirtualAlloc2PointerType (line 70) | static VirtualAlloc2PointerType loadVirtualAlloc2()
  function VirtualAlloc2PointerType (line 81) | static VirtualAlloc2PointerType getVirtualAlloc2()
  function U8 (line 88) | U8* Platform::allocateAlignedVirtualPages(Uptr numPages,
  function Uptr (line 206) | Uptr Platform::getPeakMemoryUsageBytes()

FILE: Lib/Platform/Windows/SignalWindows.cpp
  function translateSEHToSignal (line 16) | static bool translateSEHToSignal(EXCEPTION_POINTERS* exceptionPointers, ...
  function LONG (line 40) | static LONG CALLBACK sehSignalFilterFunctionNonReentrant(EXCEPTION_POINT...
  function LONG (line 61) | static LONG CALLBACK sehSignalFilterFunction(EXCEPTION_POINTERS* excepti...

FILE: Lib/Platform/Windows/ThreadWindows.cpp
  type Platform::Thread (line 24) | struct Platform::Thread
    method releaseRef (line 31) | void releaseRef()
  type CreateThreadArgs (line 45) | struct CreateThreadArgs
  function DWORD (line 74) | static DWORD WINAPI createThreadEntry(void* argsVoid)
  type ProcessorGroupInfo (line 85) | struct ProcessorGroupInfo
  function getProcessorGroupInfos (line 90) | static std::vector<ProcessorGroupInfo> getProcessorGroupInfos()
  function I64 (line 141) | I64 Platform::joinThread(Thread* thread)
  function Uptr (line 166) | static Uptr getNumberOfHardwareThreadsImpl()
  function Uptr (line 177) | Uptr Platform::getNumberOfHardwareThreads()

FILE: Lib/Platform/Windows/UnwindWindows.cpp
  function DWORD64 (line 22) | inline DWORD64 getContextIP(const CONTEXT& ctx) { return ctx.Pc; }
  function DWORD64 (line 24) | inline DWORD64 getContextIP(const CONTEXT& ctx) { return ctx.Rip; }
  function UnwindRegistration (line 27) | UnwindRegistration* Platform::registerUnwindData(const U8* imageBase,
  type UnwindStateImpl (line 62) | struct UnwindStateImpl
  function UnwindStateImpl (line 76) | static UnwindStateImpl& getImpl(U8* storage)
  function UnwindStateImpl (line 81) | static const UnwindStateImpl& getImpl(const U8* storage)
  function UnwindState (line 93) | UnwindState& UnwindState::operator=(const UnwindState& other)
  function UnwindState (line 99) | UnwindState& UnwindState::operator=(UnwindState&& other) noexcept
  function setUnwindStateRuntimeFunctionAndImageBase (line 105) | static void setUnwindStateRuntimeFunctionAndImageBase(UnwindStateImpl& i...
  function WAVM_FORCENOINLINE (line 114) | WAVM_FORCENOINLINE UnwindState UnwindState::capture(Uptr numFramesToSkip)
  function UnwindState (line 138) | UnwindState Platform::makeUnwindStateFromSignalContext(void* contextPtr)
  function UnwindStepResult (line 150) | UnwindStepResult UnwindState::step()
  type ARM64UnwindOpType (line 378) | enum ARM64UnwindOpType : U8
  type DecodedARM64Op (line 404) | struct DecodedARM64Op
  function Uptr (line 412) | static Uptr getARM64UnwindCodeSize(U8 b0)
  function Uptr (line 431) | static Uptr decodeARM64UnwindCode(const U8* codes, Uptr offset, Uptr cod...
  function Uptr (line 571) | Uptr UnwindProcInfo::decodeUnwindOps(UnwindOp* outOps, Uptr maxOps) const
  type WindowsUnwindOpType (line 717) | enum WindowsUnwindOpType
  type DecodedSlot (line 732) | struct DecodedSlot
  function Uptr (line 742) | static Uptr decodeUnwindOpAtSlot(const U8* codes, Uptr slotIndex, Decode...
  function Uptr (line 800) | Uptr UnwindProcInfo::decodeUnwindOps(UnwindOp* outOps, Uptr maxOps) const

FILE: Lib/Platform/Windows/WindowsPrivate.h
  function namespace (line 22) | namespace WAVM { namespace Platform {

FILE: Lib/RegExp/RegExp.cpp
  type NodeType (line 10) | enum class NodeType : U8
  type Node (line 19) | struct Node
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  type Lit (line 25) | struct Lit : Node
    method Lit (line 28) | Lit(const NFA::CharSet& inCharSet) : Node(NodeType::lit), charSet(inCh...
  type Unary (line 30) | struct Unary : Node
    method Unary (line 33) | Unary(Node* inChild) : Node(inType), child(inChild) {}
  type Binary (line 36) | struct Binary : Node
    method Binary (line 40) | Binary(Node* inFirstChild, Node* inSecondChild)
  function isMetachar (line 56) | static bool isMetachar(char c)
  function parseChar (line 78) | static char parseChar(const char*& nextChar)
  function parseLit (line 96) | static NFA::CharSet parseLit(const char*& nextChar)
  function parseCharClass (line 113) | static NFA::CharSet parseCharClass(const char*& nextChar)
  function parseSet (line 148) | static NFA::CharSet parseSet(const char*& nextChar)
  function Node (line 174) | static Node* parseElementary(const char*& nextChar, Uptr groupDepth)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function Node (line 202) | static Node* parseGroup(const char*& nextChar, Uptr groupDepth)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function Node (line 215) | static Node* parseQuantifier(const char*& nextChar, Uptr groupDepth)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function Node (line 229) | static Node* parseSeq(const char*& nextChar, Uptr groupDepth)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function Node (line 252) | static Node* parseUnion(const char*& nextChar, Uptr groupDepth)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function Node (line 274) | static Node* parse(const char* string)
    method Node (line 22) | Node(NodeType inType) : type(inType) {}
  function createNFA (line 282) | static void createNFA(NFA::Builder* nfaBuilder,

FILE: Lib/Runtime/Atomics.cpp
  type WAVM (line 21) | namespace WAVM { namespace Runtime {
    type Runtime (line 21) | namespace Runtime {
  type WaitList (line 26) | struct WaitList
    method WaitList (line 34) | WaitList() : numReferences(1) {}
  function WaitList (line 45) | static WaitList* openWaitList(Uptr address)
    method WaitList (line 34) | WaitList() : numReferences(1) {}
  function closeWaitList (line 63) | static void closeWaitList(Uptr address, WaitList* waitList)
  function Value (line 79) | static Value atomicLoad(const Value* valuePointer)
  function U32 (line 87) | static U32 waitOnAddress(Value* valuePointer, Value expectedValue, I64 t...
  function U32 (line 143) | static U32 wakeAddress(void* pointer, U32 numToWake)

FILE: Lib/Runtime/Compartment.cpp
  type CompartmentRuntimeData (line 21) | struct CompartmentRuntimeData
  function CompartmentRuntimeData (line 56) | static CompartmentRuntimeData* initCompartmentRuntimeData(U8*& outUnalig...
  function Compartment (line 72) | Compartment* Runtime::createCompartment(std::string&& debugName)
  function Compartment (line 81) | Compartment* Runtime::cloneCompartment(const Compartment* compartment, s...
  function Object (line 154) | Object* Runtime::remapToClonedCompartment(const Object* object, const Co...
  function Function (line 178) | Function* Runtime::remapToClonedCompartment(const Function* function,
  function Table (line 183) | Table* Runtime::remapToClonedCompartment(const Table* table, const Compa...
  function Memory (line 189) | Memory* Runtime::remapToClonedCompartment(const Memory* memory, const Co...
  function Global (line 195) | Global* Runtime::remapToClonedCompartment(const Global* global, const Co...
  function ExceptionType (line 201) | ExceptionType* Runtime::remapToClonedCompartment(const ExceptionType* ex...
  function Instance (line 208) | Instance* Runtime::remapToClonedCompartment(const Instance* instance,
  function Foreign (line 215) | Foreign* Runtime::remapToClonedCompartment(const Foreign* foreign,

FILE: Lib/Runtime/Context.cpp
  function Context (line 18) | Context* Runtime::createContext(Compartment* compartment, std::string&& ...
  function Compartment (line 65) | Compartment* Runtime::getCompartment(const Context* context) { return co...
  function Context (line 67) | Context* Runtime::cloneContext(const Context* context, Compartment* newC...

FILE: Lib/Runtime/Diagnostics.cpp
  function Uptr (line 43) | Uptr Runtime::getInstructionSourceByAddress(Uptr ip, InstructionSource* ...
  function disassembleWithCFI (line 140) | static void disassembleWithCFI(const std::shared_ptr<LLVMJIT::Disassembl...
  function traceFrame (line 220) | static void traceFrame(const std::shared_ptr<LLVMJIT::Disassembler>& dis...
  function CallStack (line 297) | CallStack Runtime::unwindCallStack(UnwindState& state)

FILE: Lib/Runtime/Exception.cpp
  type WAVM (line 26) | namespace WAVM { namespace Runtime {
    type Runtime (line 26) | namespace Runtime {
  function ExceptionType (line 48) | ExceptionType* Runtime::createExceptionType(Compartment* compartment,
  function ExceptionType (line 65) | ExceptionType* Runtime::cloneExceptionType(ExceptionType* exceptionType,
  function Exception (line 97) | Exception* Runtime::createException(ExceptionType* type,
  function ExceptionType (line 121) | ExceptionType* Runtime::getExceptionType(const Exception* exception) { r...
  function CallStack (line 129) | const CallStack& Runtime::getExceptionCallStack(const Exception* exception)
  function WAVM_FORCENOINLINE (line 199) | [[noreturn]] WAVM_FORCENOINLINE void Runtime::throwException(
  function isRuntimeException (line 255) | static bool isRuntimeException(const Platform::Signal& signal)
  function translateSignalToRuntimeException (line 278) | static void translateSignalToRuntimeException(const Platform::Signal& si...
  type UnwindContext (line 358) | struct UnwindContext

FILE: Lib/Runtime/Global.cpp
  function Global (line 17) | Global* Runtime::createGlobal(Compartment* compartment,
  function Global (line 74) | Global* Runtime::cloneGlobal(Global* global, Compartment* newCompartment)
  function Value (line 116) | Value Runtime::getGlobalValue(const Context* context, const Global* global)
  function Value (line 125) | Value Runtime::setGlobalValue(Context* context, const Global* global, Va...
  function GlobalType (line 139) | GlobalType Runtime::getGlobalType(const Global* global) { return global-...

FILE: Lib/Runtime/Instance.cpp
  function Value (line 24) | static Value evaluateInitializer(const std::vector<Global*>& moduleGlobals,
  function Uptr (line 54) | static Uptr getIndexValue(const Value& value, IndexType indexType)
  function Instance (line 73) | Instance* Runtime::instantiateModule(Compartment* compartment,
  function Instance (line 150) | Instance* Runtime::instantiateModuleInternal(Compartment* compartment,
  function Instance (line 486) | Instance* Runtime::cloneInstance(Instance* instance, Compartment* newCom...
  function Function (line 565) | Function* Runtime::getStartFunction(const Instance* instance) { return i...
  function Memory (line 567) | Memory* Runtime::getDefaultMemory(const Instance* instance)
  function Table (line 571) | Table* Runtime::getDefaultTable(const Instance* instance)
  function Object (line 576) | Object* Runtime::getInstanceExport(const Instance* instance, const std::...
  function Object (line 583) | Object* Runtime::getTypedInstanceExport(const Instance* instance,
  function Function (line 592) | Function* Runtime::getTypedInstanceExport(const Instance* instance,
  function Table (line 604) | Table* Runtime::getTypedInstanceExport(const Instance* instance,
  function Memory (line 616) | Memory* Runtime::getTypedInstanceExport(const Instance* instance,
  function Global (line 628) | Global* Runtime::getTypedInstanceExport(const Instance* instance,

FILE: Lib/Runtime/Intrinsics.cpp
  type WAVM (line 22) | namespace WAVM { namespace Intrinsics {
    type Intrinsics (line 22) | namespace Intrinsics {
      type ModuleImpl (line 23) | struct ModuleImpl
  function initializeModule (line 41) | static void initializeModule(Intrinsics::Module* moduleRef)
  function Instance (line 102) | Instance* Intrinsics::instantiateModule(

FILE: Lib/Runtime/Invoke.cpp
  type InvokeContext (line 71) | struct InvokeContext

FILE: Lib/Runtime/Linker.cpp
  function linkImport (line 156) | static void linkImport(const IR::Module& module,
  function LinkResult (line 178) | LinkResult Runtime::linkModule(const IR::Module& module, Resolver& resol...

FILE: Lib/Runtime/Memory.cpp
  type WAVM (line 26) | namespace WAVM { namespace Runtime {
    type Runtime (line 26) | namespace Runtime {
  function Uptr (line 41) | static Uptr getPlatformPagesPerWebAssemblyPageLog2()
  function Memory (line 47) | static Memory* createMemoryImpl(Compartment* compartment,
  function Memory (line 100) | Memory* Runtime::createMemory(Compartment* compartment,
  function Memory (line 129) | Memory* Runtime::cloneMemory(Memory* memory, Compartment* newCompartment)
  function Uptr (line 222) | Uptr Runtime::getMemoryNumPages(const Memory* memory)
  function GrowResult (line 233) | GrowResult Runtime::growMemory(Memory* memory, Uptr numPagesToGrow, Uptr...
  function U8 (line 296) | U8* Runtime::getMemoryBaseAddress(Memory* memory) { return memory->baseA...
  function U8 (line 298) | static U8* getValidatedMemoryOffsetRangeImpl(Memory* memory,
  function U8 (line 315) | U8* Runtime::getReservedMemoryOffsetRange(Memory* memory, Uptr address, ...
  function U8 (line 325) | U8* Runtime::getValidatedMemoryOffsetRange(Memory* memory, Uptr address,...

FILE: Lib/Runtime/Module.cpp
  function getGlobalObjectCache (line 26) | static std::shared_ptr<ObjectCacheInterface> getGlobalObjectCache()
  function ModuleRef (line 32) | ModuleRef Runtime::compileModule(const IR::Module& irModule)
  function ModuleRef (line 91) | ModuleRef Runtime::loadPrecompiledModule(const IR::Module& irModule,

FILE: Lib/Runtime/ObjectGC.cpp
  type GCState (line 74) | struct GCState
    method GCState (line 80) | GCState(Compartment* inCompartment) : compartment(inCompartment) {}
    method visitReference (line 82) | void visitReference(Object* object)
    method visitReferenceArray (line 103) | void visitReferenceArray(const Array& array)
    method initGCObject (line 108) | void initGCObject(GCObject* object, bool forceRoot = false)
    method scanObject (line 117) | void scanObject(GCObject* object)
  function collectGarbageImpl (line 182) | static bool collectGarbageImpl(Compartment* compartment)

FILE: Lib/Runtime/ResourceQuota.cpp
  function ResourceQuotaRef (line 9) | ResourceQuotaRef Runtime::createResourceQuota() { return std::make_share...
  function Uptr (line 11) | Uptr Runtime::getResourceQuotaMaxTableElems(ResourceQuotaConstRefParam r...
  function Uptr (line 16) | Uptr Runtime::getResourceQuotaCurrentTableElems(ResourceQuotaConstRefPar...
  function Uptr (line 26) | Uptr Runtime::getResourceQuotaMaxMemoryPages(ResourceQuotaConstRefParam ...
  function Uptr (line 31) | Uptr Runtime::getResourceQuotaCurrentMemoryPages(ResourceQuotaConstRefPa...

FILE: Lib/Runtime/Runtime.cpp
  function ExternType (line 131) | ExternType Runtime::getExternType(const Object* object)
  function FunctionType (line 150) | FunctionType Runtime::getFunctionType(const Function* function) { return...
  function Context (line 152) | Context* Runtime::getContextFromRuntimeData(ContextRuntimeData* contextR...
  function Compartment (line 157) | Compartment* Runtime::getCompartmentFromContextRuntimeData(
  function ContextRuntimeData (line 165) | ContextRuntimeData* Runtime::getContextRuntimeData(const Context* context)
  function Instance (line 170) | Instance* Runtime::getInstanceFromRuntimeData(ContextRuntimeData* contex...
  function Table (line 179) | Table* Runtime::getTableFromRuntimeData(ContextRuntimeData* contextRunti...
  function Memory (line 187) | Memory* Runtime::getMemoryFromRuntimeData(ContextRuntimeData* contextRun...
  function Foreign (line 203) | Foreign* Runtime::createForeign(Compartment* compartment,

FILE: Lib/Runtime/RuntimePrivate.h
  function namespace (line 23) | namespace WAVM { namespace Intrinsics {
  function namespace (line 27) | namespace WAVM { namespace Runtime {

FILE: Lib/Runtime/Table.cpp
  type WAVM (line 25) | namespace WAVM { namespace Runtime {
    type Runtime (line 25) | namespace Runtime {
  function Uptr (line 37) | static Uptr getNumPlatformPages(Uptr numBytes)
  function Function (line 42) | static Function* makeDummyFunction(const char* debugName)
  function Object (line 51) | Object* Runtime::getOutOfBoundsElement()
  function Object (line 57) | static Object* getUninitializedElement()
  function Uptr (line 63) | static Uptr objectToBiasedTableElementValue(Object* object)
  function Object (line 68) | static Object* biasedTableElementValueToObject(Uptr biasedValue)
  function Table (line 73) | static Table* createTableImpl(Compartment* compartment,
  function GrowResult (line 104) | static GrowResult growTableImpl(Table* table,
  function Table (line 174) | Table* Runtime::createTable(Compartment* compartment,
  function Table (line 215) | Table* Runtime::cloneTable(Table* table, Compartment* newCompartment)
  function Object (line 320) | static Object* setTableElementNonNull(Table* table, Uptr index, Object* ...
  function Object (line 356) | static Object* getTableElementNonNull(const Table* table, Uptr index)
  function Object (line 385) | Object* Runtime::setTableElement(Table* table, Uptr index, Object* newVa...
  function Object (line 402) | Object* Runtime::getTableElement(const Table* table, Uptr index)
  function Uptr (line 412) | Uptr Runtime::getTableNumElements(const Table* table)
  function GrowResult (line 425) | GrowResult Runtime::growTable(Table* table,

FILE: Lib/Runtime/WAVMIntrinsics.cpp
  type WAVM (line 13) | namespace WAVM { namespace Runtime {
    type Runtime (line 13) | namespace Runtime {

FILE: Lib/ThreadTest/ThreadTest.cpp
  type Thread (line 27) | struct Thread
    method addRef (line 48) | void addRef(Uptr delta = 1) { numRefs += delta; }
    method removeRef (line 49) | void removeRef()
  type ExitThreadException (line 55) | struct ExitThreadException
  function WAVM_FORCENOINLINE (line 70) | WAVM_FORCENOINLINE static Uptr allocateThreadId(Thread* thread)
  function validateThreadId (line 81) | static void validateThreadId(Uptr threadId)
  function I64 (line 91) | static I64 threadEntry(void* threadVoid)
  function removeThreadById (line 180) | static IntrusiveSharedPtr<Thread> removeThreadById(Uptr threadId)
  function Instance (line 225) | Instance* ThreadTest::instantiate(Compartment* compartment)

FILE: Lib/VFS/SandboxFS.cpp
  type SandboxFS (line 10) | struct SandboxFS : FileSystem
    method SandboxFS (line 12) | SandboxFS(FileSystem* inInnerFS, const std::string& inRootPath)
    method Result (line 18) | virtual Result open(const std::string& path,
    method Result (line 27) | virtual Result getFileInfo(const std::string& path, FileInfo& outInfo)...
    method Result (line 31) | virtual Result setFileTimes(const std::string& path,
    method Result (line 41) | virtual Result openDir(const std::string& path, DirEntStream*& outStre...
    method Result (line 46) | virtual Result renameFile(const std::string& oldPath, const std::strin...
    method Result (line 51) | virtual Result unlinkFile(const std::string& path) override
    method Result (line 56) | virtual Result removeDir(const std::string& path) override
    method Result (line 61) | virtual Result createDir(const std::string& path) override
    method getInnerPath (line 70) | std::string getInnerPath(const std::string& absolutePathName)

FILE: Lib/WASI/WASI.cpp
  type WAVM (line 29) | namespace WAVM { namespace WASI {
    type WASI (line 29) | namespace WASI {
  function Resolver (line 260) | Resolver& WASI::getProcessResolver(Process& process) { return process.re...
  function Process (line 262) | Process* WASI::getProcessFromContextRuntimeData(Runtime::ContextRuntimeD...
  function Memory (line 268) | Memory* WASI::getProcessMemory(const Process& process) { return process....
  function I32 (line 271) | I32 WASI::catchExit(std::function<I32()>&& thunk)

FILE: Lib/WASI/WASIArgsEnvs.cpp
  type WAVM (line 14) | namespace WAVM { namespace WASI {
    type WASI (line 14) | namespace WASI {

FILE: Lib/WASI/WASIClocks.cpp
  type WAVM (line 15) | namespace WAVM { namespace WASI {
    type WASI (line 15) | namespace WASI {
  function getPlatformClock (line 19) | static bool getPlatformClock(__wasi_clockid_t clock, Platform::Clock& ou...

FILE: Lib/WASI/WASIDiagnostics.cpp
  function WAVM_FORCENOINLINE (line 110) | WAVM_FORCENOINLINE static void traceSyscallv(const char* syscallName,
  function __wasi_errno_t (line 153) | __wasi_errno_t WASI::traceSyscallReturnf(const char* syscallName,

FILE: Lib/WASI/WASIFile.cpp
  type WAVM (line 28) | namespace WAVM { namespace WASI {
    type WASI (line 28) | namespace WASI {
  function __wasi_errno_t (line 32) | static __wasi_errno_t asWASIErrNo(VFS::Result result)
  function __wasi_timestamp_t (line 76) | static __wasi_timestamp_t asWASITimestamp(I128 time)
  type LockedFDE (line 81) | struct LockedFDE
    method LockedFDE (line 89) | LockedFDE(__wasi_errno_t inError) : error(inError) {}
    method LockedFDE (line 90) | LockedFDE(const std::shared_ptr<FDE>& inFDE,
  function LockedFDE (line 97) | static LockedFDE getLockedFDE(Process* process,
    method LockedFDE (line 89) | LockedFDE(__wasi_errno_t inError) : error(inError) {}
    method LockedFDE (line 90) | LockedFDE(const std::shared_ptr<FDE>& inFDE,
  function __wasi_filetype_t (line 128) | static __wasi_filetype_t asWASIFileType(FileType type)
  function readUserString (line 146) | static bool readUserString(Memory* memory,
  function getCanonicalPath (line 176) | static bool getCanonicalPath(const std::string& basePath,
  function __wasi_errno_t (line 225) | static __wasi_errno_t validatePath(Process* process,
  function VFDFlags (line 258) | static VFDFlags translateWASIVFDFlags(__wasi_fdflags_t fdFlags, __wasi_r...
  function Result (line 286) | Result WASI::FDE::close()
  function __wasi_errno_t (line 411) | static __wasi_errno_t readImpl(Process* process,
  function __wasi_errno_t (line 473) | static __wasi_errno_t writeImpl(Process* process,
  function describeSeekWhence (line 704) | static std::string describeSeekWhence(U32 whence)
  function Uptr (line 1059) | static Uptr truncatingMemcpy(void* dest, const void* source, Uptr numSou...

FILE: Lib/WASI/WASIPrivate.h
  function namespace (line 56) | namespace WAVM { namespace VFS {
  function namespace (line 62) | namespace WAVM { namespace WASI {

FILE: Lib/WASM/WASMSerialization.cpp
  function throwIfNotValidUTF8 (line 26) | static void throwIfNotValidUTF8(const std::string& string)
  function WAVM_FORCEINLINE (line 35) | WAVM_FORCEINLINE void serializeOpcode(InputStream& stream, Opcode& opcode)
  function WAVM_FORCEINLINE (line 53) | WAVM_FORCEINLINE void serializeOpcode(OutputStream& stream, Opcode opcode)
  type WAVM (line 71) | namespace WAVM { namespace IR {
    type IR (line 71) | namespace IR {
      function ValueType (line 72) | static ValueType decodeValueType(Iptr encodedValueType)
      function I8 (line 86) | static I8 encodeValueType(ValueType valueType)
      function serialize (line 103) | static void serialize(InputStream& stream, ValueType& type)
      function serialize (line 109) | static void serialize(OutputStream& stream, ValueType type)
      function WAVM_FORCEINLINE (line 115) | WAVM_FORCEINLINE static void serialize(InputStream& stream, TypeTupl...
      function serialize (line 130) | static void serialize(OutputStream& stream, TypeTuple& typeTuple)
      function serializeIndex (line 138) | void serializeIndex(Stream& stream, U64& size, IndexType sizeType)
      function serialize (line 148) | void serialize(Stream& stream,
      function serialize (line 158) | void serialize(Stream& stream, ReferenceType& referenceType)
      function serialize (line 186) | void serialize(Stream& stream, TableType& tableType)
      function serialize (line 204) | void serialize(Stream& stream, MemoryType& memoryType)
      function serialize (line 220) | void serialize(Stream& stream, GlobalType& globalType)
      function serialize (line 228) | void serialize(Stream& stream, ExceptionType& exceptionType)
      function serialize (line 233) | static void serialize(InputStream& stream, ExternKind& kind)
      function serialize (line 247) | static void serialize(OutputStream& stream, ExternKind& kind)
      function serialize (line 263) | void serialize(Stream& stream, Export& e)
      function serialize (line 271) | void serialize(Stream& stream, InitializerExpression& initializer)
      function serialize (line 301) | void serialize(Stream& stream, TableDef& tableDef)
      function serialize (line 306) | void serialize(Stream& stream, MemoryDef& memoryDef)
      function serialize (line 311) | void serialize(Stream& stream, GlobalDef& globalDef)
      function serialize (line 317) | void serialize(Stream& stream, ExceptionTypeDef& exceptionTypeDef)
      function serialize (line 322) | void serialize(Stream& stream, ElemSegment& elemSegment)
      function serialize (line 424) | void serialize(Stream& stream, DataSegment& dataSegment)
    function serialize (line 762) | void serialize(Stream& stream, V128& v128)
  type SectionID (line 473) | enum class SectionID : U8
  function serialize (line 491) | static void serialize(InputStream& stream, SectionID& sectionID)
  function serialize (line 496) | static void serialize(OutputStream& stream, SectionID sectionID)
  type ModuleSerializationState (line 501) | struct ModuleSerializationState
    method ModuleSerializationState (line 507) | ModuleSerializationState(const Module& inModule) : module(inModule) {}
  function serialize (line 511) | void serialize(Stream& stream, NoImm&, const FunctionDef&, const ModuleS...
  function serialize (line 515) | static void serialize(InputStream& stream,
  function serialize (line 539) | static void serialize(OutputStream& stream,
  function serialize (line 558) | void serialize(Stream& stream, SelectImm& imm, const FunctionDef&, const...
  function serialize (line 570) | void serialize(Stream& stream, BranchImm& imm, const FunctionDef&, const...
  function serialize (line 575) | static void serialize(InputStream& stream,
  function serialize (line 588) | static void serialize(OutputStream& stream,
  function serialize (line 602) | void serialize(Stream& stream,
  function serialize (line 611) | void serialize(Stream& stream,
  function serialize (line 620) | void serialize(Stream& stream,
  function serialize (line 629) | void serialize(Stream& stream,
  function serialize (line 638) | void serialize(Stream& stream,
  function serialize (line 647) | void serialize(Stream& stream,
  function serialize (line 657) | void serialize(Stream& stream,
  function serialize (line 693) | void serialize(Stream& stream,
  function serializeMemoryIndex (line 703) | void serializeMemoryIndex(Stream& stream, Uptr& memoryIndex, const Featu...
  function serialize (line 715) | void serialize(Stream& stream,
  function serialize (line 723) | void serialize(Stream& stream,
  function serializeTableIndex (line 732) | void serializeTableIndex(Stream& stream, Uptr& tableIndex, const Feature...
  function serialize (line 744) | void serialize(Stream& stream,
  function serialize (line 752) | void serialize(Stream& stream,
  type WAVM (line 761) | namespace WAVM {
    type IR (line 71) | namespace IR {
      function ValueType (line 72) | static ValueType decodeValueType(Iptr encodedValueType)
      function I8 (line 86) | static I8 encodeValueType(ValueType valueType)
      function serialize (line 103) | static void serialize(InputStream& stream, ValueType& type)
      function serialize (line 109) | static void serialize(OutputStream& stream, ValueType type)
      function WAVM_FORCEINLINE (line 115) | WAVM_FORCEINLINE static void serialize(InputStream& stream, TypeTupl...
      function serialize (line 130) | static void serialize(OutputStream& stream, TypeTuple& typeTuple)
      function serializeIndex (line 138) | void serializeIndex(Stream& stream, U64& size, IndexType sizeType)
      function serialize (line 148) | void serialize(Stream& stream,
      function serialize (line 158) | void serialize(Stream& stream, ReferenceType& referenceType)
      function serialize (line 186) | void serialize(Stream& stream, TableType& tableType)
      function serialize (line 204) | void serialize(Stream& stream, MemoryType& memoryType)
      function serialize (line 220) | void serialize(Stream& stream, GlobalType& globalType)
      function serialize (line 228) | void serialize(Stream& stream, ExceptionType& exceptionType)
      function serialize (line 233) | static void serialize(InputStream& stream, ExternKind& kind)
      function serialize (line 247) | static void serialize(OutputStream& stream, ExternKind& kind)
      function serialize (line 263) | void serialize(Stream& stream, Export& e)
      function serialize (line 271) | void serialize(Stream& stream, InitializerExpression& initializer)
      function serialize (line 301) | void serialize(Stream& stream, TableDef& tableDef)
      function serialize (line 306) | void serialize(Stream& stream, MemoryDef& memoryDef)
      function serialize (line 311) | void serialize(Stream& stream, GlobalDef& globalDef)
      function serialize (line 317) | void serialize(Stream& stream, ExceptionTypeDef& exceptionTypeDef)
      function serialize (line 322) | void serialize(Stream& stream, ElemSegment& elemSegment)
      function serialize (line 424) | void serialize(Stream& stream, DataSegment& dataSegment)
    function serialize (line 762) | void serialize(Stream& stream, V128& v128)
  function serialize (line 769) | void serialize(Stream& stream,
  function serialize (line 778) | void serialize(Stream& stream,
  function serialize (line 790) | void serialize(Stream& stream,
  function serialize (line 811) | void serialize(Stream& stream,
  function serialize (line 820) | void serialize(Stream& stream, RethrowImm& imm, const FunctionDef&, cons...
  function serialize (line 826) | void serialize(Stream& stream,
  function serialize (line 842) | void serialize(Stream& stream,
  function serialize (line 857) | void serialize(Stream& stream,
  function serialize (line 867) | void serialize(Stream& stream,
  function serialize (line 876) | void serialize(Stream& stream,
  function serialize (line 885) | void serialize(Stream& stream,
  function serializeSection (line 894) | void serializeSection(OutputStream& stream, SectionID id, SerializeSecti...
  function serializeSection (line 905) | void serializeSection(InputStream& stream, SectionID id, SerializeSectio...
  function serialize (line 917) | static void serialize(OutputStream& stream, CustomSection& customSection)
  function serialize (line 927) | static void serialize(InputStream& stream, CustomSection& customSection)
  type LocalSet (line 940) | struct LocalSet
  function serialize (line 946) | void serialize(Stream& stream, LocalSet& localSet)
  type OperatorSerializerStream (line 952) | struct OperatorSerializerStream
    method OperatorSerializerStream (line 956) | OperatorSerializerStream(Serialization::OutputStream& inByteStream,
    method select (line 973) | void select(SelectImm imm) const
  function serializeFunctionBody (line 997) | static void serializeFunctionBody(OutputStream& sectionStream,
  function serializeFunctionBody (line 1041) | static void serializeFunctionBody(InputStream& sectionStream,
  function serializeCallingConvention (line 1114) | static void serializeCallingConvention(InputStream& stream, CallingConve...
  function serializeCallingConvention (line 1133) | static void serializeCallingConvention(OutputStream& stream, CallingConv...
  function serializeFunctionType (line 1150) | void serializeFunctionType(Stream& stream, FunctionType& functionType)
  function serializeTypeSection (line 1194) | void serializeTypeSection(Stream& moduleStream, Module& module)
  function serializeImportSection (line 1200) | void serializeImportSection(Stream& moduleStream, Module& module)
  function serializeFunctionSection (line 1335) | void serializeFunctionSection(Stream& moduleStream, Module& module)
  function serializeTableSection (line 1367) | void serializeTableSection(Stream& moduleStream, Module& module)
  function serializeMemorySection (line 1374) | void serializeMemorySection(Stream& moduleStream, Module& module)
  function serializeGlobalSection (line 1381) | void serializeGlobalSection(Stream& moduleStream, Module& module)
  function serializeExceptionTypeSection (line 1388) | void serializeExceptionTypeSection(Stream& moduleStream, Module& module)
  function serializeExportSection (line 1395) | void serializeExportSection(Stream& moduleStream, Module& module)
  function serializeStartSection (line 1402) | void serializeStartSection(Stream& moduleStream, Module& module)
  function serializeElementSection (line 1409) | void serializeElementSection(Stream& moduleStream, Module& module)
  function serializeCodeSection (line 1416) | static void serializeCodeSection(InputStream& moduleStream,
  function serializeCodeSection (line 1436) | void serializeCodeSection(OutputStream& moduleStream,
  function serializeDataCountSection (line 1451) | void serializeDataCountSection(Stream& moduleStream, Module& module)
  function serializeDataSection (line 1470) | void serializeDataSection(InputStream& moduleStream, Module& module, boo...
  function serializeDataSection (line 1499) | void serializeDataSection(OutputStream& moduleStream, Module& module)
  function serializeCustomSectionsAfterKnownSection (line 1506) | void serializeCustomSectionsAfterKnownSection(OutputStream& moduleStream,
  function serializeModule (line 1516) | static void serializeModule(OutputStream& moduleStream, Module& module)
  function serializeModule (line 1557) | static void serializeModule(InputStream& moduleStream, Module& module)

FILE: Lib/WASTParse/Lexer.cpp
  type WAVM (line 24) | namespace WAVM { namespace WAST {
    type WAST (line 24) | namespace WAST {
      type LineInfo (line 25) | struct LineInfo
        method LineInfo (line 34) | LineInfo(U32* inLineStarts, U32 inNumLineStarts)
  type StaticData (line 54) | struct StaticData
  function createTokenSeparatorPeekState (line 62) | static NFA::StateIndex createTokenSeparatorPeekState(NFA::Builder* builder,
  function addLiteralStringToNFA (line 83) | static void addLiteralStringToNFA(const char* string,
  function addLiteralTokenToNFA (line 102) | static void addLiteralTokenToNFA(const char* literalString,
  function StaticData (line 237) | StaticData& StaticData::get(bool allowLegacyInstructionNames)
  function isRecoveryPointChar (line 251) | inline bool isRecoveryPointChar(char c)
  function Token (line 267) | Token* WAST::lex(const char* string,
  function Uptr (line 437) | static Uptr getLineOffset(const LineInfo* lineInfo, Uptr lineIndex)
  function TextFileLocus (line 443) | TextFileLocus WAST::calcLocusFromOffset(const char* string,

FILE: Lib/WASTParse/Lexer.h
  function namespace (line 110) | namespace WAVM { namespace WAST {

FILE: Lib/WASTParse/Parse.cpp
  function parseErrorfImpl (line 51) | static void parseErrorfImpl(ParseState* parseState,
  function ValueType (line 129) | ValueType WAST::parseValueType(CursorState* cursor)
  function ReferenceType (line 156) | ReferenceType WAST::parseReferenceType(CursorState* cursor)
  function tryParseReferencedType (line 167) | static bool tryParseReferencedType(CursorState* cursor, IR::ReferenceTyp...
  function ReferenceType (line 183) | ReferenceType WAST::parseReferencedType(CursorState* cursor)
  function FunctionType (line 194) | FunctionType WAST::parseFunctionType(CursorState* cursor,
  function UnresolvedFunctionType (line 264) | UnresolvedFunctionType WAST::parseFunctionTypeRefAndOrDecl(
  function IndexedFunctionType (line 293) | IndexedFunctionType WAST::resolveFunctionType(ModuleState* moduleState,
  function IndexedFunctionType (line 332) | IndexedFunctionType WAST::getUniqueFunctionTypeIndex(ModuleState* module...
  function Name (line 442) | Name WAST::parseName(CursorState* cursor, const char* context)
  function Reference (line 453) | Reference WAST::parseNameOrIndexRef(CursorState* cursor, const char* con...
  function Uptr (line 464) | Uptr WAST::parseAndResolveNameOrIndexRef(CursorState* cursor,
  function Uptr (line 500) | Uptr WAST::resolveRef(ParseState* parseState,
  function Uptr (line 533) | Uptr WAST::resolveExternRef(ModuleState* moduleState, ExternKind externK...
  function parseCharEscapeCode (line 582) | static void parseCharEscapeCode(const char*& nextChar,
  function parseStringChars (line 669) | static void parseStringChars(const char*& nextChar, ParseState* parseSta...

FILE: Lib/WASTParse/Parse.h
  function namespace (line 19) | namespace WAVM { namespace WAST {
  type HashMap (line 101) | typedef HashMap<Name, Uptr, Name::HashPolicy> NameToIndexMap;
  type Reference (line 104) | struct Reference
  type UnresolvedFunctionType (line 127) | struct UnresolvedFunctionType
  type ModuleState (line 134) | struct ModuleState

FILE: Lib/WASTParse/ParseFunction.cpp
  type WAVM (line 23) | namespace WAVM { namespace WAST {
    type WAST (line 23) | namespace WAST {
      type ResumableCodeValidationProxyStream (line 25) | struct ResumableCodeValidationProxyStream
        method ResumableCodeValidationProxyStream (line 29) | ResumableCodeValidationProxyStream(ModuleState* moduleState,
  function finishValidation (line 76) | void finishValidation() { codeValidationStream.finish(); }
  type FunctionState (line 85) | struct FunctionState
    method FunctionState (line 100) | FunctionState(const std::shared_ptr<NameToIndexMap>& inLocalNameToInde...
  type ScopedBranchTarget (line 118) | struct ScopedBranchTarget
    method ScopedBranchTarget (line 120) | ScopedBranchTarget(FunctionState* inFunctionState, Name inName)
  function tryParseAndResolveBranchTargetRef (line 169) | static bool tryParseAndResolveBranchTargetRef(CursorState* cursor, Uptr&...
  function parseAndValidateRedundantBranchTargetName (line 200) | static void parseAndValidateRedundantBranchTargetName(CursorState* cursor,
  function parseImm (line 216) | static void parseImm(CursorState* cursor, NoImm&) {}
  function parseImm (line 217) | static void parseImm(CursorState* cursor, MemoryImm& outImm)
  function parseImm (line 228) | static void parseImm(CursorState* cursor, MemoryCopyImm& outImm)
  function parseImm (line 248) | static void parseImm(CursorState* cursor, TableImm& outImm)
  function parseImm (line 259) | static void parseImm(CursorState* cursor, TableCopyImm& outImm)
  function parseImm (line 280) | static void parseImm(CursorState* cursor, SelectImm& outImm)
  function parseImm (line 314) | static void parseImm(CursorState* cursor, LiteralImm<I32>& outImm)
  function parseImm (line 318) | static void parseImm(CursorState* cursor, LiteralImm<I64>& outImm)
  function parseImm (line 322) | static void parseImm(CursorState* cursor, LiteralImm<F32>& outImm)
  function parseImm (line 326) | static void parseImm(CursorState* cursor, LiteralImm<F64>& outImm)
  function parseImm (line 331) | static void parseImm(CursorState* cursor, BranchImm& outImm)
  function parseImm (line 340) | static void parseImm(CursorState* cursor, BranchTableImm& outImm)
  function parseImm (line 364) | static void parseImm(CursorState* cursor, GetOrSetVariableImm<isGlobal>&...
  function parseImm (line 374) | static void parseImm(CursorState* cursor, FunctionImm& outImm)
  function parseImm (line 383) | static void parseImm(CursorState* cursor, FunctionRefImm& outImm)
  function parseImm (line 392) | static void parseImm(CursorState* cursor, CallIndirectImm& outImm)
  function parseImm (line 428) | static void parseImm(CursorState* cursor, LoadOrStoreImm<naturalAlignmen...
  function isIntLiteral (line 473) | static bool isIntLiteral(TokenType tokenType)
  function parseImm (line 479) | static void parseImm(CursorState* cursor,
  function parseImm (line 545) | static void parseImm(CursorState* cursor, LiteralImm<V128>& outImm)
  function parseImm (line 550) | static void parseImm(CursorState* cursor, LaneIndexImm<numLanes>& outImm)
  function parseImm (line 564) | static void parseImm(CursorState* cursor, ShuffleImm<numLanes>& outImm)
  function parseImm (line 582) | static void parseImm(CursorState* cursor, AtomicLoadOrStoreImm<naturalAl...
  function parseImm (line 591) | static void parseImm(CursorState* cursor, AtomicFenceImm& outImm)
  function parseImm (line 596) | static void parseImm(CursorState* cursor, ExceptionTypeImm& outImm)
  function parseImm (line 604) | static void parseImm(CursorState* cursor, RethrowImm& outImm)
  function parseImm (line 613) | static void parseImm(CursorState* cursor, DataSegmentAndMemImm& outImm)
  function parseImm (line 638) | static void parseImm(CursorState* cursor, DataSegmentImm& outImm)
  function parseImm (line 647) | static void parseImm(CursorState* cursor, ElemSegmentAndTableImm& outImm)
  function parseImm (line 672) | static void parseImm(CursorState* cursor, ElemSegmentImm& outImm)
  function parseImm (line 681) | static void parseImm(CursorState* cursor, ReferenceTypeImm& outImm)
  function parseControlImm (line 689) | static void parseControlImm(CursorState* cursor,
  function checkRecursionDepth (line 760) | static void checkRecursionDepth(CursorState* cursor, Uptr depth)
  function WAVM_FORCENOINLINE (line 769) | static WAVM_FORCENOINLINE void parseBlock(CursorState* cursor, bool isEx...
  function WAVM_FORCENOINLINE (line 787) | static WAVM_FORCENOINLINE void parseLoop(CursorState* cursor, bool isExp...
  function WAVM_FORCENOINLINE (line 805) | static WAVM_FORCENOINLINE void parseIfInstr(CursorState* cursor, Uptr de...
  function WAVM_FORCENOINLINE (line 832) | static WAVM_FORCENOINLINE void parseIfExpr(CursorState* cursor, Uptr depth)
  function WAVM_FORCENOINLINE (line 879) | static WAVM_FORCENOINLINE void parseTryInstr(CursorState* cursor, Uptr d...
  function WAVM_FORCENOINLINE (line 922) | static WAVM_FORCENOINLINE void parseExprSequence(CursorState* cursor, Up...
  function parseExpr (line 942) | static void parseExpr(CursorState* cursor, Uptr depth)
  function parseInstrSequence (line 990) | static void parseInstrSequence(CursorState* cursor, Uptr depth)
  function FunctionDef (line 1063) | FunctionDef WAST::parseFunctionDef(CursorState* cursor, const Token* fun...

FILE: Lib/WASTParse/ParseModule.cpp
  function tryParseSizeConstraints (line 24) | static bool tryParseSizeConstraints(CursorState* cursor,
  function IndexType (line 67) | static IndexType parseOptionalIndexType(CursorState* cursor)
  function SizeConstraints (line 85) | static SizeConstraints parseSizeConstraints(CursorState* cursor, U64 max...
  function GlobalType (line 95) | static GlobalType parseGlobalType(CursorState* cursor)
  function TypeTuple (line 104) | static TypeTuple parseTypeTuple(CursorState* cursor)
  function UnresolvedInitializerExpression (line 116) | static UnresolvedInitializerExpression parseInitializerInstruction(Curso...
  function UnresolvedInitializerExpression (line 183) | static UnresolvedInitializerExpression parseInitializerExpression(Cursor...
  function InitializerExpression (line 200) | static InitializerExpression resolveInitializerExpression(
  function errorIfFollowsDefinitions (line 235) | static void errorIfFollowsDefinitions(CursorState* cursor)
  function Uptr (line 249) | static Uptr createImport(CursorState* cursor,
  function parseOptionalSharedDeclaration (line 267) | static bool parseOptionalSharedDeclaration(CursorState* cursor)
  function parseImport (line 280) | static void parseImport(CursorState* cursor)
  function tryParseExternKind (line 399) | static bool tryParseExternKind(CursorState* cursor, ExternKind& outKind)
  function parseExport (line 427) | static void parseExport(CursorState* cursor)
  function parseType (line 458) | static void parseType(CursorState* cursor)
  function parseData (line 483) | static void parseData(CursorState* cursor)
  type UnresolvedElem (line 575) | struct UnresolvedElem
    method UnresolvedElem (line 583) | UnresolvedElem(Reference&& inRef = Reference(),
    method UnresolvedElem (line 589) | UnresolvedElem(ReferenceType inNullReferenceType)
  function UnresolvedElem (line 595) | static UnresolvedElem parseElemSegmentInstr(CursorState* cursor)
    method UnresolvedElem (line 583) | UnresolvedElem(Reference&& inRef = Reference(),
    method UnresolvedElem (line 589) | UnresolvedElem(ReferenceType inNullReferenceType)
  function UnresolvedElem (line 624) | static UnresolvedElem parseElemSegmentExpr(CursorState* cursor)
    method UnresolvedElem (line 583) | UnresolvedElem(Reference&& inRef = Reference(),
    method UnresolvedElem (line 589) | UnresolvedElem(ReferenceType inNullReferenceType)
  function UnresolvedElem (line 635) | static UnresolvedElem parseElemSegmentItemExpr(CursorState* cursor)
    method UnresolvedElem (line 583) | UnresolvedElem(Reference&& inRef = Reference(),
    method UnresolvedElem (line 589) | UnresolvedElem(ReferenceType inNullReferenceType)
  function Uptr (line 652) | static Uptr parseElemSegmentBody(CursorState* cursor,
  function parseElem (line 786) | static void parseElem(CursorState* cursor)
  function parseObjectDefOrImport (line 859) | static void parseObjectDefOrImport(CursorState* cursor,
  function parseFunc (line 915) | static void parseFunc(CursorState* cursor)
  function parseTable (line 943) | static void parseTable(CursorState* cursor)
  function parseMemory (line 1015) | static void parseMemory(CursorState* cursor)
  function parseGlobal (line 1067) | static void parseGlobal(CursorState* cursor)
  function parseExceptionType (line 1100) | static void parseExceptionType(CursorState* cursor)
  function parseStart (line 1121) | static void parseStart(CursorState* cursor)
  function OrderedSectionID (line 1151) | static OrderedSectionID parseOrderedSectionID(CursorState* cursor)
  function parseCustomSection (line 1196) | static void parseCustomSection(CursorState* cursor)
  function parseDeclaration (line 1297) | static void parseDeclaration(CursorState* cursor)

FILE: Lib/WASTParse/ParseNumbers.cpp
  function parseSign (line 18) | static bool parseSign(const char*& nextChar)
  function U64 (line 32) | static U64 parseHexUnsignedInt(const char*& nextChar, ParseState* parseS...
  function U64 (line 64) | static U64 parseDecimalUnsignedInt(const char*& nextChar,
  function Float (line 99) | Float parseNaN(const char*& nextChar, ParseState* parseState)
  function Float (line 137) | Float parseInfinity(const char* nextChar)
  function F32 (line 149) | F32 strtox(const char* firstChar, char** endChar) { return strtof(firstC...
  function F64 (line 150) | F64 strtox(const char* firstChar, char** endChar) { return strtod(firstC...
  function Float (line 154) | Float parseDecimalFloat(const char*& nextChar, ParseState* parseState)
  function roundSignificand (line 205) | static bool roundSignificand(U64& significand64, bool hasNonZeroTailBits...
  function Float (line 224) | Float parseHexFloat(const char*& nextChar, ParseState* parseState)
  function tryParseInt (line 373) | bool tryParseInt(CursorState* cursor,
  function tryParseFloat (line 416) | bool tryParseFloat(CursorState* cursor, Float& outFloat)
  function U8 (line 448) | U8 WAST::parseU8(CursorState* cursor, bool allowSign)
  function U32 (line 459) | U32 WAST::parseU32(CursorState* cursor)
  function U64 (line 470) | U64 WAST::parseU64(CursorState* cursor)
  function I8 (line 481) | I8 WAST::parseI8(CursorState* cursor)
  function I16 (line 492) | I16 WAST::parseI16(CursorState* cursor)
  function I32 (line 503) | I32 WAST::parseI32(CursorState* cursor)
  function I64 (line 514) | I64 WAST::parseI64(CursorState* cursor)
  function F32 (line 525) | F32 WAST::parseF32(CursorState* cursor)
  function F64 (line 536) | F64 WAST::parseF64(CursorState* cursor)
  function V128 (line 547) | V128 WAST::parseV128(CursorState* cursor)

FILE: Lib/WASTParse/ParseTests.cpp
  type HostRef (line 27) | struct HostRef
    method HostRef (line 30) | HostRef() : function(nullptr) {}
    method HostRef (line 40) | HostRef(HostRef&& movee) noexcept
  function parseConstExpression (line 69) | static IR::Value parseConstExpression(CursorState* cursor)
  function parseConstExpressionTuple (line 121) | static std::vector<IR::Value> parseConstExpressionTuple(CursorState* cur...
  function parseFloatResultSet (line 131) | FloatResultSet<Float> parseFloatResultSet(CursorState* cursor)
  function ResultSet (line 155) | static ResultSet parseV128ResultSet(CursorState* cursor)
  function ResultSet (line 218) | static ResultSet parseResultSet(CursorState* cursor)
  function parseResultSetTuple (line 289) | static std::vector<ResultSet> parseResultSetTuple(CursorState* cursor)
  function parseOptionalNameAsString (line 299) | static std::string parseOptionalNameAsString(CursorState* cursor)
  function parseTestScriptModule (line 305) | static void parseTestScriptModule(CursorState* cursor,
  function parseAction (line 384) | static std::unique_ptr<Action> parseAction(CursorState* cursor, const IR...
  function stringStartsWith (line 441) | static bool stringStartsWith(const char* string, const char (&prefix)[nu...
  function parseCommand (line 446) | static std::unique_ptr<Command> parseCommand(CursorState* cursor,

FILE: Lib/WASTPrint/Print.cpp
  function nibbleToHexChar (line 25) | static char nibbleToHexChar(U8 value) { return value < 10 ? ('0' + value...
  function escapeString (line 27) | static std::string escapeString(const char* string, Uptr numChars)
  function escapeString (line 50) | static std::string escapeString(const std::string& string)
  function escapeName (line 55) | static std::string escapeName(const std::string& name)
  function hasNonNameChars (line 79) | static bool hasNonNameChars(const std::string& name)
  function expandIndentation (line 88) | static std::string expandIndentation(std::string&& inString, U8 spacesPe...
  type ScopedTagPrinter (line 127) | struct ScopedTagPrinter
    method ScopedTagPrinter (line 129) | ScopedTagPrinter(std::string& inString, const char* tag) : string(inSt...
  function print (line 142) | static void print(std::string& string, ValueType type) { string += asStr...
  function print (line 144) | static void print(std::string& string, const SizeConstraints& size)
  function print (line 154) | static void print(std::string& string, FunctionType functionType)
  function print (line 194) | static void print(std::string& string, ReferenceType type)
  function print (line 206) | static void print(std::string& string, IndexType type)
  function print (line 216) | static void print(std::string& string, const TableType& type)
  function print (line 230) | static void print(std::string& string, const MemoryType& type)
  function print (line 242) | static void print(std::string& string, GlobalType type)
  function print (line 250) | static void print(std::string& string, const ExceptionType& type)
  function printReferencedType (line 259) | static void printReferencedType(std::string& string, const ReferenceType...
  type NameScope (line 270) | struct NameScope
    method NameScope (line 272) | NameScope(const char inSigil, bool inAllowQuotedNames, Uptr estimatedN...
    method map (line 280) | void map(std::string& name)
  type ModulePrintContext (line 312) | struct ModulePrintContext
    method ModulePrintContext (line 319) | ModulePrintContext(const Module& inModule, std::string& inString)
    method printInitializerExpression (line 351) | void printInitializerExpression(const InitializerExpression& expression)
  type FunctionPrintContext (line 388) | struct FunctionPrintContext
    method FunctionPrintContext (line 403) | FunctionPrintContext(ModulePrintContext& inModuleContext, Uptr functio...
    method block (line 420) | void block(ControlStructureImm imm)
    method loop (line 427) | void loop(ControlStructureImm imm)
    method if_ (line 434) | void if_(ControlStructureImm imm)
    method else_ (line 441) | void else_(NoImm imm)
    method end (line 447) | void end(NoImm)
    method return_ (line 458) | void return_(NoImm)
    method br (line 464) | void br(BranchImm imm)
    method br_table (line 469) | void br_table(BranchTableImm imm)
    method br_if (line 490) | void br_if(BranchImm imm) { string += "\nbr_if " + getBranchTargetId(i...
    method unreachable (line 492) | void unreachable(NoImm)
    method drop (line 497) | void drop(NoImm) { string += "\ndrop"; }
    method select (line 499) | void select(SelectImm imm)
    method local_get (line 510) | void local_get(GetOrSetVariableImm<false> imm)
    method local_set (line 514) | void local_set(GetOrSetVariableImm<false> imm)
    method local_tee (line 518) | void local_tee(GetOrSetVariableImm<false> imm)
    method global_get (line 523) | void global_get(GetOrSetVariableImm<true> imm)
    method global_set (line 527) | void global_set(GetOrSetVariableImm<true> imm)
    method table_get (line 532) | void table_get(TableImm imm)
    method table_set (line 536) | void table_set(TableImm imm)
    method table_grow (line 540) | void table_grow(TableImm imm)
    method table_fill (line 544) | void table_fill(TableImm imm)
    method throw_ (line 549) | void throw_(ExceptionTypeImm imm)
    method rethrow (line 554) | void rethrow(RethrowImm imm)
    method ref_null (line 562) | void ref_null(ReferenceTypeImm imm)
    method ref_is_null (line 568) | void ref_is_null(NoImm) { string += "\nref.is_null"; }
    method call (line 570) | void call(FunctionImm imm)
    method call_indirect (line 574) | void call_indirect(CallIndirectImm imm)
    method printControlSignature (line 580) | void printControlSignature(IndexedBlockType indexedSignature)
    method printImm (line 586) | void printImm(NoImm) {}
    method printImm (line 587) | void printImm(MemoryImm imm)
    method printImm (line 595) | void printImm(MemoryCopyImm imm)
    method printImm (line 608) | void printImm(TableImm imm)
    method printImm (line 613) | void printImm(TableCopyImm imm)
    method printImm (line 626) | void printImm(FunctionImm imm)
    method printImm (line 631) | void printImm(FunctionRefImm imm)
    method printImm (line 637) | void printImm(LiteralImm<I32> imm)
    method printImm (line 642) | void printImm(LiteralImm<I64> imm)
    method printImm (line 647) | void printImm(LiteralImm<F32> imm)
    method printImm (line 652) | void printImm(LiteralImm<F64> imm)
    method printImm (line 658) | void printImm(LoadOrStoreImm<naturalAlignmentLog2> imm)
    method printImm (line 678) | void printImm(LoadOrStoreLaneImm<naturalAlignmentLog2, numLanes> imm)
    method printImm (line 685) | void printImm(LiteralImm<V128> imm)
    method printImm (line 691) | void printImm(LaneIndexImm<numLanes> imm)
    method printImm (line 697) | void printImm(ShuffleImm<numLanes> imm)
    method printImm (line 707) | void printImm(AtomicLoadOrStoreImm<naturalAlignmentLog2> imm)
    method printImm (line 722) | void printImm(AtomicFenceImm imm)
    method printImm (line 731) | void printImm(DataSegmentAndMemImm imm)
    method printImm (line 736) | void printImm(DataSegmentImm imm)
    method printImm (line 741) | void printImm(ElemSegmentAndTableImm imm)
    method printImm (line 746) | void printImm(ElemSegmentImm imm)
    method try_ (line 751) | void try_(ControlStructureImm imm)
    method catch_ (line 758) | void catch_(ExceptionTypeImm imm)
    method catch_all (line 766) | void catch_all(NoImm)
    type ControlContext (line 785) | struct ControlContext
      type Type (line 787) | enum class Type : U8
    method getBranchTargetId (line 803) | std::string getBranchTargetId(Uptr depth)
    method printControlLabel (line 810) | std::string printControlLabel(const char* labelIdBase)
    method pushControlStack (line 820) | void pushControlStack(ControlContext::Type type, std::string labelId)
    method enterUnreachable (line 826) | void enterUnreachable() {}
  function printImportType (line 829) | void printImportType(std::string& string, const Module& module, Type type)
  function printImport (line 842) | void printImport(std::string& string,
  type LinkingSubsectionType (line 1277) | enum class LinkingSubsectionType
  type COMDATKind (line 1286) | enum class COMDATKind
  type SymbolKind (line 1293) | enum class SymbolKind

FILE: Lib/wavm-c/wavm-c.cpp
  type wasm_config_t (line 51) | struct wasm_config_t
  type wasm_engine_t (line 52) | struct wasm_engine_t
  type wasm_valtype_t (line 53) | struct wasm_valtype_t
  type wasm_functype_t (line 54) | struct wasm_functype_t
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  type wasm_tabletype_t (line 55) | struct wasm_tabletype_t
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  type wasm_memorytype_t (line 56) | struct wasm_memorytype_t
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  type wasm_globaltype_t (line 57) | struct wasm_globaltype_t
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  type wasm_externtype_t (line 58) | struct wasm_externtype_t
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  type wasm_module_t (line 60) | struct wasm_module_t
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  type wasm_module_t (line 61) | struct wasm_module_t
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  type wasm_config_t (line 67) | struct wasm_config_t
  type wasm_engine_t (line 72) | struct wasm_engine_t
  type wasm_valtype_t (line 77) | struct wasm_valtype_t
  type wasm_externtype_t (line 82) | struct wasm_externtype_t
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  type wasm_functype_t (line 87) | struct wasm_functype_t : wasm_externtype_t
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  type wasm_globaltype_t (line 93) | struct wasm_globaltype_t : wasm_externtype_t
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  type wasm_tabletype_t (line 103) | struct wasm_tabletype_t : wasm_externtype_t
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  type wasm_memorytype_t (line 114) | struct wasm_memorytype_t : wasm_externtype_t
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  type wasm_module_t (line 124) | struct wasm_module_t
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  function wasm_index_t (line 131) | static wasm_index_t as_index(IndexType indexType)
  function wasm_limits_t (line 140) | static wasm_limits_t as_limits(const SizeConstraints& size)
  function wasm_functype_t (line 146) | static wasm_functype_t* as_externtype(FunctionType type) { return new wa...
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_tabletype_t (line 147) | static wasm_tabletype_t* as_externtype(TableType type)
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_memorytype_t (line 152) | static wasm_memorytype_t* as_externtype(MemoryType type)
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_globaltype_t (line 156) | static wasm_globaltype_t* as_externtype(GlobalType type)
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_externtype_t (line 160) | static wasm_externtype_t* as_externtype(ExternType type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function IndexType (line 176) | static IndexType asIndexType(wasm_index_t index)
  function ValueType (line 185) | static ValueType asValueType(wasm_valkind_t kind)
  function Value (line 199) | static Value asValue(ValueType type, const wasm_val_t* value)
  function wasm_val_t (line 222) | static wasm_val_t as_val(const Value& value)
  function wasm_config_delete (line 249) | void wasm_config_delete(wasm_config_t* config) { delete config; }
  function wasm_config_t (line 250) | wasm_config_t* wasm_config_new() { return new wasm_config_t; }
  function wasm_engine_t (line 278) | wasm_engine_t* wasm_engine_new() { return new wasm_engine_t; }
  function wasm_engine_t (line 279) | wasm_engine_t* wasm_engine_new_with_config(wasm_config_t* config)
  function wasm_engine_delete (line 285) | void wasm_engine_delete(wasm_engine_t* engine) { delete engine; }
  function wasm_compartment_delete (line 288) | void wasm_compartment_delete(wasm_compartment_t* compartment)
  function wasm_compartment_t (line 294) | wasm_compartment_t* wasm_compartment_new(wasm_engine_t*, const char* deb...
  function wasm_compartment_t (line 300) | wasm_compartment_t* wasm_compartment_clone(const wasm_compartment_t* com...
  function wasm_compartment_contains (line 306) | bool wasm_compartment_contains(const wasm_compartment_t* compartment, co...
  function wasm_store_delete (line 312) | void wasm_store_delete(wasm_store_t* store) { removeGCRoot(store); }
  function wasm_store_t (line 313) | wasm_store_t* wasm_store_new(wasm_compartment_t* compartment, const char...
  function wasm_valtype_delete (line 321) | void wasm_valtype_delete(wasm_valtype_t* type) { delete type; }
  function wasm_valtype_t (line 322) | wasm_valtype_t* wasm_valtype_copy(wasm_valtype_t* type) { return new was...
  function wasm_valtype_t (line 323) | wasm_valtype_t* wasm_valtype_new(wasm_valkind_t kind)
  function wasm_valkind_t (line 328) | wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t* type)
  function wasm_functype_delete (line 347) | void wasm_functype_delete(wasm_functype_t* type) { delete type; }
  function wasm_functype_t (line 348) | wasm_functype_t* wasm_functype_copy(wasm_functype_t* type)
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_functype_t (line 352) | wasm_functype_t* wasm_functype_new(wasm_valtype_t** params,
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_functype_num_params (line 373) | size_t wasm_functype_num_params(const wasm_functype_t* type) { return ty...
  function wasm_valtype_t (line 374) | wasm_valtype_t* wasm_functype_param(const wasm_functype_t* type, size_t ...
  function wasm_functype_num_results (line 378) | size_t wasm_functype_num_results(const wasm_functype_t* type)
  function wasm_valtype_t (line 382) | wasm_valtype_t* wasm_functype_result(const wasm_functype_t* type, size_t...
  function wasm_globaltype_delete (line 388) | void wasm_globaltype_delete(wasm_globaltype_t* type)
  function wasm_globaltype_t (line 393) | wasm_globaltype_t* wasm_globaltype_copy(wasm_globaltype_t* type)
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_globaltype_t (line 397) | wasm_globaltype_t* wasm_globaltype_new(wasm_valtype_t* valtype, wasm_mut...
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_valtype_t (line 401) | const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t* t...
  function wasm_mutability_t (line 405) | wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t* type)
  function wasm_tabletype_delete (line 411) | void wasm_tabletype_delete(wasm_tabletype_t* type)
  function wasm_tabletype_t (line 416) | wasm_tabletype_t* wasm_tabletype_copy(wasm_tabletype_t* type)
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_tabletype_t (line 420) | wasm_tabletype_t* wasm_tabletype_new(wasm_valtype_t* element,
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_valtype_t (line 433) | const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t* typ...
  function wasm_limits_t (line 434) | const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t* type)...
  function wasm_shared_t (line 435) | wasm_shared_t wasm_tabletype_shared(const wasm_tabletype_t* type)
  function wasm_index_t (line 439) | wasm_index_t wasm_tabletype_index(const wasm_tabletype_t* type)
  function wasm_memorytype_delete (line 445) | void wasm_memorytype_delete(wasm_memorytype_t* type) { delete type; }
  function wasm_memorytype_t (line 446) | wasm_memorytype_t* wasm_memorytype_copy(wasm_memorytype_t* type)
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_memorytype_t (line 450) | wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t* limits,
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_limits_t (line 459) | const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t* typ...
  function wasm_shared_t (line 460) | wasm_shared_t wasm_memorytype_shared(const wasm_memorytype_t* type)
  function wasm_index_t (line 464) | wasm_index_t wasm_memorytype_index(const wasm_memorytype_t* type)
  function wasm_externtype_delete (line 470) | void wasm_externtype_delete(wasm_externtype_t* type)
  function wasm_externtype_t (line 484) | wasm_externtype_t* wasm_externtype_copy(wasm_externtype_t* type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externkind_t (line 505) | wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t* type)
  function wasm_externtype_t (line 519) | wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t* type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 523) | wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t* type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 527) | wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t* type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 531) | wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t* type)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_functype_t (line 535) | wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t* type)
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_globaltype_t (line 539) | wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t* type)
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_tabletype_t (line 543) | wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t* type)
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_memorytype_t (line 547) | wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t* type)
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_externtype_t (line 551) | const wasm_externtype_t* wasm_functype_as_externtype_const(const wasm_fu...
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 555) | const wasm_externtype_t* wasm_globaltype_as_externtype_const(const wasm_...
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 559) | const wasm_externtype_t* wasm_tabletype_as_externtype_const(const wasm_t...
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_externtype_t (line 563) | const wasm_externtype_t* wasm_memorytype_as_externtype_const(const wasm_...
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_functype_t (line 567) | const wasm_functype_t* wasm_externtype_as_functype_const(const wasm_exte...
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_globaltype_t (line 571) | const wasm_globaltype_t* wasm_externtype_as_globaltype_const(const wasm_...
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_tabletype_t (line 575) | const wasm_tabletype_t* wasm_externtype_as_tabletype_const(const wasm_ex...
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_memorytype_t (line 579) | const wasm_memorytype_t* wasm_externtype_as_memorytype_const(const wasm_...
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_trap_delete (line 655) | void wasm_trap_delete(wasm_trap_t* trap) { destroyException(trap); }
  function wasm_trap_t (line 657) | wasm_trap_t* wasm_trap_copy(const wasm_trap_t* trap) { return new Except...
  function wasm_trap_same (line 658) | bool wasm_trap_same(const wasm_trap_t* a, const wasm_trap_t* b) { return...
  function wasm_trap_set_host_info (line 661) | void wasm_trap_set_host_info(wasm_trap_t* trap, void* userData)
  function wasm_trap_set_host_info_with_finalizer (line 665) | void wasm_trap_set_host_info_with_finalizer(wasm_trap_t* trap,
  function wasm_ref_t (line 672) | wasm_ref_t* wasm_trap_as_ref(wasm_trap_t* trap) { Errors::unimplemented(...
  function wasm_trap_t (line 673) | wasm_trap_t* wasm_ref_as_trap(wasm_ref_t* object) { Errors::unimplemente...
  function wasm_ref_t (line 674) | const wasm_ref_t* wasm_trap_as_ref_const(const wasm_trap_t*)
  function wasm_trap_t (line 678) | const wasm_trap_t* wasm_ref_as_trap_const(const wasm_ref_t*)
  function WAVM_FORCENOINLINE (line 683) | WAVM_FORCENOINLINE wasm_trap_t* wasm_trap_new(wasm_compartment_t* compar...
  function wasm_trap_message (line 692) | bool wasm_trap_message(const wasm_trap_t* trap, char* out_message, size_...
  function wasm_trap_stack_num_frames (line 709) | size_t wasm_trap_stack_num_frames(const wasm_trap_t* trap)
  function wasm_trap_stack_frame (line 713) | void wasm_trap_stack_frame(const wasm_trap_t* trap, size_t index, wasm_f...
  function wasm_foreign_t (line 732) | wasm_foreign_t* wasm_foreign_new(wasm_compartment_t* compartment, const ...
  function wasm_val_delete (line 740) | void wasm_val_delete(wasm_valkind_t kind, wasm_val_t* val) {}
  function wasm_val_copy (line 741) | void wasm_val_copy(wasm_valkind_t kind, wasm_val_t* out, const wasm_val_...
  function wasm_module_delete (line 747) | void wasm_module_delete(wasm_module_t* module) { delete module; }
  function wasm_module_t (line 748) | wasm_module_t* wasm_module_copy(wasm_module_t* module) { return new wasm...
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  function wasm_module_t (line 749) | wasm_module_t* wasm_module_new(wasm_engine_t* engine, const char* wasmBy...
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  function wasm_module_t (line 764) | wasm_module_t* wasm_module_new_text(wasm_engine_t* engine, const char* t...
    method wasm_module_t (line 128) | wasm_module_t(ModuleRef inModule) : module(inModule) {}
  function wasm_module_validate (line 796) | bool wasm_module_validate(const char* binary, size_t numBinaryBytes)
  function wasm_module_num_imports (line 811) | size_t wasm_module_num_imports(const wasm_module_t* module)
  function wasm_module_import (line 815) | void wasm_module_import(const wasm_module_t* module, size_t index, wasm_...
  function wasm_module_num_exports (line 865) | size_t wasm_module_num_exports(const wasm_module_t* module)
  function wasm_module_export (line 869) | void wasm_module_export(const wasm_module_t* module, size_t index, wasm_...
  function wasm_func_t (line 902) | wasm_func_t* wasm_func_new(wasm_compartment_t* compartment,
  function wasm_func_t (line 917) | wasm_func_t* wasm_func_new_with_env(wasm_compartment_t*,
  function wasm_functype_t (line 926) | wasm_functype_t* wasm_func_type(const wasm_func_t* function)
    method wasm_functype_t (line 91) | wasm_functype_t(FunctionType inType) : wasm_externtype_t(ExternKind::f...
  function wasm_func_param_arity (line 930) | size_t wasm_func_param_arity(const wasm_func_t* function)
  function wasm_func_result_arity (line 934) | size_t wasm_func_result_arity(const wasm_func_t* function)
  function wasm_trap_t (line 939) | wasm_trap_t* wasm_func_call(wasm_store_t* store,
  function wasm_global_t (line 973) | wasm_global_t* wasm_global_new(wasm_compartment_t* compartment,
  function wasm_globaltype_t (line 984) | wasm_globaltype_t* wasm_global_type(const wasm_global_t* global)
    method wasm_globaltype_t (line 98) | wasm_globaltype_t(GlobalType inType, wasm_valtype_t* inValtype)
  function wasm_global_get (line 989) | void wasm_global_get(wasm_store_t* store, const wasm_global_t* global, w...
  function wasm_global_set (line 994) | void wasm_global_set(wasm_store_t* store, wasm_global_t* global, const w...
  function wasm_table_t (line 1002) | wasm_table_t* wasm_table_new(wasm_compartment_t* compartment,
  function wasm_tabletype_t (line 1012) | wasm_tabletype_t* wasm_table_type(const wasm_table_t* table)
    method wasm_tabletype_t (line 109) | wasm_tabletype_t(TableType inType, wasm_valtype_t* inElement, wasm_lim...
  function wasm_ref_t (line 1017) | wasm_ref_t* wasm_table_get(const wasm_table_t* table, wasm_table_size_t ...
  function wasm_table_set (line 1021) | bool wasm_table_set(wasm_table_t* table, wasm_table_size_t index, wasm_r...
  function wasm_table_size_t (line 1029) | wasm_table_size_t wasm_table_size(const wasm_table_t* table)
  function wasm_table_grow (line 1036) | bool wasm_table_grow(wasm_table_t* table,
  function wasm_memory_t (line 1054) | wasm_memory_t* wasm_memory_new(wasm_compartment_t* compartment,
  function wasm_memorytype_t (line 1063) | wasm_memorytype_t* wasm_memory_type(const wasm_memory_t* memory)
    method wasm_memorytype_t (line 119) | wasm_memorytype_t(MemoryType inType, wasm_limits_t inLimits)
  function wasm_memory_data_size (line 1069) | size_t wasm_memory_data_size(const wasm_memory_t* memory)
  function wasm_memory_pages_t (line 1074) | wasm_memory_pages_t wasm_memory_size(const wasm_memory_t* memory)
  function wasm_memory_grow (line 1080) | bool wasm_memory_grow(wasm_memory_t* memory,
  function wasm_externkind_t (line 1097) | wasm_externkind_t wasm_extern_kind(const wasm_extern_t* object)
  function wasm_externtype_t (line 1115) | wasm_externtype_t* wasm_extern_type(const wasm_extern_t* object)
    method wasm_externtype_t (line 85) | wasm_externtype_t(ExternKind inKind) : kind(inKind) {}
  function wasm_instance_t (line 1138) | wasm_instance_t* wasm_instance_new(wasm_store_t* store,
  function wasm_instance_delete (line 1178) | void wasm_instance_delete(wasm_instance_t* instance) { removeGCRoot(inst...
  function wasm_instance_num_exports (line 1180) | size_t wasm_instance_num_exports(const wasm_instance_t* instance)
  function wasm_extern_t (line 1185) | wasm_extern_t* wasm_instance_export(const wasm_instance_t* instance, siz...

FILE: Programs/wavm/Testing/Benchmark.cpp
  function getFilenameAndExtension (line 32) | static std::string getFilenameAndExtension(const char* path)
  function showBenchmarkHelp (line 45) | void showBenchmarkHelp(WAVM::Log::Category outputCategory)
  function execBenchmark (line 59) | int execBenchmark(int argc, char** argv)

FILE: Programs/wavm/Testing/DumpTestModules.cpp
  type DumpFormat (line 23) | enum class DumpFormat
  function dumpWAST (line 30) | static void dumpWAST(const std::string& wastString, const char* outputDir)
  function dumpWASM (line 38) | static void dumpWASM(const U8* wasmBytes, Uptr numBytes, const char* out...
  function dumpModule (line 46) | static void dumpModule(const Module& module, const char* outputDir, Dump...
  function dumpCommandModules (line 61) | static void dumpCommandModules(const char* filename,
  function execDumpTestModules (line 144) | int execDumpTestModules(int argc, char** argv)

FILE: Programs/wavm/Testing/RunTestScript.cpp
  type Config (line 53) | struct Config
  type TestScriptStateKind (line 64) | enum class TestScriptStateKind
  type TestScriptState (line 70) | struct TestScriptState
    type TestScriptThread (line 86) | struct TestScriptThread
    method TestScriptState (line 88) | TestScriptState(const char* inScriptFilename, const Config& inConfig)
    method TestScriptState (line 99) | TestScriptState(TestScriptState&& movee) noexcept
    method TestScriptState (line 112) | TestScriptState forkThread() const
    method TestScriptState (line 123) | TestScriptState* clone() const
    method TestScriptState (line 174) | TestScriptState(const char* inScriptFilename,
    method addIntrinsicModules (line 181) | void addIntrinsicModules()
  type TestScriptThread (line 191) | struct TestScriptThread
  type TestScriptResolver (line 198) | struct TestScriptResolver : Resolver
    method TestScriptResolver (line 200) | TestScriptResolver(const TestScriptState& inState) : state(inState) {}
    method resolve (line 201) | bool resolve(const std::string& moduleName,
  function testErrorf (line 221) | static void testErrorf(TestScriptState& state,
  function Instance (line 251) | static Instance* getModuleContextByInternalName(TestScriptState& state,
  function describeExpectedTrapType (line 313) | static std::string describeExpectedTrapType(WAST::ExpectedTrapType expec...
  function isExpectedExceptionType (line 322) | static bool isExpectedExceptionType(WAST::ExpectedTrapType expectedType,
  function traceLLVMIR (line 349) | static void traceLLVMIR(const char* moduleName, const IR::Module& irModule)
  function traceAssembly (line 356) | static void traceAssembly(const char* moduleName, ModuleConstRefParam co...
  function maybeCollectGarbage (line 366) | static void maybeCollectGarbage(TestScriptState& state)
  function processAction (line 376) | static bool processAction(TestScriptState& state, Action* action, std::v...
  function isArithmeticNaN (line 531) | bool isArithmeticNaN(Float value)
  function isCanonicalNaN (line 540) | bool isCanonicalNaN(Float value)
  function isFloatResultInExpectedSet (line 549) | bool isFloatResultInExpectedSet(Float result, const FloatResultSet<Float...
  function isResultInExpectedSet (line 562) | static bool isResultInExpectedSet(const Value& result, const ResultSet& ...
  function asString (line 613) | std::string asString(const FloatResultSet<Float> resultSet)
  function asString (line 625) | static std::string asString(const ResultSet& resultSet)
  function ResultSet (line 732) | static ResultSet asResultSet(const Value& value, ResultSet::Type expecte...
  function areResultsInExpectedSet (line 806) | static bool areResultsInExpectedSet(const std::vector<Value>& results,
  function processRegister (line 832) | static void processRegister(TestScriptState& state, const RegisterComman...
  function processAssertReturn (line 840) | static void processAssertReturn(TestScriptState& state, const AssertRetu...
  function processAssertReturnNaN (line 852) | static void processAssertReturnNaN(TestScriptState& state,
  function processAssertReturnFunc (line 927) | static void processAssertReturnFunc(TestScriptState& state,
  function processAssertTrap (line 945) | static void processAssertTrap(TestScriptState& state, const AssertTrapCo...
  function processAssertThrows (line 971) | static void processAssertThrows(TestScriptState& state, const AssertThro...
  function processAssertInvalid (line 1042) | static void processAssertInvalid(TestScriptState& state,
  function processAssertMalformed (line 1062) | static void processAssertMalformed(TestScriptState& state,
  function processAssertUnlinkable (line 1083) | static void processAssertUnlinkable(TestScriptState& state,
  function I64 (line 1114) | static I64 testScriptThreadMain(void* sharedStateVoid)
  function processThread (line 1121) | static void processThread(TestScriptState& state, const ThreadCommand* t...
  function processWait (line 1159) | static void processWait(TestScriptState& state, const WaitCommand* waitC...
  function processCommand (line 1193) | static void processCommand(TestScriptState& state, const Command* command)
  function processCommandWithCloning (line 1231) | static void processCommandWithCloning(TestScriptState& state, const Comm...
  function processCommands (line 1340) | static void processCommands(TestScriptState& state,
  type SharedState (line 1428) | struct SharedState
  function I64 (line 1436) | static I64 threadMain(void* sharedStateVoid)
  function showHelp (line 1487) | static void showHelp()
  function execRunTestScript (line 1507) | int execRunTestScript(int argc, char** argv)

FILE: Programs/wavm/Testing/TestAPI.cpp
  function loadTextModule (line 23) | static bool loadTextModule(const char* wat, Uptr watLength, ModuleRef& o...
  type WAVM (line 36) | namespace WAVM { namespace IR {
    type IR (line 36) | namespace IR {
      function testToString (line 37) | inline std::string testToString(ValueType type)
    type Runtime (line 55) | namespace Runtime {
      function testToString (line 56) | inline std::string testToString(GrowResult result)
      function testToString (line 68) | inline std::string testToString(InstructionSource::Type type)
      function testToString (line 79) | inline std::string testToString(Function* function)
  type WAVM (line 55) | namespace WAVM { namespace Runtime {
    type IR (line 36) | namespace IR {
      function testToString (line 37) | inline std::string testToString(ValueType type)
    type Runtime (line 55) | namespace Runtime {
      function testToString (line 56) | inline std::string testToString(GrowResult result)
      function testToString (line 68) | inline std::string testToString(InstructionSource::Type type)
      function testToString (line 79) | inline std::string testToString(Function* function)
  function testCompartmentCloning (line 85) | static void testCompartmentCloning(TEST_STATE_PARAM)
  function testResourceQuotas (line 145) | static void testResourceQuotas(TEST_STATE_PARAM)
  function testMemoryOperations (line 197) | static void testMemoryOperations(TEST_STATE_PARAM)
  function testTableOperations (line 247) | static void testTableOperations(TEST_STATE_PARAM)
  function testGlobalOperations (line 283) | static void testGlobalOperations(TEST_STATE_PARAM)
  function testExceptionTypes (line 337) | static void testExceptionTypes(TEST_STATE_PARAM)
  function testModuleCompileAndIntrospect (line 402) | static void testModuleCompileAndIntrospect(TEST_STATE_PARAM)
  function testForeignObjects (line 466) | static void testForeignObjects(TEST_STATE_PARAM)
  function testTrapInstructionIndex (line 508) | static void testTrapInstructionIndex(TEST_STATE_PARAM)
  function testTrapInstructionIndexWithInlining (line 574) | static void testTrapInstructionIndexWithInlining(TEST_STATE_PARAM)
  function testGarbageCollection (line 664) | static void testGarbageCollection(TEST_STATE_PARAM)
  function execAPITest (line 695) | int execAPITest(int argc, char** argv)

FILE: Programs/wavm/Testing/TestCAPI.c
  function own (line 27) | own wasm_trap_t* hello_callback(const wasm_val_t args[], wasm_val_t resu...
  function execCAPITest (line 33) | int execCAPITest(int argc, char** argv)

FILE: Programs/wavm/Testing/TestDWARF.cpp
  function write (line 27) | static void write(Serialization::OutputStream& stream, const T& value)
  function writeULEB128 (line 32) | static void writeULEB128(Serialization::OutputStream& stream, U64 value)
  function writeSLEB128 (line 37) | static void writeSLEB128(Serialization::OutputStream& stream, I64 value)
  function patchU32 (line 43) | static void patchU32(std::vector<U8>& bytes, Uptr offset, U32 value)
  function makeSections (line 49) | static DWARF::Sections makeSections(const std::vector<U8>& info,
  type AbbrevAttrDef (line 70) | struct AbbrevAttrDef
  function buildAbbrevEntry (line 76) | static void buildAbbrevEntry(Serialization::OutputStream& stream,
  function terminateAbbrevTable (line 95) | static void terminateAbbrevTable(Serialization::OutputStream& stream)
  function U32 (line 105) | static U32 addDebugStr(ArrayOutputStream& stream, const char* str)
  function Uptr (line 119) | static Uptr beginCUv4(ArrayOutputStream& stream, U32 abbrevOffset, U8 ad...
  function Uptr (line 130) | static Uptr beginCUv5(ArrayOutputStream& stream, U32 abbrevOffset, U8 ad...
  function Uptr (line 158) | static Uptr beginLineTableV4(ArrayOutputStream& stream)
  function lineSetAddress (line 177) | static void lineSetAddress(Serialization::OutputStream& stream, U64 addr...
  function lineEndSequence (line 186) | static void lineEndSequence(Serialization::OutputStream& stream)
  function lineCopy (line 194) | static void lineCopy(Serialization::OutputStream& stream) { write(stream...
  function lineAdvancePC (line 197) | static void lineAdvancePC(Serialization::OutputStream& stream, U64 adv)
  function lineAdvanceLine (line 204) | static void lineAdvanceLine(Serialization::OutputStream& stream, I64 adv)
  function lineConstAddPC (line 211) | static void lineConstAddPC(Serialization::OutputStream& stream) { write(...
  function Uptr (line 214) | static Uptr constAddPCIncrement()
  function testSimpleFunction (line 224) | static void testSimpleFunction(TEST_STATE_PARAM)
  function testFunctionNotFound (line 299) | static void testFunctionNotFound(TEST_STATE_PARAM)
  function testInlineChain (line 350) | static void testInlineChain(TEST_STATE_PARAM)
  function testAbstractOrigin (line 437) | static void testAbstractOrigin(TEST_STATE_PARAM)
  function testSimpleCU (line 540) | static void testSimpleCU(TEST_STATE_PARAM,
  function testDWARFv4Header (line 608) | static void testDWARFv4Header(TEST_STATE_PARAM)
  function testDWARFv5Header (line 617) | static void testDWARFv5Header(TEST_STATE_PARAM)
  function testHighPCAsOffset (line 626) | static void testHighPCAsOffset(TEST_STATE_PARAM)
  function testLineTableSpecialOpcodes (line 696) | static void testLineTableSpecialOpcodes(TEST_STATE_PARAM)
  function testLineTableConstAddPC (line 781) | static void testLineTableConstAddPC(TEST_STATE_PARAM)
  function testMultipleCUs (line 856) | static void testMultipleCUs(TEST_STATE_PARAM)
  function testInlineStringForm (line 951) | static void testInlineStringForm(TEST_STATE_PARAM)
  function testEmptySections (line 1019) | static void testEmptySections(TEST_STATE_PARAM)
  function testMaxLocations (line 1051) | static void testMaxLocations(TEST_STATE_PARAM)
  function testDeclLineForSubprogram (line 1163) | static void testDeclLineForSubprogram(TEST_STATE_PARAM)
  function I32 (line 1263) | I32 execDWARFTest(int argc, char** argv)

FILE: Programs/wavm/Testing/TestHashMap.cpp
  function generateRandomString (line 20) | static std::string generateRandomString()
  function testStringMap (line 34) | static void testStringMap(TEST_STATE_PARAM)
  function testU32Map (line 108) | static void testU32Map(TEST_STATE_PARAM)
  function testMapCopy (line 138) | static void testMapCopy(TEST_STATE_PARAM)
  function testMapMove (line 176) | static void testMapMove(TEST_STATE_PARAM)
  function testMapInitializerList (line 205) | static void testMapInitializerList(TEST_STATE_PARAM)
  function testMapIterator (line 228) | static void testMapIterator(TEST_STATE_PARAM)
  function testMapGetOrAdd (line 264) | static void testMapGetOrAdd(TEST_STATE_PARAM)
  function testMapSet (line 277) | static void testMapSet(TEST_STATE_PARAM)
  type EmplacedValue (line 288) | struct EmplacedValue
    method EmplacedValue (line 293) | EmplacedValue(const std::string& inA, const std::string& inB) : a(inA)...
  function testMapEmplace (line 296) | static void testMapEmplace(TEST_STATE_PARAM)
  function testMapBracketOperator (line 322) | static void testMapBracketOperator(TEST_STATE_PARAM)
  function testMapEmpty (line 334) | static void testMapEmpty(TEST_STATE_PARAM)
  function testMapClear (line 356) | static void testMapClear(TEST_STATE_PARAM)
  function testMapGetPair (line 373) | static void testMapGetPair(TEST_STATE_PARAM)
  function testMapReserve (line 390) | static void testMapReserve(TEST_STATE_PARAM)
  function testMapAddOrFail (line 402) | static void testMapAddOrFail(TEST_STATE_PARAM)
  function testMapRemoveOrFail (line 411) | static void testMapRemoveOrFail(TEST_STATE_PARAM)
  function testMapAnalyzeSpaceUsage (line 421) | static void testMapAnalyzeSpaceUsage(TEST_STATE_PARAM)
  function testMapAnalyzeSpaceUsageAfterClear (line 439) | static void testMapAnalyzeSpaceUsageAfterClear(TEST_STATE_PARAM)
  function testMapMovedFromState (line 456) | static void testMapMovedFromState(TEST_STATE_PARAM)
  type CollidingHashPolicy (line 482) | struct CollidingHashPolicy
    method areKeysEqual (line 484) | static bool areKeysEqual(Uptr left, Uptr right) { return left == right; }
    method Uptr (line 485) | static Uptr getKeyHash(Uptr) { return 0; }
  function testMapHashCollisions (line 488) | static void testMapHashCollisions(TEST_STATE_PARAM)
  function testMapAnalyzeSpaceUsageEmpty (line 523) | static void testMapAnalyzeSpaceUsageEmpty(TEST_STATE_PARAM)
  function testMapTrackedValueDestruction (line 538) | static void testMapTrackedValueDestruction(TEST_STATE_PARAM)
  function testMapTrackedValueClear (line 554) | static void testMapTrackedValueClear(TEST_STATE_PARAM)
  function testMapTrackedValueRemove (line 577) | static void testMapTrackedValueRemove(TEST_STATE_PARAM)
  function testMapTrackedValueContainerMove (line 598) | static void testMapTrackedValueContainerMove(TEST_STATE_PARAM)
  function testMapTrackedValueContainerCopy (line 628) | static void testMapTrackedValueContainerCopy(TEST_STATE_PARAM)
  function I32 (line 670) | I32 execHashMapTest(int argc, char** argv)

FILE: Programs/wavm/Testing/TestHashSet.cpp
  function generateRandomString (line 20) | static std::string generateRandomString()
  function testStringSet (line 34) | static void testStringSet(TEST_STATE_PARAM)
  function testU32Set (line 92) | static void testU32Set(TEST_STATE_PARAM)
  function testSetCopy (line 122) | static void testSetCopy(TEST_STATE_PARAM)
  function testSetMove (line 160) | static void testSetMove(TEST_STATE_PARAM)
  function testSetInitializerList (line 189) | static void testSetInitializerList(TEST_STATE_PARAM)
  function testSetIterator (line 212) | static void testSetIterator(TEST_STATE_PARAM)
  function testSetBracketOperator (line 236) | static void testSetBracketOperator(TEST_STATE_PARAM)
  function testSetEmpty (line 248) | static void testSetEmpty(TEST_STATE_PARAM)
  function testSetClear (line 270) | static void testSetClear(TEST_STATE_PARAM)
  function testSetReserve (line 287) | static void testSetReserve(TEST_STATE_PARAM)
  function testSetAddOrFail (line 299) | static void testSetAddOrFail(TEST_STATE_PARAM)
  function testSetRemoveOrFail (line 308) | static void testSetRemoveOrFail(TEST_STATE_PARAM)
  function testSetAnalyzeSpaceUsage (line 318) | static void testSetAnalyzeSpaceUsage(TEST_STATE_PARAM)
  function testSetAnalyzeSpaceUsageAfterClear (line 336) | static void testSetAnalyzeSpaceUsageAfterClear(TEST_STATE_PARAM)
  function testSetMovedFromState (line 353) | static void testSetMovedFromState(TEST_STATE_PARAM)
  type CollidingHashPolicy (line 379) | struct CollidingHashPolicy
    method areKeysEqual (line 381) | static bool areKeysEqual(Uptr left, Uptr right) { return left == right; }
    method Uptr (line 382) | static Uptr getKeyHash(Uptr) { return 0; }
  function testSetHashCollisions (line 385) | static void testSetHashCollisions(TEST_STATE_PARAM)
  function testSetAnalyzeSpaceUsageEmpty (line 415) | static void testSetAnalyzeSpaceUsageEmpty(TEST_STATE_PARAM)
  function testSetTrackedValueDestruction (line 430) | static void testSetTrackedValueDestruction(TEST_STATE_PARAM)
  function testSetTrackedValueClear (line 444) | static void testSetTrackedValueClear(TEST_STATE_PARAM)
  function testSetTrackedValueRemove (line 464) | static void testSetTrackedValueRemove(TEST_STATE_PARAM)
  function testSetTrackedValueContainerMove (line 484) | static void testSetTrackedValueContainerMove(TEST_STATE_PARAM)
  function testSetTrackedValueContainerCopy (line 506) | static void testSetTrackedValueContainerCopy(TEST_STATE_PARAM)
  function I32 (line 539) | I32 execHashSetTest(int argc, char** argv)

FILE: Programs/wavm/Testing/TestI128.cpp
  type RandomStream (line 11) | struct RandomStream
    method RandomStream (line 13) | RandomStream(I128 inSeed) : seed(inSeed) {}
    method I128 (line 15) | I128 get()
  function testNaNHandling (line 58) | static void testNaNHandling(TEST_STATE_PARAM)
  function testOverflow (line 119) | static void testOverflow(TEST_STATE_PARAM)
  function testDivision (line 166) | static void testDivision(TEST_STATE_PARAM)
  function testShifts (line 208) | static void testShifts(TEST_STATE_PARAM)
  function testBitwise (line 242) | static void testBitwise(TEST_STATE_PARAM)
  function testComparisons (line 267) | static void testComparisons(TEST_STATE_PARAM)
  function testUnaryOps (line 325) | static void testUnaryOps(TEST_STATE_PARAM)
  function testConstructorsAndConversions (line 344) | static void testConstructorsAndConversions(TEST_STATE_PARAM)
  function testFloatConversions (line 358) | static void testFloatConversions(TEST_STATE_PARAM)
  function testBoundaryValues (line 491) | static void testBoundaryValues(TEST_STATE_PARAM)
  function testAssignmentOps (line 509) | static void testAssignmentOps(TEST_STATE_PARAM)
  function I32 (line 554) | I32 execI128Test(int argc, char** argv)

FILE: Programs/wavm/Testing/TestLEB128.cpp
  function roundtrip (line 16) | static void roundtrip(TEST_STATE_PARAM, Value value, Value minValue, Val...
  function testUnsigned32 (line 31) | static void testUnsigned32(TEST_STATE_PARAM)
  function testSigned32 (line 51) | static void testSigned32(TEST_STAT

[
  {
    "path": ".clang-format",
    "chars": 2781,
    "preview": "---\nLanguage:        Cpp\nAccessModifierOffset: -4\nAlignAfterOpenBracket: Align\nAlignConsecutiveAssignments: false\nAlignC"
  },
  {
    "path": ".clang-tidy",
    "chars": 163,
    "preview": "Checks: >\n  -*,\n  misc-include-cleaner\nCheckOptions:\n  - key: misc-include-cleaner.IgnoreHeaders\n    value: \"_.*;sys/_.*"
  },
  {
    "path": ".editorconfig",
    "chars": 68,
    "preview": "root = true\n\n[*.{c,cpp,h,S,asm}]\nindent_style = tab\nindent_size = 4\n"
  },
  {
    "path": ".gitattributes",
    "chars": 29,
    "preview": "*.wast linguist-vendored=true"
  },
  {
    "path": ".github/workflows/build.yml",
    "chars": 26221,
    "preview": "name: Build\n\non:\n  push:\n    branches: [master]\n    tags: ['v*']\n  pull_request:\n    branches: [master]\n  schedule:\n    "
  },
  {
    "path": ".gitignore",
    "chars": 78,
    "preview": ".claude\nCLAUDE.md\n\n**/__pycache__\n\n# dev.py default working directory\n.working"
  },
  {
    "path": "Benchmarks/blake2b-memory64.wast",
    "chars": 95603,
    "preview": ";; Blake2b hash function\n\n(module\n\t(import \"wasi_unstable\" \"fd_write\" (func $wasi_fd_write (param i32 i32 i32 i32) (resu"
  },
  {
    "path": "Benchmarks/blake2b.wast",
    "chars": 95401,
    "preview": ";; Blake2b hash function\n\n(module\n\t(import \"wasi_unstable\" \"fd_write\" (func $wasi_fd_write (param i32 i32 i32 i32) (resu"
  },
  {
    "path": "Build/dev.py",
    "chars": 3748,
    "preview": "#!/usr/bin/env python3\n\"\"\"Build, test, and maintain WAVM across multiple configurations.\"\"\"\n\nimport argparse\nimport os\ni"
  },
  {
    "path": "Build/lib/__init__.py",
    "chars": 24,
    "preview": "# Build library modules\n"
  },
  {
    "path": "Build/lib/benchmark.py",
    "chars": 26632,
    "preview": "\"\"\"Benchmark execution, result collection, and comparison.\"\"\"\n\nimport argparse\nimport json\nimport math\nimport platform\ni"
  },
  {
    "path": "Build/lib/build.py",
    "chars": 21252,
    "preview": "\"\"\"Build configuration classes and CMake utilities.\"\"\"\n\nimport argparse\nimport hashlib\nimport json\nimport shutil\nfrom da"
  },
  {
    "path": "Build/lib/context.py",
    "chars": 199,
    "preview": "\"\"\"Shared command context passed to all subcommand handlers.\"\"\"\n\nfrom dataclasses import dataclass\nfrom pathlib import P"
  },
  {
    "path": "Build/lib/coverage.py",
    "chars": 11437,
    "preview": "\"\"\"Code coverage report generation and LCOV merging utilities.\"\"\"\n\nimport argparse\nimport shutil\nfrom collections import"
  },
  {
    "path": "Build/lib/cpp_files.py",
    "chars": 913,
    "preview": "\"\"\"Discover C/C++ source files in the WAVM tree.\"\"\"\n\nimport os\nfrom pathlib import Path\n\n\ndef discover_cpp_files(source_"
  },
  {
    "path": "Build/lib/format.py",
    "chars": 6076,
    "preview": "\"\"\"C/C++ formatting tasks using clang-format.\"\"\"\n\nimport argparse\nimport difflib\nfrom pathlib import Path\nfrom typing im"
  },
  {
    "path": "Build/lib/fuzz.py",
    "chars": 18012,
    "preview": "\"\"\"LibFuzzer fuzzing campaign management.\"\"\"\n\nimport argparse\nimport os\nimport shutil\nimport subprocess\nimport time\nfrom"
  },
  {
    "path": "Build/lib/lint.py",
    "chars": 2411,
    "preview": "\"\"\"Python linting tasks using ruff and ty.\"\"\"\n\nimport argparse\n\nfrom pathlib import Path\n\nfrom .context import CommandCo"
  },
  {
    "path": "Build/lib/llvm.py",
    "chars": 13951,
    "preview": "\"\"\"LLVM download, build, and version management.\"\"\"\n\nimport functools\nimport shutil\nimport sys\nfrom dataclasses import d"
  },
  {
    "path": "Build/lib/output.py",
    "chars": 3503,
    "preview": "\"\"\"Console output management with support for status lines and verbosity levels.\"\"\"\n\nimport io\nimport os\nimport sys\n\n\ncl"
  },
  {
    "path": "Build/lib/platform.py",
    "chars": 18616,
    "preview": "\"\"\"Platform detection, command execution, and compiler/linker utilities.\"\"\"\n\nimport functools\nimport os\nimport platform "
  },
  {
    "path": "Build/lib/run.py",
    "chars": 1678,
    "preview": "\"\"\"Build-and-run subcommand.\"\"\"\n\nimport argparse\nimport subprocess\n\nfrom .build import build_single_config\nfrom .context"
  },
  {
    "path": "Build/lib/task_graph.py",
    "chars": 11757,
    "preview": "\"\"\"Task scheduling framework with parallel execution support.\"\"\"\n\nimport os\nimport threading\nimport time\nfrom concurrent"
  },
  {
    "path": "Build/lib/test.py",
    "chars": 37380,
    "preview": "\"\"\"Test execution, task management, and test history.\"\"\"\n\nimport argparse\nimport functools\nimport os\nimport re\nimport si"
  },
  {
    "path": "Build/lib/test_def.py",
    "chars": 5690,
    "preview": "\"\"\"Test definition types: TestContext, TestResult, TestStep, TestDef.\"\"\"\n\nimport hashlib\nimport re\nfrom dataclasses impo"
  },
  {
    "path": "Build/lib/tidy.py",
    "chars": 5647,
    "preview": "\"\"\"Clang-tidy tasks.\"\"\"\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Union\n\nfrom .build impo"
  },
  {
    "path": "Build/lib/toolchain.py",
    "chars": 13522,
    "preview": "\"\"\"Toolchain detection, configuration, and CMake argument generation.\"\"\"\n\nimport functools\nimport shutil\nimport sys\nfrom"
  },
  {
    "path": "Build/lib/wasi.py",
    "chars": 18357,
    "preview": "\"\"\"WASI SDK download, compilation tasks, and WASI test definitions.\"\"\"\n\nimport platform as platform_mod\nimport shutil\nfr"
  },
  {
    "path": "Build/lib/workspace.py",
    "chars": 4087,
    "preview": "\"\"\"VS Code workspace file generation for clangd integration.\"\"\"\n\nimport argparse\nimport json\nfrom pathlib import Path\nfr"
  },
  {
    "path": "Build/ruff.toml",
    "chars": 18,
    "preview": "line-length = 100\n"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 39941,
    "preview": "cmake_minimum_required(VERSION 3.16)\n\n# Parse the VERSION file.\nset_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_D"
  },
  {
    "path": "Doc/BuildSystem.md",
    "chars": 10783,
    "preview": "# Build System & CI\n\nWAVM uses `Build/dev.py` to manage multi-configuration builds, testing, formatting, packaging, and "
  },
  {
    "path": "Doc/Building.md",
    "chars": 3752,
    "preview": "# Building WAVM from source\n\n## Quick Start (Recommended)\n\nThe easiest way to build and test WAVM is using the `dev.py` "
  },
  {
    "path": "Doc/CodeOrganization.md",
    "chars": 2724,
    "preview": "# Exploring the WAVM source\n\n## Directory Structure\n\n- **Lib/** - Core library implementations (compiled into libWAVM)\n-"
  },
  {
    "path": "Doc/GettingStarted.md",
    "chars": 3541,
    "preview": "# Getting Started\n\n## Install a binary build\n\nBinary builds of WAVM are available on [GitHub releases](https://github.co"
  },
  {
    "path": "Doc/PortabilityMatrix.md",
    "chars": 592,
    "preview": "# Portability Matrix\n\n| Key         |                                                   |\n|-------------|---------------"
  },
  {
    "path": "Doc/SignalsAndExceptions.md",
    "chars": 9342,
    "preview": "# Hardware trap handling\n\nWAVM uses hardware trap handling to implement WebAssembly's semantics efficiently. The primary"
  },
  {
    "path": "Doc/WAVMObjectReachability.dot",
    "chars": 3518,
    "preview": "digraph {\n\trankdir=LR;\n\t\n\tlabelloc=\"t\";\n\tlabel=\"Reachability Graph Schema\";\n\tfontsize=30;\n\n\tsubgraph clusterLegend {\n\t\tl"
  },
  {
    "path": "Dockerfile",
    "chars": 532,
    "preview": "FROM ubuntu:18.04\n\nRUN apt-get update\nRUN apt-get install -y software-properties-common\n\n# System deps\nRUN apt-get updat"
  },
  {
    "path": "Examples/CMakeLists.txt",
    "chars": 167,
    "preview": "set(Sources\n\techo.wast\n\thelloworld.wast\n\ttee.wast\n\ttrap.wast)\nadd_custom_target(Examples SOURCES ${Sources})\nset_target_"
  },
  {
    "path": "Examples/echo.wast",
    "chars": 4752,
    "preview": ";; Classic Unix echo program in WebAssembly WASM AST\n\n(module\n  (import \"wasi_unstable\" \"args_get\" (func $wasi_args_get "
  },
  {
    "path": "Examples/embedder/c/CMakeLists.txt",
    "chars": 963,
    "preview": "cmake_minimum_required(VERSION 3.8.0)\nproject(embedder-test LANGUAGES C CXX)\n\nadd_executable(embedder-example embedder-e"
  },
  {
    "path": "Examples/embedder/c/embedder-example.c",
    "chars": 5556,
    "preview": "#include <assert.h>\n#include <inttypes.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include \"WAVM/wavm"
  },
  {
    "path": "Examples/embedder/cpp/CMakeLists.txt",
    "chars": 965,
    "preview": "cmake_minimum_required(VERSION 3.8.0)\nproject(embedder-test LANGUAGES C CXX)\n\nadd_executable(embedder-example embedder-e"
  },
  {
    "path": "Examples/embedder/cpp/build.sh",
    "chars": 365,
    "preview": "#!/bin/sh\n\nWAVM_INSTALL_DIR=/usr\n\n# Compile embedder-example.cpp to embedder-example.o\nc++ \\\n\t-DWASM_C_API=\"\" \\\n\t-DWAVM_"
  },
  {
    "path": "Examples/embedder/cpp/embedder-example.cpp",
    "chars": 4450,
    "preview": "#include <inttypes.h>\n#include <stdio.h>\n#include <vector>\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Types.h\"\n#inclu"
  },
  {
    "path": "Examples/embedder/cpp-wasi/CMakeLists.txt",
    "chars": 965,
    "preview": "cmake_minimum_required(VERSION 3.8.0)\nproject(embedder-test LANGUAGES C CXX)\n\nadd_executable(embedder-example embedder-e"
  },
  {
    "path": "Examples/embedder/cpp-wasi/embedder-example.cpp",
    "chars": 4513,
    "preview": "#ifdef _MSC_VER\n#define _CRT_SECURE_NO_WARNINGS\n#endif\n\n#include <errno.h>\n#include <inttypes.h>\n#include <stdio.h>\n#inc"
  },
  {
    "path": "Examples/helloworld.wast",
    "chars": 858,
    "preview": ";; WebAssembly WASM AST Hello World! program\n\n(module\n  (import \"wasi_unstable\" \"fd_write\" (func $wasi_fd_write (param i"
  },
  {
    "path": "Examples/tee.wast",
    "chars": 2663,
    "preview": ";; poor man's tee\n;; Outputs to stderr and stdout whatever comes in stdin\n\n(module\n\n  (import \"wasi_unstable\" \"fd_read\" "
  },
  {
    "path": "Examples/trap.wast",
    "chars": 432,
    "preview": "(module\n\n\t(import \"wasi_unstable\" \"proc_exit\" (func $wasi_proc_exit (param i32)))\n\n\t(memory (export \"memory\") 1)\n\n\t(func"
  },
  {
    "path": "Include/WAVM/DWARF/Constants.h",
    "chars": 4206,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace DWARF {\n\n\t// DWARF tag constants.\n\tinline "
  },
  {
    "path": "Include/WAVM/DWARF/DWARF.h",
    "chars": 712,
    "preview": "#pragma once\n\n#include \"WAVM/DWARF/Sections.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace DWARF {\n\n"
  },
  {
    "path": "Include/WAVM/DWARF/Sections.h",
    "chars": 483,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace DWARF {\n\n\tstruct Sections\n\t{\n\t\tconst U8* d"
  },
  {
    "path": "Include/WAVM/IR/FeatureSpec.h",
    "chars": 5322,
    "preview": "#pragma once\n\n#include <cstdint>\n#include \"WAVM/Inline/BasicTypes.h\"\n\n// Features that have been standardized by the W3C"
  },
  {
    "path": "Include/WAVM/IR/IR.h",
    "chars": 524,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\n#include <cstdint>\n\nnamespace WAVM { namespace IR {\n\tinline constexpr"
  },
  {
    "path": "Include/WAVM/IR/Module.h",
    "chars": 12374,
    "preview": "#pragma once\n\n#include <stdint.h>\n#include <initializer_list>\n#include <memory>\n#include <string>\n#include <utility>\n#in"
  },
  {
    "path": "Include/WAVM/IR/OperatorPrinter.h",
    "chars": 4834,
    "preview": "#pragma once\n\n#include <string>\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Operators.h\"\n#include \"WAVM/IR/Types.h\"\n#i"
  },
  {
    "path": "Include/WAVM/IR/OperatorSignatures.h",
    "chars": 13925,
    "preview": "#pragma once\n\n#include <initializer_list>\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Operators.h\"\n#include \"WAVM/IR/T"
  },
  {
    "path": "Include/WAVM/IR/OperatorTable.h",
    "chars": 100877,
    "preview": "// IWYU pragma: private, include \"WAVM/IR/Operators.h\"\n// Don't include this file directly; include Operators.h instead\n"
  },
  {
    "path": "Include/WAVM/IR/Operators.h",
    "chars": 5969,
    "preview": "#pragma once\n\n#include <string.h>\n#include <vector>\n#include \"WAVM/IR/Types.h\"\n#include \"WAVM/Inline/Assert.h\"\n#include "
  },
  {
    "path": "Include/WAVM/IR/RandomModule.h",
    "chars": 192,
    "preview": "#pragma once\n\nnamespace WAVM {\n\tstruct RandomStream;\n}\n\nnamespace WAVM { namespace IR {\n\tstruct Module;\n\n\tWAVM_API void "
  },
  {
    "path": "Include/WAVM/IR/Types.h",
    "chars": 19578,
    "preview": "#pragma once\n\n#include <stddef.h>\n#include <stdint.h>\n#include <initializer_list>\n#include <string>\n#include <vector>\n#i"
  },
  {
    "path": "Include/WAVM/IR/Types.natvis",
    "chars": 633,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<AutoVisualizer xmlns=\"http://schemas.microsoft.com/vstudio/debugger/natvis/2010\""
  },
  {
    "path": "Include/WAVM/IR/Validate.h",
    "chars": 3171,
    "preview": "#pragma once\n\n#include <memory>\n#include <string>\n#include \"WAVM/IR/Operators.h\"\n\nnamespace WAVM { namespace IR {\n\tstruc"
  },
  {
    "path": "Include/WAVM/IR/Value.h",
    "chars": 4013,
    "preview": "#pragma once\n\n#include <string.h>\n#include <string>\n#include <vector>\n#include \"WAVM/IR/Types.h\"\n#include \"WAVM/Inline/A"
  },
  {
    "path": "Include/WAVM/Inline/Assert.h",
    "chars": 2601,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Config.h\"\n#include \"WAVM/Platform/Defines.h\"\n#include \"WAVM/Platform/Error.h\" // IWY"
  },
  {
    "path": "Include/WAVM/Inline/BasicTypes.h",
    "chars": 1223,
    "preview": "#pragma once\n\n#include <inttypes.h>\n#include <stddef.h>\n#include <stdint.h>\n#include \"WAVM/Platform/Defines.h\"\n\nnamespac"
  },
  {
    "path": "Include/WAVM/Inline/CLI.h",
    "chars": 6655,
    "preview": "#pragma once\n\n#include <cstdint>\n#include <cstdlib>\n#include <cstring> // IWYU pragma: keep\n#include <string>\n#include <"
  },
  {
    "path": "Include/WAVM/Inline/CMakeLists.txt",
    "chars": 800,
    "preview": "set(Headers\n\tAssert.h\n\tBasicTypes.h\n\tCLI.h\n\tDenseStaticIntSet.h\n\tErrors.h\n\tFloatComponents.h\n\tHash.h\n\tHashMap.h\n\tHashSet"
  },
  {
    "path": "Include/WAVM/Inline/Config.h.in",
    "chars": 925,
    "preview": "#cmakedefine01 WAVM_ENABLE_RUNTIME\n#cmakedefine01 WAVM_ENABLE_STATIC_LINKING\n#cmakedefine01 WAVM_ENABLE_ASAN\n#cmakedefin"
  },
  {
    "path": "Include/WAVM/Inline/DenseStaticIntSet.h",
    "chars": 5605,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Hash.h\"\n#include"
  },
  {
    "path": "Include/WAVM/Inline/Errors.h",
    "chars": 708,
    "preview": "#pragma once\n\n#include <cstdarg>\n#include \"WAVM/Platform/Error.h\"\n\nnamespace WAVM { namespace Errors {\n\t// Fatal error h"
  },
  {
    "path": "Include/WAVM/Inline/FixedString.h",
    "chars": 1360,
    "preview": "#pragma once\n\n#include <cstring>\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM {\n\n\t// A fixed-capacity, null-termi"
  },
  {
    "path": "Include/WAVM/Inline/FloatComponents.h",
    "chars": 1573,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM {\n\ttemplate<typename Float> struct FloatComponents;\n\n\t"
  },
  {
    "path": "Include/WAVM/Inline/Hash.h",
    "chars": 4107,
    "preview": "#pragma once\n\n#include <functional>\n#include <string>\n#include <string_view>\n#include <vector>\n#include \"BasicTypes.h\"\n\n"
  },
  {
    "path": "Include/WAVM/Inline/HashMap.h",
    "chars": 4681,
    "preview": "// Use both #pragma once and include guards: we test that headers compile as standalone translation\n// units, and the ci"
  },
  {
    "path": "Include/WAVM/Inline/HashSet.h",
    "chars": 3455,
    "preview": "// Use both #pragma once and include guards: we test that headers compile as standalone translation\n// units, and the ci"
  },
  {
    "path": "Include/WAVM/Inline/HashTable.h",
    "chars": 6444,
    "preview": "// Use both #pragma once and include guards: we test that headers compile as standalone translation\n// units, and the ci"
  },
  {
    "path": "Include/WAVM/Inline/I128.h",
    "chars": 5332,
    "preview": "// Use both #pragma once and include guards: we test that headers compile as standalone translation\n// units, and the ci"
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashMap.natvis",
    "chars": 1068,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<AutoVisualizer xmlns=\"http://schemas.microsoft.com/vstudio/debugger/natvis/2010\""
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashMapImpl.h",
    "chars": 9689,
    "preview": "// IWYU pragma: private, include \"WAVM/Inline/HashMap.h\"\n#pragma once\n#ifndef WAVM_INLINE_IMPL_HASHMAPIMPL_H\n#define WAV"
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashSet.natvis",
    "chars": 675,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<AutoVisualizer xmlns=\"http://schemas.microsoft.com/vstudio/debugger/natvis/2010\""
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashSetImpl.h",
    "chars": 6455,
    "preview": "// IWYU pragma: private, include \"WAVM/Inline/HashSet.h\"\n#pragma once\n#ifndef WAVM_INLINE_IMPL_HASHSETIMPL_H\n#define WAV"
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashTable.natvis",
    "chars": 443,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<AutoVisualizer xmlns=\"http://schemas.microsoft.com/vstudio/debugger/natvis/2010\""
  },
  {
    "path": "Include/WAVM/Inline/Impl/HashTableImpl.h",
    "chars": 13588,
    "preview": "// IWYU pragma: private, include \"WAVM/Inline/HashTable.h\"\n#pragma once\n#ifndef WAVM_INLINE_IMPL_HASHTABLEIMPL_H\n#define"
  },
  {
    "path": "Include/WAVM/Inline/Impl/I128Impl.LICENSE",
    "chars": 16708,
    "preview": "==============================================================================\nThe LLVM Project is under the Apache Lice"
  },
  {
    "path": "Include/WAVM/Inline/Impl/I128Impl.h",
    "chars": 19272,
    "preview": "// IWYU pragma: private, include \"WAVM/Inline/I128.h\"\n// You should only include this file indirectly by including I128."
  },
  {
    "path": "Include/WAVM/Inline/Impl/OptionalStorage.h",
    "chars": 2140,
    "preview": "#pragma once\n\n#include <new> // IWYU pragma: keep\n#include <type_traits>\n#include <utility> // IWYU pragma: keep\n\nnamesp"
  },
  {
    "path": "Include/WAVM/Inline/Impl/OptionalStorage.natvis",
    "chars": 329,
    "preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<AutoVisualizer xmlns=\"http://schemas.microsoft.com/vstudio/debugger/natvis/2010\""
  },
  {
    "path": "Include/WAVM/Inline/IndexMap.h",
    "chars": 4354,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/HashMap.h\"\n\nname"
  },
  {
    "path": "Include/WAVM/Inline/InlineArray.h",
    "chars": 2638,
    "preview": "#pragma once\n\n#include <type_traits>\n#include \"Impl/OptionalStorage.h\"\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/In"
  },
  {
    "path": "Include/WAVM/Inline/IntCasts.h",
    "chars": 1727,
    "preview": "#pragma once\n\n#include <cinttypes>\n#include <type_traits>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Erro"
  },
  {
    "path": "Include/WAVM/Inline/IntrusiveSharedPtr.h",
    "chars": 2057,
    "preview": "#pragma once\n\nnamespace WAVM {\n\t// A smart pointer that uses an intrusive reference counter.\n\t// Needs Pointee to define"
  },
  {
    "path": "Include/WAVM/Inline/IsNameChar.h",
    "chars": 458,
    "preview": "#pragma once\n\nnamespace WAVM {\n\tinline bool isNameChar(char c)\n\t{\n\t\treturn (c >= 'a' && c <= 'z') || (c >= 'A' && c <= '"
  },
  {
    "path": "Include/WAVM/Inline/LEB128.h",
    "chars": 7532,
    "preview": "#pragma once\n\n#include <cstdint>\n#include <limits> // IWYU pragma: keep\n#include <string> // IWYU pragma: keep\n#include "
  },
  {
    "path": "Include/WAVM/Inline/RandomStream.h",
    "chars": 1485,
    "preview": "#pragma once\n\n#include <cstdint>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM {\n\t"
  },
  {
    "path": "Include/WAVM/Inline/Serialization.h",
    "chars": 9634,
    "preview": "#pragma once\n\n#include <string.h>\n#include <algorithm>\n#include <cstdint>\n#include <string>\n#include <utility>\n#include "
  },
  {
    "path": "Include/WAVM/Inline/StringBuilder.h",
    "chars": 6406,
    "preview": "#pragma once\n\n#include <algorithm>\n#include <cstdarg>\n#include <cstdio>\n#include <cstdlib>\n#include <cstring>\n#include <"
  },
  {
    "path": "Include/WAVM/Inline/Time.h",
    "chars": 224,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/I128.h\"\n\nnamespace WAVM {\n\tstruct Time\n\t{\n\t\tI128 ns;\n\n\t\tstatic constexpr Time infini"
  },
  {
    "path": "Include/WAVM/Inline/Timing.h",
    "chars": 1453,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/I128.h\"\n#include \"WAVM/Inline/Time.h\"\n#include \""
  },
  {
    "path": "Include/WAVM/Inline/UnalignedArrayView.h",
    "chars": 673,
    "preview": "#pragma once\n\n#include <cstring>\n#include <type_traits>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes"
  },
  {
    "path": "Include/WAVM/Inline/Unicode.h",
    "chars": 5128,
    "preview": "#pragma once\n\n#include \"BasicTypes.h\"\n#include \"WAVM/Inline/Assert.h\"\n\nnamespace WAVM { namespace Unicode {\n\ttemplate<ty"
  },
  {
    "path": "Include/WAVM/Inline/Version.h.in",
    "chars": 247,
    "preview": "#define WAVM_VERSION_MAJOR @WAVM_VERSION_MAJOR@\n#define WAVM_VERSION_MINOR @WAVM_VERSION_MINOR@\n#define WAVM_VERSION_PAT"
  },
  {
    "path": "Include/WAVM/Inline/xxhash/CMakeLists.txt",
    "chars": 128,
    "preview": "add_custom_target(xxhash SOURCES LICENSE xxhash.c xxh3.h xxhash.h)\nset_target_properties(xxhash PROPERTIES FOLDER \"Third"
  },
  {
    "path": "Include/WAVM/Inline/xxhash/LICENSE",
    "chars": 2228,
    "preview": "xxHash Library\nCopyright (c) 2012-2020 Yann Collet\nAll rights reserved.\n\nBSD 2-Clause License (https://www.opensource.or"
  },
  {
    "path": "Include/WAVM/Inline/xxhash/xxh3.h",
    "chars": 109230,
    "preview": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Development source file for `xxh3`\n * Copyright (C) 2019-2020 Yann Colle"
  },
  {
    "path": "Include/WAVM/Inline/xxhash/xxhash.c",
    "chars": 1855,
    "preview": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Copyright (C) 2012-2020 Yann Collet\n *\n * BSD 2-Clause License (https://"
  },
  {
    "path": "Include/WAVM/Inline/xxhash/xxhash.h",
    "chars": 74772,
    "preview": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Header File\n * Copyright (C) 2012-2020 Yann Collet\n *\n * BSD 2-Clause Li"
  },
  {
    "path": "Include/WAVM/LLVMJIT/LLVMJIT.h",
    "chars": 5505,
    "preview": "#pragma once\n\n#include <memory>\n#include <optional>\n#include <string>\n#include <vector>\n#include \"WAVM/IR/Types.h\"\n#incl"
  },
  {
    "path": "Include/WAVM/Logging/Logging.h",
    "chars": 1258,
    "preview": "#pragma once\n\n#include <stdarg.h>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Platform/Defines.h\"\n\n// Debug loggi"
  },
  {
    "path": "Include/WAVM/NFA/NFA.h",
    "chars": 3472,
    "preview": "#pragma once\n\n#include <stdint.h>\n#include <string>\n#include <utility>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAV"
  },
  {
    "path": "Include/WAVM/ObjectCache/ObjectCache.h",
    "chars": 474,
    "preview": "#pragma once\n\n#include <memory>\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace Runtime {\n\tstruct Object"
  },
  {
    "path": "Include/WAVM/ObjectLinker/ObjectLinker.h",
    "chars": 1230,
    "preview": "#pragma once\n\n#include <functional>\n#include <string>\n#include <vector>\n#include \"WAVM/DWARF/Sections.h\"\n#include \"WAVM/"
  },
  {
    "path": "Include/WAVM/Platform/Alloca.h",
    "chars": 129,
    "preview": "#pragma once\n\n#ifdef _MSC_VER\n#include <malloc.h> // IWYU pragma: export\n#else\n#include <alloca.h> // IWYU pragma: expor"
  },
  {
    "path": "Include/WAVM/Platform/CPU.h",
    "chars": 9407,
    "preview": "#pragma once\n\n#include <string>\n#include <type_traits>\n#include <utility>\n\n#if defined(_M_X64) || defined(__x86_64__)\n#d"
  },
  {
    "path": "Include/WAVM/Platform/Clock.h",
    "chars": 475,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Time.h\"\n\nnamespace WAVM { namespace Platform {\n\tenum class Clock\n\t{\n\t\t// The real-ti"
  },
  {
    "path": "Include/WAVM/Platform/ConditionVariable.h",
    "chars": 1099,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Config.h\"\n#include \"WAVM/Inline/Time.h\"\n\nnamespa"
  },
  {
    "path": "Include/WAVM/Platform/Defines.h",
    "chars": 5451,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Config.h\"\n\n#define WAVM_SUPPRESS_UNUSED(variable) (void)(variable);\n\n// Compiler-spe"
  },
  {
    "path": "Include/WAVM/Platform/Diagnostics.h",
    "chars": 1652,
    "preview": "#pragma once\n\n#include <string>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/FixedString.h\"\n#include \"WAVM/"
  },
  {
    "path": "Include/WAVM/Platform/Error.h",
    "chars": 1287,
    "preview": "#pragma once\n\n#include <cstdarg>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Config.h\"\n\nnamespace WAVM { n"
  },
  {
    "path": "Include/WAVM/Platform/File.h",
    "chars": 445,
    "preview": "#pragma once\n\n#include <string>\n#include \"WAVM/VFS/VFS.h\"\n\nnamespace WAVM { namespace Platform {\n\n\tenum class StdDevice\n"
  },
  {
    "path": "Include/WAVM/Platform/Intrinsic.h",
    "chars": 4889,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\n#ifdef _WIN32\n#include <intrin.h>\n#endif\n\n// __has_builtin is a Clang"
  },
  {
    "path": "Include/WAVM/Platform/Memory.h",
    "chars": 2812,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace Platform {\n\t// Describes allowed memory ac"
  },
  {
    "path": "Include/WAVM/Platform/Mutex.h",
    "chars": 1482,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Config.h\"\n\n#ifde"
  },
  {
    "path": "Include/WAVM/Platform/RWMutex.h",
    "chars": 2189,
    "preview": "#pragma once\n\n#include <atomic>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inlin"
  },
  {
    "path": "Include/WAVM/Platform/Random.h",
    "chars": 163,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace Platform {\n\tWAVM_API void getCryptographic"
  },
  {
    "path": "Include/WAVM/Platform/Signal.h",
    "chars": 527,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Config.h\"\n#include \"WAVM/Platform/Unwind.h\"\n\nnam"
  },
  {
    "path": "Include/WAVM/Platform/Thread.h",
    "chars": 376,
    "preview": "#pragma once\n\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnamespace WAVM { namespace Platform {\n\tstruct Thread;\n\tWAVM_API Threa"
  },
  {
    "path": "Include/WAVM/Platform/Unwind.h",
    "chars": 3947,
    "preview": "#pragma once\n\n#include <optional>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Config.h\"\n#include \"WAVM/Pla"
  },
  {
    "path": "Include/WAVM/RegExp/RegExp.h",
    "chars": 467,
    "preview": "#pragma once\n\n#include \"WAVM/NFA/NFA.h\"\n\nnamespace WAVM { namespace RegExp {\n\t// Parses a regular expression from a stri"
  },
  {
    "path": "Include/WAVM/Runtime/Intrinsics.h",
    "chars": 7126,
    "preview": "#pragma once\n\n#include <initializer_list>\n#include <string>\n#include \"WAVM/IR/Types.h\"\n#include \"WAVM/IR/Value.h\"\n#inclu"
  },
  {
    "path": "Include/WAVM/Runtime/Linker.h",
    "chars": 2566,
    "preview": "#pragma once\n\n#include <string>\n#include <vector>\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Types.h\"\n#include \"WAVM/"
  },
  {
    "path": "Include/WAVM/Runtime/Runtime.h",
    "chars": 25872,
    "preview": "#pragma once\n\n#include <functional>\n#include <memory>\n#include <string>\n#include <vector>\n#include \"WAVM/IR/FeatureSpec."
  },
  {
    "path": "Include/WAVM/RuntimeABI/CMakeLists.txt",
    "chars": 95,
    "preview": "set(PublicHeaders\n\tRuntimeABI.h)\n\nWAVM_ADD_LIB_COMPONENT(RuntimeABI\n\tHEADERS ${PublicHeaders})\n"
  },
  {
    "path": "Include/WAVM/RuntimeABI/RuntimeABI.h",
    "chars": 7699,
    "preview": "#pragma once\n\n//\n// Data structures that are used to share data between WAVM C++ code and the compiled WASM code.\n//\n\n#i"
  },
  {
    "path": "Include/WAVM/ThreadTest/ThreadTest.h",
    "chars": 214,
    "preview": "#pragma once\n\nnamespace WAVM { namespace Runtime {\n\tstruct Compartment;\n\tstruct Instance;\n}}\n\nnamespace WAVM { namespace"
  },
  {
    "path": "Include/WAVM/VFS/SandboxFS.h",
    "chars": 231,
    "preview": "#pragma once\n\n#include <memory>\n#include <string>\n\nnamespace WAVM { namespace VFS {\n\tstruct FileSystem;\n\tWAVM_API std::s"
  },
  {
    "path": "Include/WAVM/VFS/VFS.h",
    "chars": 6379,
    "preview": "#pragma once\n\n#include <string>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Inline/Time.h\"\n\nnamespace WAVM { name"
  },
  {
    "path": "Include/WAVM/WASI/WASI.h",
    "chars": 1163,
    "preview": "#pragma once\n\n#include <functional>\n#include <memory>\n#include <string>\n#include <vector>\n#include \"WAVM/Inline/BasicTyp"
  },
  {
    "path": "Include/WAVM/WASI/WASIABI.LICENSE",
    "chars": 7048,
    "preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
  },
  {
    "path": "Include/WAVM/WASI/WASIABI.h",
    "chars": 17828,
    "preview": "// WASI syscall API definitions\n// Derived from wasi-sysroot:\n// https://github.com/CraneStation/wasi-sysroot/blob/32005"
  },
  {
    "path": "Include/WAVM/WASM/WASM.h",
    "chars": 1004,
    "preview": "#pragma once\n\n#include <string>\n#include <vector>\n#include \"WAVM/IR/Validate.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n\nnam"
  },
  {
    "path": "Include/WAVM/WASTParse/TestScript.h",
    "chars": 11163,
    "preview": "#pragma once\n\n#include <cstring>\n#include <memory>\n#include <string>\n#include <utility>\n#include <vector>\n#include \"WAVM"
  },
  {
    "path": "Include/WAVM/WASTParse/WASTParse.h",
    "chars": 1874,
    "preview": "#pragma once\n\n#include <string>\n#include <vector>\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Logging/Logging.h\"\n"
  },
  {
    "path": "Include/WAVM/WASTPrint/WASTPrint.h",
    "chars": 213,
    "preview": "#pragma once\n\n#include <string>\n\nnamespace WAVM { namespace IR {\n\tstruct Module;\n}}\n\nnamespace WAVM { namespace WAST {\n\t"
  },
  {
    "path": "Include/WAVM/wavm-c/wasm-c-api.LICENSE",
    "chars": 11358,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "Include/WAVM/wavm-c/wavm-c.h",
    "chars": 24934,
    "preview": "// WebAssembly C API\n\n#ifndef __WASM_H\n#define __WASM_H\n\n#include <assert.h>\n#include <stdbool.h> // IWYU pragma: keep\n#"
  },
  {
    "path": "LICENSE.txt",
    "chars": 1467,
    "preview": "Copyright (c) 2026, Andrew Scheidecker\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "Lib/DWARF/CMakeLists.txt",
    "chars": 155,
    "preview": "set(Sources\n\tDWARF.cpp)\nset(PublicHeaders\n\t${WAVM_INCLUDE_DIR}/DWARF/DWARF.h)\n\nWAVM_ADD_LIB_COMPONENT(DWARF\n\tSOURCES ${S"
  },
  {
    "path": "Lib/DWARF/DWARF.cpp",
    "chars": 40119,
    "preview": "// Signal-safe, zero-allocation DWARF v4/v5 parser for source location lookup.\n// Parses .debug_info, .debug_abbrev, and"
  },
  {
    "path": "Lib/IR/CMakeLists.txt",
    "chars": 693,
    "preview": "set(Sources\n\tDisassemblyNames.cpp\n\tFeatureSpec.cpp\n\tFloatPrinting.cpp\n\tOperators.cpp\n\tModule.cpp\n\tRandomModule.cpp\n\tType"
  },
  {
    "path": "Lib/IR/DisassemblyNames.cpp",
    "chars": 12945,
    "preview": "#include <new>\n#include <string>\n#include <utility>\n#include <vector>\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Type"
  },
  {
    "path": "Lib/IR/FeatureSpec.cpp",
    "chars": 1249,
    "preview": "#include \"WAVM/IR/FeatureSpec.h\"\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include \"WAVM/Plat"
  },
  {
    "path": "Lib/IR/FloatPrinting.cpp",
    "chars": 3461,
    "preview": "#include <string>\n#include \"WAVM/IR/Types.h\"\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#includ"
  },
  {
    "path": "Lib/IR/Module.cpp",
    "chars": 3430,
    "preview": "#include \"WAVM/IR/Module.h\"\n#include <utility>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n\nusin"
  },
  {
    "path": "Lib/IR/Operators.cpp",
    "chars": 377,
    "preview": "#include \"WAVM/IR/Operators.h\"\n\nusing namespace WAVM;\nusing namespace WAVM::IR;\n\nconst char* IR::getOpcodeName(Opcode op"
  },
  {
    "path": "Lib/IR/RandomModule.cpp",
    "chars": 44336,
    "preview": "#include \"WAVM/IR/RandomModule.h\"\n#include <cstdint>\n#include <cstring>\n#include <functional>\n#include <memory>\n#include"
  },
  {
    "path": "Lib/IR/Types.cpp",
    "chars": 4979,
    "preview": "#include \"WAVM/IR/Types.h\"\n#include <stdlib.h>\n#include <string.h>\n#include <initializer_list>\n#include <vector>\n#includ"
  },
  {
    "path": "Lib/IR/Validate.cpp",
    "chars": 46325,
    "preview": "#include \"WAVM/IR/Validate.h\"\n#include <stdint.h>\n#include <memory>\n#include <string>\n#include <utility>\n#include <vecto"
  },
  {
    "path": "Lib/LLVMJIT/CMakeLists.txt",
    "chars": 1621,
    "preview": "# Convert LLVM_DEFINITIONS from a string of space-separated elements to a CMake list.\n# (find_package(LLVM) is called in"
  },
  {
    "path": "Lib/LLVMJIT/Disassembler.cpp",
    "chars": 6219,
    "preview": "#include <memory>\n#include <string>\n#include <utility>\n#include <vector>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/"
  },
  {
    "path": "Lib/LLVMJIT/EmitContext.h",
    "chars": 14240,
    "preview": "#pragma once\n\n#include <cstddef>\n#include <initializer_list>\n#include <vector>\n#include \"LLVMJITPrivate.h\"\n#include \"WAV"
  },
  {
    "path": "Lib/LLVMJIT/EmitConvert.cpp",
    "chars": 29540,
    "preview": "#include <stdint.h>\n#include \"EmitContext.h\"\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\"\n#include \"L"
  },
  {
    "path": "Lib/LLVMJIT/EmitCore.cpp",
    "chars": 17057,
    "preview": "#include <cstddef>\n#include <cstdint>\n#include <vector>\n#include \"EmitContext.h\"\n#include \"EmitFunctionContext.h\"\n#inclu"
  },
  {
    "path": "Lib/LLVMJIT/EmitExceptions.cpp",
    "chars": 13464,
    "preview": "#include <stddef.h>\n#include <vector>\n#include \"EmitContext.h\"\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleCont"
  },
  {
    "path": "Lib/LLVMJIT/EmitFunction.cpp",
    "chars": 13369,
    "preview": "#include <stdint.h>\n#include <cstddef>\n#include <initializer_list>\n#include <string>\n#include <vector>\n#include \"EmitFun"
  },
  {
    "path": "Lib/LLVMJIT/EmitFunctionContext.h",
    "chars": 8998,
    "preview": "#pragma once\n\n#include <algorithm>\n#include <initializer_list>\n#include <string>\n#include <vector>\n#include \"EmitContext"
  },
  {
    "path": "Lib/LLVMJIT/EmitMem.cpp",
    "chars": 45980,
    "preview": "#include <cstddef>\n#include \"EmitContext.h\"\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\"\n#include \"LL"
  },
  {
    "path": "Lib/LLVMJIT/EmitModule.cpp",
    "chars": 12217,
    "preview": "#include <stdint.h>\n#include <cstring>\n#include <vector>\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\""
  },
  {
    "path": "Lib/LLVMJIT/EmitModuleContext.h",
    "chars": 2156,
    "preview": "#pragma once\n\n#include <vector>\n#include \"LLVMJITPrivate.h\"\n#include \"WAVM/IR/Module.h\"\n#include \"WAVM/IR/Types.h\"\n#incl"
  },
  {
    "path": "Lib/LLVMJIT/EmitNumeric.cpp",
    "chars": 47716,
    "preview": "#include <stdint.h>\n#include \"EmitContext.h\"\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\"\n#include \"L"
  },
  {
    "path": "Lib/LLVMJIT/EmitTable.cpp",
    "chars": 5942,
    "preview": "#include <cstddef>\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\"\n#include \"LLVMJITPrivate.h\"\n#include "
  },
  {
    "path": "Lib/LLVMJIT/EmitVar.cpp",
    "chars": 5704,
    "preview": "#include <cstddef>\n#include <vector>\n#include \"EmitFunctionContext.h\"\n#include \"EmitModuleContext.h\"\n#include \"LLVMJITPr"
  },
  {
    "path": "Lib/LLVMJIT/GDBRegistration.cpp",
    "chars": 2658,
    "preview": "// GDB JIT Interface - allows GDB to see JIT-compiled code.\n// See: https://sourceware.org/gdb/current/onlinedocs/gdb.ht"
  },
  {
    "path": "Lib/LLVMJIT/LLVMCompile.cpp",
    "chars": 7798,
    "preview": "#include <string.h>\n#include <memory>\n#include <string>\n#include <utility>\n#include <vector>\n#include \"LLVMJITPrivate.h\""
  },
  {
    "path": "Lib/LLVMJIT/LLVMJIT.cpp",
    "chars": 11714,
    "preview": "#include \"WAVM/LLVMJIT/LLVMJIT.h\"\n#include <cstring>\n#include <memory>\n#include <optional>\n#include <string>\n#include <u"
  },
  {
    "path": "Lib/LLVMJIT/LLVMJITPrivate.h",
    "chars": 14164,
    "preview": "#pragma once\n\n#include <map>\n#include <memory>\n#include <string>\n#include <vector>\n#include \"WAVM/DWARF/Sections.h\"\n#inc"
  },
  {
    "path": "Lib/LLVMJIT/LLVMModule.cpp",
    "chars": 13822,
    "preview": "#include <stddef.h>\n#include <stdint.h>\n#include <map>\n#include <memory>\n#include <string>\n#include <string_view>\n#inclu"
  },
  {
    "path": "Lib/LLVMJIT/Thunk.cpp",
    "chars": 6353,
    "preview": "#include <stddef.h>\n#include <stdint.h>\n#include <memory>\n#include <string>\n#include <utility>\n#include <vector>\n#includ"
  },
  {
    "path": "Lib/Logging/CMakeLists.txt",
    "chars": 163,
    "preview": "set(Sources\n\tLogging.cpp)\nset(PublicHeaders\n\t${WAVM_INCLUDE_DIR}/Logging/Logging.h)\n\nWAVM_ADD_LIB_COMPONENT(Logging\n\tSOU"
  },
  {
    "path": "Lib/Logging/Logging.cpp",
    "chars": 2625,
    "preview": "#include \"WAVM/Logging/Logging.h\"\n#include <atomic>\n#include <cstdarg>\n#include <cstdio>\n#include \"WAVM/Inline/Assert.h\""
  },
  {
    "path": "Lib/NFA/CMakeLists.txt",
    "chars": 147,
    "preview": "set(Sources\n\tNFA.cpp)\nset(PublicHeaders\n\t${WAVM_INCLUDE_DIR}/NFA/NFA.h)\n\nWAVM_ADD_LIB_COMPONENT(NFA\n\tSOURCES ${Sources}\n"
  },
  {
    "path": "Lib/NFA/NFA.cpp",
    "chars": 20985,
    "preview": "#include \"WAVM/NFA/NFA.h\"\n#include <string.h>\n#include <algorithm>\n#include <cstdint>\n#include <string>\n#include <vector"
  },
  {
    "path": "Lib/ObjectCache/CMakeLists.txt",
    "chars": 213,
    "preview": "set(Sources\n\tObjectCache.cpp)\nset(PublicHeaders\n\t${WAVM_INCLUDE_DIR}/ObjectCache/ObjectCache.h)\n\nWAVM_ADD_LIB_COMPONENT("
  },
  {
    "path": "Lib/ObjectCache/ObjectCache.cpp",
    "chars": 22390,
    "preview": "#include \"WAVM/ObjectCache/ObjectCache.h\"\n#include <errno.h>\n#include <cinttypes>\n#include <cstdint>\n#include <cstring>\n"
  },
  {
    "path": "Lib/ObjectLinker/CMakeLists.txt",
    "chars": 274,
    "preview": "set(Sources\n\tObjectLinker.cpp\n\tCOFF.cpp\n\tELF.cpp\n\tMachO.cpp)\nset(PrivateHeaders\n\tObjectLinkerPrivate.h)\nset(PublicHeader"
  },
  {
    "path": "Lib/ObjectLinker/COFF.cpp",
    "chars": 31116,
    "preview": "#include <cinttypes>\n#include <cstdlib>\n#include <cstring>\n#include <string>\n#include <utility>\n#include <vector>\n#inclu"
  },
  {
    "path": "Lib/ObjectLinker/ELF.cpp",
    "chars": 22430,
    "preview": "#include <cinttypes>\n#include <cstring>\n#include <string>\n#include <utility>\n#include <vector>\n#include \"ObjectLinkerPri"
  },
  {
    "path": "Lib/ObjectLinker/MachO.cpp",
    "chars": 42639,
    "preview": "#include <algorithm>\n#include <cinttypes>\n#include <cstdint>\n#include <cstring>\n#include <string>\n#include <utility>\n#in"
  },
  {
    "path": "Lib/ObjectLinker/ObjectLinker.cpp",
    "chars": 9329,
    "preview": "// Object linker: layout, memory protection, relocation application, stubs, and GOT.\n// Format-specific parsers (COFF.cp"
  },
  {
    "path": "Lib/ObjectLinker/ObjectLinkerPrivate.h",
    "chars": 6900,
    "preview": "#pragma once\n\n// Internal types shared between ObjectLinker.cpp and format-specific files.\n\n#include <cinttypes>\n#includ"
  },
  {
    "path": "Lib/Platform/CMakeLists.txt",
    "chars": 4273,
    "preview": "include(CheckSymbolExists)\n\nset(POSIXCppSources\n\tPOSIX/ClockPOSIX.cpp\n\tPOSIX/ConditionVariablePOSIX.cpp\n\tPOSIX/CPUPOSIX."
  },
  {
    "path": "Lib/Platform/POSIX/CPUPOSIX.cpp",
    "chars": 1669,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include \"WAVM/Platform/CPU.h\"\n\n#if WAVM_CPU_ARCH_ARM\n#if defined(__APPLE__)\n#include <sys/sysc"
  },
  {
    "path": "Lib/Platform/POSIX/ClockPOSIX.cpp",
    "chars": 3196,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <time.h>\n#include \"WAVM/Inline/Assert.h\"\n#include \"WAVM/Inline/BasicTypes.h\"\n#include "
  },
  {
    "path": "Lib/Platform/POSIX/ConditionVariablePOSIX.cpp",
    "chars": 2741,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <errno.h>\n#include <pthread.h>\n#include <time.h>\n#include \"WAVM/Inline/Assert.h\"\n#incl"
  },
  {
    "path": "Lib/Platform/POSIX/DebugPersonality.cpp",
    "chars": 15338,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <stdlib.h>\n#include <unwind.h>\n#include <unwind_itanium.h>\n#include <cinttypes>\n#inclu"
  },
  {
    "path": "Lib/Platform/POSIX/DiagnosticsPOSIX.cpp",
    "chars": 2563,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <dlfcn.h>\n#include <stdio.h>\n#include <atomic>\n#include <cinttypes>\n#include <cstdint>"
  },
  {
    "path": "Lib/Platform/POSIX/EHFrameDecode.cpp",
    "chars": 14317,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <cinttypes>\n#include <cstring>\n#include \"WAVM/DWARF/Constants.h\"\n#include \"WAVM/Inline"
  },
  {
    "path": "Lib/Platform/POSIX/ErrorPOSIX.cpp",
    "chars": 2406,
    "preview": "#if WAVM_PLATFORM_POSIX\n\n#include <atomic>\n#include <cstdarg>\n#include <cstdio>\n#include <cstdlib>\n#include <utility>\n#i"
  }
]

// ... and 862 more files (download for full content)