feat: complete ISLE pipeline coverage — all standard WASM instructions

[avrabe]

Summary

This PR achieves 100% ISLE pipeline coverage for all standard WebAssembly instructions. Every function in standard-compliant WASM files now gets full optimization — the skip block only triggers for Unknown (unrecognized) opcodes.

Changes by commit:

1. Memory index tracking (763a261): Add mem field to all load/store instructions, generalize multi-memory adapter collapse
2. Fused optimizer relaxation (fa7f744): Allow memory stores in same-memory adapters
3. F32/F64 constants + arithmetic (91a28c4): Wire f32.const, f64.const, and 8 float arithmetic ops (add/sub/mul/div) into ISLE
4. F64 constant folding tests (0a4d29b): Add F64 test coverage, re-enable I64 optimization tests
5. 32 float operations (b3a8470): Wire all remaining float ops (unary, binary, comparison) — abs, neg, ceil, floor, trunc, nearest, sqrt, min, max, copysign, eq/ne/lt/gt/le/ge for both f32 and f64
6. Edition 2024 (48ddc88): Upgrade to Rust edition 2024 and MSRV 1.85
7. 30 conversion operations (85076af): Wire all trapping truncations, saturating truncations, int↔float conversions, demote/promote, and reinterpret bit-casts
8. MemorySize/MemoryGrow + CallIndirect/BrTable (f50dd04): Wire memory ops, remove CallIndirect/BrTable from skip block, fix CallIndirect stack validation with type_signatures
9. Bulk memory ops (056ad88): Wire MemoryFill/MemoryCopy/MemoryInit/DataDrop — eliminates skip block entirely

Skip block elimination

Before: 70+ instruction types blocked (all floats, conversions, memory ops, call_indirect, br_table, bulk memory)
After: Only Unknown opcodes blocked — all standard WASM instructions supported

Key design decisions

• Trapping truncations only fold when value is in range (not NaN, not overflow) — preserves trap semantics
• Saturating truncations always fold: NaN→0, overflow→clamp per WASM spec
• Float min/max fold only when both operands are non-NaN (WASM returns NaN if either is NaN)
• CallIndirect removed from contains_unanalyzable_instructions when module context available — type_idx provides full stack signature statically
• BrTable still protected by has_dataflow_unsafe_control_flow for term-rewriting, but now gets DCE, branch simplification, code folding, etc.
• Bulk memory ops treated as side effects in instructions_to_terms (consume stack values, produce no stack output)
• Z3 verification upgraded with concrete computation for all float and conversion operations

Test plan

• 224+ lib tests pass (including new memory, call_indirect, bulk memory tests)
• 82 optimization tests pass
• 32 Z3 verification tests pass
• 5 stress tests pass (including 10K EMI iterations)
• All real-world WASM files optimize correctly
• Pre-commit hooks pass (fmt, clippy, test, build)

🤖 Generated with Claude Code

[temper-pulseengine]

AI Code Review for PR #53

The provided code snippet is a series of tests for various optimizations and deduplication passes in the WebAssembly binary format. These tests are part of a larger suite that verifies the correctness of the WebAssembly toolchain, specifically focusing on memory management and optimization.

Here's a breakdown of the key points from the code:

1. Memory Import Deduplication Tests (Pass 0a):

   • The deduplicate_memory_imports function is tested to ensure it correctly deduplicates identical memory imports.
   • Various scenarios are tested, including different module names, names, limits, and whether they share a local memory.

2. Memory Copy Remapping:

   • Functions with MemoryCopy instructions are tested to ensure that they are remapped to use the same memory index after deduplication.
   • This is crucial for maintaining consistency in memory usage across functions.

3. Data Segment Remapping:

   • Data segments associated with specific memory indices are checked to see if they are correctly remapped to a new index after deduplication.
   • This ensures that data segments are not duplicated and are properly managed.

4. Memory Export Deduplication:

   • Memory exports are tested to ensure that they are correctly updated to use the same memory index after deduplication.
   • This is important for maintaining consistency in how memory is exported from WebAssembly modules.

5. Adapter Collapse Optimization:

   • The deduplicate_memory_imports function is also tested to see if it enables the optimization of adapter functions, which are used to manage memory allocations and deallocations.
   • This ensures that deduplication does not interfere with optimizations that rely on specific memory indices.

6. Type Deduplication:

   • The deduplicate_types function is tested to ensure it correctly removes duplicate type definitions.
   • This is important for maintaining a clean and efficient WebAssembly module by removing unnecessary type declarations.

These tests are crucial for ensuring the reliability and performance of WebAssembly tools, particularly in scenarios where memory management and optimization are critical.

---

Reviewed by qwen2.5-coder:3b (local Ollama). Advisory only — may miss issues or report false positives.

Commands

Command	Description
/ask <question>	Discuss this review — ask questions or disagree with findings
/review-pr	Re-run the review from scratch
/review-pr <focus>	Re-run with specific instructions (e.g. /review-pr focus on error handling)