issues.txt

Prio	Component	Issue
-------------------------------
	bin		Refactor WasmParser to be WasmReader
	bin		reorganize BinParser, BpFsm, and WasmParser
	ci		test tail-call, multi-memory, function-references, gc, exception-handling, stack-switching, custom-page-sizes, extended-const
	eh		implement catch in SPC
	ext		custom-page-sizes
	ext		memory64
	ext		threads
	fast-int	Optimize 4-byte sidetable entry loads
	fast-int	tune: handler order, alignment
	fast-int	tune: hot-swap bytecode implementations, e.g. memory64
	fast-int	tune: inline some extended LEB cases?
	fast-int	tune: preload next handler at beginning of handler
	fast-int	tune: register assignment
	fast-int	tune: use 2^n-byte handler blocks to avoid load for first dispatch
	gc		tests for binary iso-rec canonicalization
	gc		tests for verifying supertype decls
	interpreter	compress ctlxfer entries (4 byte cases)
        masm            add utilities for all Virgil object accesses
        masm            add utility for building correct runtime calls
        masm            add utility for building correct Virgil calls
        masm            add utility for calling Runtime directly instead of X86_64Runtime
	monitors	Test and handle multi-module cases
	parse		Simplify BinParser state machine
	parse		Tracing of indexes/offsets might be wrong
	spc		Always allocate registers for transfer values
	spc		Analyze loop for read/written locals
	spc		Explore loop peeling
	spc		Improve prologue; assume instance, mem0_base in registers
	spc		Load hot locals before loop
	spc		Optimize empty transfers
	spc		implement deoptimization for inserting probes when on-stack
	spc		inlining of direct calls / whamm probes
	spc		instr-combine for cmp+branch
	spc		unit-test SpcState
	spc		unit-test regalloc
	spec		is it legal to have 0-count funcs and no code section?
	test		Add fuzzy-matching of stacktraces for CRASH opcodes
	test		Add testing of --trace-interpreter and --trace-calls
	test		Test proper value tags in SPC/int
	test		all ext:gc instructions
	tuning		Add command-line and build-time options for tuning parameters
	util		Dump module into text format
	util		Improve objdump utility, add control rendering
	util		Test objdump utility with canned modules
	v3-int		Implement and use NativeMemory
	v3-int		Implement and use NativeValueStack
	validator	prettier trace output
	validator	typecheck whole signatures at a time
	wasi		Implement x86-64-linux wasi
	wizeng		Eager pre-linking of some host modules
	wizeng		Lazy link errors for unbound imports that are never called
	wizeng		Load tool-convention core dumps
	wizeng		repl for loading and running modules

Monitors + trace
--------------------------------
	All --trace-interpreter, memory, calls, etc output events in code in common nested call trace format
	   > func1
	     > func2A
	       call event
	       > func3
	         instr event
	         memory access event
	     > func2B
	--trace-interpreter accepts a function filter
	--break-at inserts breakpoints at given location(s) and drops into debugger
	--trace-at inserts tracepoints at given location(s)
	build general-purpose "what is this program doing" monitor
	CallsMonitor should report source-names of callees
	--trace-tables should report read/write/calls through tables
	TrapsMonitor shows state of program at trap points (default?)
	VirgilMonitor hooks into sections of Virgil-generated Wasm
	--trace-exception tracks try/throw/catch
	MallocMonitor tracks malloc/free behavior
           - tries to find memory leaks
	   - perf metrics: total usage, average usage, distribution of alloc sizes, free distance
	   - heatmap of allocation sites, memory ranges
	   - timeseries of memory consumption (bytes, objects)
	   - lifetime analysis (time between allocate and free)
	MemoryMonitor records/reports at multiple granularities
	   - read/write count
	   - strides (FFT somehow ?), use prefetching detector algorithms
	   - hotness / heatmap
	   - memory access density (accesses per 1000K instructions)
	   - aliasing relationship between "pointers" into memory
	   - how often contents of memory change
	CacheMonitor simulates and analyzes cache behavior
	BranchPredictMonitor simulates and analyzes branch predictor behavior
	DebugMonitor supports tab completion, uncooked terminal, etc
	PathsMonitor profiles program paths
	PhaseMonitor detects program phases
	ObjectMonitor tracks allocations and mutations for WasmGC objects
	-trace-calls, trace-globals, trace-tables show mutations
	-trace-memory should show what memory monitor does currently
	Global call stack depth tracking for monitor outputs
	       events: instructions, calls, exceptions
	Coverage monitor should have more useful default output
	{Instr,Block}TraceMonitor outputs compressed instruction/block traces for analysis
	ProfileMonitor:
		add a flat mode that is more efficient
		add profiling of compilation, runtime, gc, and host calls
	Hooks needed:
	  - wasm: traps, throw/catch, memory access, suspend/resume, host calls, frame unwind
	  - engine: gc, compile, load, verify
        LoopMonitor	track and display loop count distribution, improve display
	Interactive - show an interactive, terminal-animated view of execution, e.g. which function
		    func | xxx xx | <- color indicates how recent / hot
		    mem  | ====== |
	ConstMonitor - track const load/store, global get/set
	   - track whether a given store instruction>
	     - always stores to the same address
	   - track whether a given load instruction:
	     - always loads from the same address
	     - always loads the same value => partial eval
	     - always loads data that is not later modified by the program => partial eval
	   - track whether a given global.get:
	     - always loads the same value
	   - track whether a given global.set:
	     - always writes the same value
	FuncMemAccessMonitor - compute the set of accessed memory for each function
	   - Does a given function
	     - access a fixed number of unique locations (e.g. close to a param)
	       => lift loads and sink stores, make function pure
	     - access memory in linear strides
	     - access memory through chaining (taint)
	   - Can use dataflow analysis from arguments to determine input addresses
	DeadCodeEliminator
	   - uses results from coverage to insert UNREACHABLE into unreachable paths,
	     then feed to optimizer like Binaryen
	NanCanonicalizer
	   - probe all instructions that can produce NaN and replace result via
	     FrameAccessor with canonical nan (or 0, like denan from Binaryen)
	Taint
	   - propagate taint labels from certain calls through locals, memory, tables,
	     remove them through certain calls, and check they don't reach other calls.
	Memoizer
	   - detect statically=, dynamically=, and empirically-pure functions
	   - for functions that read mutable state, consider the values of recorded
	     mutable locations as part of the key for memoization
	Metadata
	   - estimate of metadata usage for the program, including size of module,
	     tables, functions, objects, stacks etc



Test Coverage
--------------------------------
Interpreter
	doCallHost of null host function
	doCallFunction of host function
	pushFrame of EXTERNREF, FUNCREF, RefNullFunc locals
	traceCallHostFunction deeper than 0
	loop unbounded

Memory
	.new with OOM
	.read/write OOB for all elem sizes
	.copyD of null
	.size of null

SpecTestParser
	.parseCommand error
	.parseList boundary conditions
	.parseOneCommandForTesting boundary conditions
	.parseExpectedValue i64, f32, f64, refnull, refextern

BinParser
	invalid section code
	render invalid type con
	.readElemFuncIndexes of FUNCREF, FuncRef, ExternRef
	.readValueType of VEC128
	.readDataIndex max > explicit_data_count
	invalid import/export kind
	renderLimitFlags of shared
	readMemoryArg of full memory index
	readLabels exceeding maximum
	custom section name length too long
	readDataDecl with different flags settings
	readInitExpr readRefNull type
	readMemoryLimits expecting shared memory maximum
	decodeFunctionBody func count mismatch
	decodeFunctionBody with code validation
	readBlockType of double, vec128
	readBlockType with function types
	readRefType of function types
	readElemDecl

Values
	.f64 of underflow exponent
	.render of host function

ValueType
	.render of vec 128

Arrays
	.boundsCheck of null
	.map of null

Instantiator
	check data bounds of null memory
	check limits of Max.None
	check elem bounds of expressions
	checkBounds fails

Instance
	evalInitExpr of f32, f64, FUNCREF, EXTERNREF, global

CodeValidator
	.checkArgs of null
	.readLocals exceeds maximum
	.mergeTypesAt, invalid block type
	checkAlignment (loads/stores)
	table.init: element type mismatch

CtlXferTest
	0 entries

Result
	.equals of mismatched sizes

Opcodes
	.renderInstr of not found prefix
	.readBlockType .readValueType PARAM_INDEX
	.find with 0 prefix
Max
	.check of None
	.min of None

Utf8
	.findError of null

Strings
	.equals of null

StringBuilder
	.putx of u16

Stack
	.pop of empty stack
	.pushA with grow
	.resize

Decoder
	.read_x64leb with EOF
	.read_u64 with EOF
	.skip_bytes with EOF
	.check_bytes with EOF

Module
	.addDef of AbsTypeDecl
	.addDef of EventDecl

AbsTypeDecl
	.render of imported

BinBuilder
	.put_ValueType

ElemDetails
	.length of exprs

HostType
	.isAssignableTo

V3C optimization hints
--------------------------------
Value representation
Inline 1-byte case of LEB
Inline SpcVal methods
Inline Values.v_* methods
Inline V3Interpreter.do_ii_i methods
Inline WasmObject.values array

Done
--------------------------------
        spc             support all Wasm-GC opcodes
	spc		non-final subtyping check for call_indirect
	gc		implement array.new_data, array.new_elem in init expressions
	gc		Test for final types
	monitor		Track runtime function argument consts to detect specialization/inlining opportunities
	ext		extended constants
        fast-int        non-final subtyping check for call_indirect
	interpreter	implement atomics
        BranchMonitor   print full CFG and block nesting (done in ControlMonitor)
	ext		gc
	ext		function-references
	wave		Run monitor reports on System.error
	ctlxfer		more tests for greater depths
        spc             -jit-filter for debugging
	validator	more br tests
	ext		exception-handling
	eh		implement catch in fast int
        spc,fast-int    Unwind stack instead of checks for abrupt return
        loop-monitor    Don't show output of 0-count loops by default
        v3-int          implement simd
        fast-int        tune: loop for repeated blocks
	ext		multi-memory
        validate        move init expr validation into CodeValidator
        fast-int        tune: inline dispatch of END
        eh              Implement option B' for exnref
	gc		array.fill, array.new_data, array.new_elem
        wizeng          basic profiler
        fast-int        implement simd
	spc		implement simd
	wizeng		wizeng module: rdtsc call
        spc             trap locations and stacktraces
	spc		allow register to be used for more than one slot
	tiering		implement dynamic tier-up
        test		Add crash-exec and crash-compile bytecodes
	test		measure and report execution time of individual tests
	spc		lazy compilation
	spc		return_call_indirect
        wizeng          trace calls
	fast-int	stack traces for wasm traps
        spc             implement state splitting/merging
	ext		tail-call
	v3-int	        print value stack / call stack in tracing mode
        probes          Probes should support full frame access
        wizeng          run start function of modules
        func-refs       no subtyping for function references without gc proposal
        gc              new array opcodes
	fast-int	scan value stack for GC
        interpreter     rename Xcode to sidetable
        fast-int        support main loop probe
        fast-int        support extended LEB secondary opcodes
        gc              Refactor type comparison for iso-recursion
        validate        implement simd
        opcodes         add simd
        fast-int        tagless interpreter
	fast-int	support instruction probes
        interpreter     reimplement break support using probes
        interpreter     reimplement timeout support using probes
	interpreter	support probes
	fast-int	Implement tail calls
        fast-int        Implement BREAK opcode
	fast-int	save VSP into ValueStack for runtime calls
        fast-int        Direct calls to runtime functions
        fast-int        Include descriptions of interpreter frames in fatal errors
        wizeng          trace imports/modules
	fast-int	scan interpreter frames for GC
        trace           Unify all tracing patterns as if(Trace.foo)
	build		sense host platform
	fast-int	skip tag for ref<T> types
        fast-int        allocate binary space for interpreter code
	fast-int	gen code into global array
        fast-int        4 byte entries in dispatch table
	interpreter	factor context out of v3 int and fast int
	test		support TEST_TARGET= for all tests
	fast-int	refactor codegen to eliminate looping over bytecodes
	runtime		Fast native memories (pointer, memmap)
	binary		Parse names section
	trace		Reuse opcode renderer across calls
	unit		Improve overall unit testing framework
	validator	bug: Unreachable in one-armed if-value
	wave		implementation to bootstrap Virgil
	instance	Write unit tests for instantiation
	interpreter	test host functions
	interpreter	multivalue blocks, loops
	ext		bulk_memory
	ext		reference_types
	ext		sign_extension
	ext		tail_call: interpreter
	ext		multiple_memories
	ext		non_trapping_fic
	spec		floating point opcodes
	interpreter	floating point
	ext		tail_call: opcodes and validation
	spec		spectest includes 0xFFFE and 0xFFFF special characters
	binparse	offsets for errors incorrectly buffer relative
	binparse	reduce type specialization of readMultiple<T>
	validator	check for mutability of global in write
	spec		subnormal floats
	spec		br_table popcount bug
	spec		br_table merging of types
	spec		binary LEB 5-byte limit
	spec		elements bugs
	spec		duplicate export name
	spec		invalid memory flags
	spec		parse unicode escapes in strings
	spec		assign to immutable global
	spec		invalid global flags
	spec		assert_trap of module: start function
	spec		UTF-8 encoding
	spec		br_if bugs
	util		use "def var" Virgil feature for .length
	spec		support _ in literals
	binparse	tests for streaming
	config		properly check config settings for decoding and running
	instance	move oom logic into instantiator, out of constructors
	trace		Always use StringBuffer.out(STDOUT)
	validator	multivalue blocks, loops
	test		spec test loader and runner
	interpreter	memory index decoding
	core		introduce Extension enum
	binparse	double check memory operand decoding
	validator	check alignment of memory operators
	interpreter	convert unit tests to params, results order
	binparse	write tests for binary decoding