ed/pikuma_ps1
1
0
Fork 0
mirror of https://github.com/Ed94/pikuma_ps1.git synced 2026-08-05 07:08:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Lua Metaprogram: Improvements to static analysis + others.

Browse Source
This commit is contained in:
ed
2026-07-23 10:18:30 -04:00
parent 67d54debfa
commit 08af73d0d2
13 changed files with 871 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/passes/static_analysis.lua
+266 -83
View File
@@ -1,26 +1,38 @@
--- passes/static_analysis.lua — Per-atom static-analysis checks.
---
--- The 9 checks currently shipped:
--- Per-atom rules:
--- 1. **GTE pipeline-fill** — every `gte_cmdw_*` invocation must be preceded by the minimum number of `nop` words
--- (per `duffle.GTE_PIPELINE_LATENCY`) so the COP2 pipeline latency is fully retired before the command issues.
--- 2. **mac_yield uniformity** — every atom body must contain exactly one `mac_yield()` call (control transfer pattern).
--- 3. **ABI handoff** — every `atom_bind(Binds_X)` must reference a `typedef Struct_(Binds_X) { ... }` declaration.
--- 4. **GPU port-store shape** — per-shape (`f3`/`f4`/`g4`/etc.) the sum of `mac_format_X_color` + `mac_gte_store_X_*` +
--- `mac_insert_ot_tag_X` words must equal the GP0 cmd's expected packet size.
--- 5. **per-atom cycle budget** — sum each atom body's instruction latencies (per `duffle.INSTRUCTION_LATENCY`); report total.
--- Per-source rules (registry-driven, added 2026-07-16):
--- 6. **enum_alias_membership** — every `R_X` referenced from `atom_dbg_reg_default`, `atom_reg_types`,
--- `atom_type(...)`, `atom_reads`, or `atom_writes` must be in `scan.register_alias_registry`. Missing -> warning.
--- 7. **atom_type_consistency** — every `reg_type_overrides[R_X].type_name` must resolve in `scan.type_name_registry`. Missing -> error.
--- 8. **binds_no_substruct_deref** — every `load_word(R_A, R_B, O_(Type, Field))` and `store_word(...)` in every atom body
--- must reference a leaf scalar (pointer-to-struct counts as leaf; nested struct members do NOT). Missing -> warning (build continues).
--- 9. **reads_writes_alias_membership** — distinct check name duplicating #6's reads/writes coverage so the report can
--- attribute failures to a precedence class. Missing -> warning (build continues).
--- Per-atom rules:
--- 1. gte_write_retire: Every `gte_mv_to_data_r` / `gte_mv_to_ctrl_r` (CPU-to-COP2 write) must retire the documented slot count
--- (`duffle.COP2_WRITE_RETIRE_SLOTS`: 2 slots default, 3 slots for writes to `gte_cr_IRGB` / `gte_cr_ORGB`)
--- before any subsequent `gte_cmdw_*` consumes one of the command's input registers (`duffle.GTE_COMMAND_INPUTS`).
--- The check walks `atom.paths.word_events` (the semantic emitted-word stream). Every emitted machine word
--- (including CPU ALU, branch, GTE transfer, `nop`/`nop2` half, and `mac_X(...)`-expanded words) counts as one retired slot.
--- 2. cop2_gpr_load_delay: Every `gte_mv_from_data_r` / `gte_mv_from_ctrl_r` (COP2-to-GPR read) requires 1 retired slot
--- before the destination GPR can be used as an operand of the next instruction.
--- The check walks `atom.paths.word_events` and consults `duffle.OPERAND_READ_POSITIONS` to classify which emitted tokens read each GPR operand position.
--- Branch delay slots are out of scope (separate MIPS control-flow concern).
--- 3. mac_yield uniformity: Every atom body must contain exactly one `mac_yield()` call (control transfer pattern).
--- 4. Binding handoff: Every `atom_bind(Binds_X)` must reference a `typedef Struct_(Binds_X) { ... }` declaration.
--- 5. GPU Port-Store Shape: Per-shape (`f3`/`f4`/`g4`/etc.) the sum of `mac_format_X_color` + `mac_gte_store_X_*` + `mac_insert_ot_tag_X` words
--- must equal the GP0 cmd's expected packet size.
--- 6. Per-Atom Cycle Budget: Sum each atom body's instruction latencies (per `duffle.INSTRUCTION_LATENCY`); report total.
---
--- Per-source rules (registry-driven):
--- 7. enum_alias_membership: Every `R_X` referenced from `atom_dbg_reg_default`, `atom_reg_types`, `atom_type(...)`, `atom_reads`, or `atom_writes`
--- must be in `scan.register_alias_registry`.
--- 8. atom_type_consistency: Every `reg_type_overrides[R_X].type_name` must resolve in `scan.type_name_registry`.
--- 9. binds_no_substruct_deref: Every `load_word(R_A, R_B, O_(Type, Field))` and `store_word(...)` in every atom body must reference a leaf scalar (pointer-to-struct counts as leaf;
--- nested struct members do NOT).
--- 10. reads_writes_alias_membership: Distinct check name duplicating #7's reads/writes coverage so the report can attribute failures to a precedence class.
---
--- The orchestrator (`ps1_meta.lua`) wires this module in via the PASSES table:
--- `["static-analysis"] = { module = "passes.static_analysis", kind = "validation", deps = {"word-counts", "components"},
--- out = { { kind = "report", path_template = "<out_root>/<basename>.static_analysis.txt" } } }`
--- `["static-analysis"] = {
--- module = "passes.static_analysis",
--- kind = "diagnostic",
--- deps = {"word-counts", "components"},
--- out = { { kind = "report", path_template = "<out_root>/<basename>.static_analysis.txt" } }
--- }
--- `kind = "diagnostic"` keeps every finding visible in the report; the orchestrator does not exit non-zero
--- on static-analysis errors. Annotation and header-output validation remain build-stopping.
---
--- **Conventions**: tabs (1/level), EmmyLua annotations, no regex, Lua 5.3 compatible.
@@ -122,7 +134,7 @@ local OUTPUT_EXTENSION = ".static_analysis.txt"
--- @field total_cycles integer -- sum of token cycle costs
-- ════════════════════════════════════════════════════════════════════════════
-- classify_tokens — per-token classification (the plex's pre-computed data layer)
-- classify_tokens — per-token classification
-- ════════════════════════════════════════════════════════════════════════════
-- ONE forward pass over the token list produces a flat table of per-token classifications.
@@ -250,54 +262,208 @@ local function classify_tokens(tokens)
end
-- ════════════════════════════════════════════════════════════════════════════
-- Check #1: GTE pipeline-fill
-- ════════════════════════════════════════════════════════════════════════════
-- Check #1: GTE CPU→C2 write retirement (producer/consumer scoreboard).
--
-- Reads `atom.paths.word_events` (the semantic emitted-word stream from `duffle.expand_word_events`).
-- Every `gte_mv_to_data_r` / `gte_mv_to_ctrl_r` event stages a write into a pending-writes queue;
-- Every `gte_cmdw_*` event intersects its command input set against the still-pending queue.
-- A write that has not retired its documented slot count (`M.COP2_WRITE_RETIRE_SLOTS.cpu_to_cop2`, override for writes to gte_cr_IRGB / gte_cr_ORGB) is reported as an `error`.
--
-- Convention: every emitted instruction slot — CPU ALU, branch, GTE transfer, GTE command, `nop`, `mask_upper` half, and every word expanded from a `mac_X(...)` component;
-- Counts as one retired slot.
-- This replaces the prior literal-NOP-prefix heuristic; the canonical `nop2` is the conservative fallback for callers that haven't modeled their producer/consumer pairs.
-- ─────────────────────────────────────────────────────────────────────────
-- Check a single gte_cmdw_* token for pipeline-fill compliance.
-- Uses the pre-computed `tok_class` entry (nop_prefix replaces the backward walk; ident replaces the per-token match).
local function check_one_gte_cmdw(atom, tc_entry, ti, line_in_body, findings)
local ident = tc_entry.ident
if not ident:match("^gte_cmdw_") then return end
-- Return true iff `reg_ident` is an IRGB/ORGB write that requires the 3-cycle fan-out.
local function is_irgb_destination(reg_ident)
return reg_ident == "gte_cr_IRGB" or reg_ident == "gte_cr_ORGB"
end
local variant = ident:match("^gte_cmdw_(.+)$")
local need = duffle.GTE_PIPELINE_LATENCY[ident]
local line = atom.line + line_in_body[atom.paths.tokens[ti].rel]
-- Look up the alias → canonical mapping.
-- Defaults to the input ident so MVMVA variants + unknown idents surface as `command_unknown` warnings rather than being silently treated as 0-cycle.
local function canonical_command(ident)
local aliases = duffle.GTE_COMMAND_ALIASES or {}
return aliases[ident] or ident
end
if need == nil then
findings[#findings + 1] = {
atom = atom.name,
line = line,
check = "gte_pipeline_fill",
kind = "warning",
msg = string.format(
"%s at line %d uses `gte_cmdw_%s` but that macro is not in duffle.GTE_PIPELINE_LATENCY -- add a min_nops entry",
atom.name, line, variant),
}
elseif need > 0 then
local have = tc_entry.nop_prefix
if have < need then
local function push_write(pending, reg_ident, slots, source_path, line)
pending[#pending + 1] = {
reg = reg_ident,
slots = slots,
source = source_path,
line = line,
}
end
local function retire_writes(pending, max_elapsed)
-- Walk pending in FIFO order; advance their slot counters; remove any whose counter has met or exceeded the required retire window.
-- The walk index advances monotonically; once a pending entry's `elapsed >= required` the slot is freed and the next pending entry can retire on the same cycle.
local out = {}
for i = 1, #pending do
pending[i].elapsed = (pending[i].elapsed or 0) + max_elapsed
if pending[i].elapsed < pending[i].slots then
out[#out + 1] = pending[i]
end
end
return out
end
local function check_gte_write_retire(atom, pipe_ctx, findings)
local events = atom.paths.word_events
if not events or #events == 0 then return end
local pending = {}
local inputs = duffle.GTE_COMMAND_INPUTS or {}
local slots_def = duffle.COP2_WRITE_RETIRE_SLOTS or { cpu_to_cop2 = 2, cpu_to_irgb = 3 }
for _, ev in ipairs(events) do
-- Every non-write slot retires pending writes by 1.
if ev.ident == "gte_mv_to_data_r" or ev.ident == "gte_mv_to_ctrl_r" then
local dest_reg = ev.args and ev.args[2] or nil
if dest_reg then
local required = is_irgb_destination(dest_reg) and slots_def.cpu_to_irgb or slots_def.cpu_to_cop2
push_write(pending, dest_reg, required, ev.source, ev.line)
end
-- Advance pre-existing writes by 1 (this very slot counts).
pending = retire_writes(pending, 1)
elseif ev.ident == "gte_cmdw_rtps" or ev.ident == "gte_cmdw_rtpt" or ev.ident == "gte_cmdw_nclip"
or ev.ident == "gte_cmdw_mvmva" or ev.ident == "gte_cmdw_op"
or ev.ident == "gte_cmdw_avsz3" or ev.ident == "gte_cmdw_avsz4"
or duffle.GTE_COMMAND_ALIASES[ev.ident] ~= nil
then
-- A dependent GTE command stalls until in-flight commands complete (hardware interlock).
-- We still retire all pending writes by 1 for the slot this command occupies, then check the still-pending writes against the command's input set.
-- If the command reads a register whose write is still pending, that is a true hazard.
pending = retire_writes(pending, 1)
local canonical = canonical_command(ev.ident)
local cmd_inputs = inputs[canonical]
if cmd_inputs == nil then
findings[#findings + 1] = {
atom = atom.name,
line = ev.line,
check = "gte_write_retire",
kind = "warning",
msg = string.format("%s at line %d uses `%s` but the canonical command is not in GTE_COMMAND_INPUTS -- add an entry (or confirm the alias)"
, atom.name, ev.line, ev.ident
),
}
else
for _, pw in ipairs(pending) do
-- Check intersection with the command's input set.
for _, in_reg in ipairs(cmd_inputs) do
if pw.reg == in_reg then
findings[#findings + 1] = {
atom = atom.name,
line = ev.line,
check = "gte_write_retire",
kind = "error",
msg = string.format("%s at line %d: recent %s at %s:%d has not retired (need %d slot(s); %s reads %s at slot %d)"
, atom.name, ev.line, pw.reg, pw.source, pw.line, pw.slots, ev.ident, in_reg, pw.slapsed or 0
),
}
break -- one finding per pending write per command
end
end
end
end
-- A command does NOT introduce a new pending CPU→C2 write
-- (the command writes its RESULT registers, which are not subject to the CPU-side retire window).
-- We leave `pending` as-is after the input-set check so the next event sees the post-retire state.
else
-- Plain CPU word / branch / GTE transfer read / nop2 half / etc.
pending = retire_writes(pending, 1)
end
end
-- (Surface expansion-cycle diagnostics as informational findings, not errors.)
local errors = atom.paths.word_event_errors or {}
for _, e in ipairs(errors) do
if e.kind == "cycle" then
findings[#findings + 1] = {
atom = atom.name,
line = line,
check = "gte_pipeline_fill",
kind = "error",
msg = string.format(
"%s at line %d needs %d nop word%s immediately BEFORE `gte_cmdw_%s`; only %d found",
atom.name, line, need, need == 1 and "" or "s", variant, have),
line = e.line,
check = "gte_write_retire",
kind = "info",
msg = string.format("%s at line %d: %s", atom.name, e.line, e.msg),
}
end
end
end
--- Per-atom: check every `gte_cmdw_*` for pipeline-fill compliance.
--- Uses the pre-computed `atom.paths.tok_class` — nop_prefix (forward-pass pre-compute)
--- replaces the old backward walk; ident replaces the per-token `tok:match` classification.
local function check_gte_pipeline_fill(atom, pipe_ctx, findings)
local tc = atom.paths.tok_class
local line_in_body = atom.paths.line_in_body
local tn = #atom.paths.tokens
for ti = 1, tn do
check_one_gte_cmdw(atom, tc[ti], ti, line_in_body, findings)
-- ─────────────────────────────────────────────────────────────────────────
-- Check #1b: COP2→GPR load delay (mfc2 / cfc2 → first GPR consumer).
--
-- Reads `atom.paths.word_events`. Every `gte_mv_from_data_r` / `gte_mv_from_ctrl_r` stages a destination GPR + 1 remaining slot.
-- A subsequent event that READS from that GPR (per the OPERAND_READ_POSITIONS table + operand-position rules)
-- within the same instruction slot emits a finding with `kind = "error"`.
--
-- Branch delay slots + BD-slot absorption are out of scope (separate MIPS control-flow concern).
-- ─────────────────────────────────────────────────────────────────────────
-- Return the textual ident of the GPR read at `pos` in the macro's argument list, or nil if the operand is not a GPR.
-- Operands that are numeric literals (e.g. `0`, `4`, `0xFFFF`) or type keywords (`U4`, `C2_VZ2`) are not GPR reads.
local function operand_gpr_at(ev, pos)
local op = ev.args and ev.args[pos] or nil
if not op then return nil end
if op:sub(1, 2) == "0x" or op:sub(1, 2) == "0X" then return nil end
if op:match("^%d") then return nil end -- numeric literal
if op == "true" or op == "false" then return nil end
-- Strip any trailing whitespace; the operator scanner already trims, but be defensive against raw args.
return op:match("^%s*(%S+)%s*$")
end
local function check_cop2_gpr_load_delay(atom, pipe_ctx, findings)
local events = atom.paths.word_events
if not events or #events == 0 then return end
local pending = {} -- { gpr = "R_T0", line = N, source = path, slots = 1 }
for _, ev in ipairs(events) do
if ev.ident == "gte_mv_from_data_r" or ev.ident == "gte_mv_from_ctrl_r" then
local dst = ev.args and ev.args[1] or nil
if dst then
pending[#pending + 1] = {
gpr = dst,
slots = 1,
source = ev.source,
line = ev.line,
}
end
-- The transfer itself counts as one slot (the destination GPR is updated after the next instruction), so the existing pending list advances.
for i = 1, #pending do pending[i].slots = pending[i].slots - 1 end
local next_pending = {}
for _, p in ipairs(pending) do
if p.slots > 0 then next_pending[#next_pending + 1] = p end
end
pending = next_pending
else
-- Resolve read positions for this emitting token.
local read_pos = duffle.OPERAND_READ_POSITIONS and duffle.OPERAND_READ_POSITIONS[ev.ident]
if read_pos then
for _, pw in ipairs(pending) do
for _, pos in ipairs(read_pos) do
local op = operand_gpr_at(ev, pos)
if op and op == pw.gpr then
findings[#findings + 1] = {
atom = atom.name,
line = ev.line,
check = "cop2_gpr_load_delay",
kind = "error",
msg = string.format("%s at line %d: %s reads %s but the load from %s at %s:%d has not retired (need 1 slot)"
, atom.name, ev.line, ev.ident, pw.gpr, ev.ident, pw.source, pw.line
),
}
break
end
end
end
end
-- Advance all pending writes by 1 for the slot this instruction occupies.
for i = 1, #pending do pending[i].slots = pending[i].slots - 1 end
local next_pending = {}
for _, p in ipairs(pending) do
if p.slots > 0 then next_pending[#next_pending + 1] = p end
end
pending = next_pending
end
end
end
@@ -308,8 +474,9 @@ end
--- Every atom body must contain exactly one `mac_yield()` call and it must be the LAST top-level token in the body
--- (so the tape runtime can pick up cleanly at the next atom's bound registers).
---
--- Empty bodies are not currently flagged — runtime infrastructure atoms like `MipsAtom_(yield) { mac_yield() }`
--- and `MipsAtom_(tape_exit) { jump_reg(rret_addr), nop }` are valid as-is; mac_yield at the end is the contract.
--- Empty bodies are not currently flagged — runtime infrastructure atoms like
--- `MipsAtom_(yield) { mac_yield() }` and `MipsAtom_(tape_exit) { jump_reg(rret_addr), nop }`
--- are valid as-is; mac_yield at the end is the contract.
--- Stage 2: signature uniformized to `(atom, pipe_ctx, findings)` — pipe_ctx is ignored here.
local function check_mac_yield_uniformity(atom, pipe_ctx, findings)
-- Per-kind semantics:
@@ -402,22 +569,22 @@ local function check_mac_yield_uniformity(atom, pipe_ctx, findings)
end
-- ════════════════════════════════════════════════════════════════════════════
-- Check #3: ABI handoff discipline
-- Check #3: Binding handoff discipline
-- ════════════════════════════════════════════════════════════════════════════
--- For every atom with `atom_bind(Binds_X)`, verify the atom body reads every field of `Binds_X` from R_TapePtr (in any order)
--- and advances R_TapePtr by S_(Binds_X) at the end. Mismatches are errors.
---
--- This is the "job boundary sanity check": Binds_X is the atom's input payload (like a C function's argument struct).
--- The body must read each input field and advance the input cursor past the payload.
--- The order of reads doesn't matter — each field is at a different offset in the struct, and the advance at the end is what keeps the tape pointer in sync.
--- Binds_X is the atom phase's input payload (like a C function's argument struct).
--- The body must read each input field and advance the input cursor past the payload. The order of reads doesn't matter.
--- Each field is at a different offset in the struct, and the advance at the end is what keeps the tape pointer in sync.
---
--- Rules:
--- 1. Body MUST contain one `load_word(R_*, R_TapePtr, O_(Binds_X, field))` per field of Binds_X. Missing field = error.
--- 2. Body MUST contain an `add_ui_self(R_TapePtr, S_(Binds_X))` (or equivalent advance by the struct's byte count). Missing = error.
--- 3. atom_bind(Binds_X) where Binds_X doesn't exist = error.
--- Per-atom: verify the atom body reads every field of its `Binds_X` from R_TapePtr and advances R_TapePtr by S_(Binds_X).
--- Signature changed in Stage 1B: takes `(atom, pipe_ctx, findings)` where `pipe_ctx` carries the cross-atom
--- Per-atom: Verify the atom body reads every field of its `Binds_X` from R_TapePtr and advances R_TapePtr by S_(Binds_X).
--- Signature changed in Stage 1B: Takes `(atom, pipe_ctx, findings)` where `pipe_ctx` carries the cross-atom
--- `info_by_atom` + `binds_index` tables (built once by validate() before the per-atom loop).
--- Per-atom iteration now lives in validate(); this is a per-atom predicate.
local function check_abi_handoff(atom, pipe_ctx, findings)
@@ -575,10 +742,8 @@ end
--- cycles_min - shortest path through the body (sum of token costs)
--- cycles_max - longest path through the body
--- branches - number of branches in the body
--- paths - number of distinct paths reached (terminated at
--- mac_yield or end-of-body)
--- has_loops - true iff a path re-entered a token it had visited
--- (warning; loop bodies aren't supported)
--- paths - number of distinct paths reached (terminated at mac_yield or end-of-body)
--- has_loops - true iff a path re-entered a token it had visited (warning; loop bodies aren't supported)
--- unknown_macros - list of unique macro names not in duffle.INSTRUCTION_LATENCY
local function analyze_atom_paths(atom)
local tokens = atom.paths.tokens or duffle.tokenize_body(atom.body)
@@ -753,7 +918,7 @@ end
-- Severity: WARNING (build continues).
-- The rule is intentionally permissive because the production `code/duffle/` and `code/gte_hello/`
-- sources use R_* aliases in atom_reads / atom_writes that may not yet be opted in via the
-- bare `atom_reg` marker. R_TapePtr / R_AtomJmp / R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase ARE opted in (lottes_tape.h Task 21).
-- bare `atom_reg` marker. R_TapePtr / R_AtomJmp / R_PrimCursor / R_FaceCursor / R_VertBase / R_OtBase ARE opted in.
-- Raw C-ABI aliases like R_T0..R_T3 are intentionally NOT auto-included (per the prototype principle:
-- no auto-include of wave-context; explicit opt-in only). Warnings keep the build green
-- and surface the migration gap so users see which atoms still need opt-in registration.
@@ -761,7 +926,7 @@ local function check_enum_alias_membership(_src, pipe_ctx, findings)
local reg_registry = pipe_ctx.register_alias_registry or {}
-- (a) atom_dbg_reg_default(R_X, T) -- pipe_ctx.types.
-- source_line is on every entry; emit the diagnostic against the default declaration's own line so the report's
-- source_line is on every entry; emit the diagnostic against the default declaration's own line so the report's
-- "Findings by atom" section can attribute the failure to the marker location.
for reg, def in pairs(pipe_ctx.types or {}) do
if not reg_registry[reg] then
@@ -996,14 +1161,15 @@ end
-- This is the plex pattern: the iteration is in ONE place (validate), the variation is in DATA (this table).
local CHECK_RULES = {
{ name = "gte_pipeline_fill", per_atom = check_gte_pipeline_fill },
{ name = "mac_yield_uniformity", per_atom = check_mac_yield_uniformity },
{ name = "abi_handoff", per_atom = check_abi_handoff },
{ name = "gpu_portstore_shape", per_atom = check_gpu_portstore_shape },
{ name = "per_atom_cycle_budget", per_atom = check_per_atom_cycle_budget },
{ name = "enum_alias_membership", per_source = check_enum_alias_membership },
{ name = "atom_type_consistency", per_source = check_atom_type_consistency },
{ name = "binds_no_substruct_deref", per_source = check_binds_no_substruct_deref },
{ name = "gte_write_retire", per_atom = check_gte_write_retire },
{ name = "cop2_gpr_load_delay", per_atom = check_cop2_gpr_load_delay },
{ name = "mac_yield_uniformity", per_atom = check_mac_yield_uniformity },
{ name = "abi_handoff", per_atom = check_abi_handoff },
{ name = "gpu_portstore_shape", per_atom = check_gpu_portstore_shape },
{ name = "per_atom_cycle_budget", per_atom = check_per_atom_cycle_budget },
{ name = "enum_alias_membership", per_source = check_enum_alias_membership },
{ name = "atom_type_consistency", per_source = check_atom_type_consistency },
{ name = "binds_no_substruct_deref", per_source = check_binds_no_substruct_deref },
{ name = "reads_writes_alias_membership",per_source = check_reads_writes_alias_membership},
}
@@ -1048,13 +1214,17 @@ local function validate(ctx, src)
atoms = atoms,
types = scan.types or {},
atom_infos_list = atom_infos or {},
register_alias_registry = scan.register_alias_registry or {},
register_alias_registry = scan.register_alias_registry or {},
type_name_registry = scan.type_name_registry or {},
}
-- Shared cross-source component-body index (built once per pass via duffle's memoizing helper).
-- `atom.paths.word_events` + `atom.paths.word_event_errors` are populated below and consumed by
-- the per-atom checks (`check_gte_write_retire`, `check_cop2_gpr_load_delay`).
pipe_ctx.component_body_index = duffle.get_component_body_index(ctx)
-- THE per-atom pipeline. ONE iteration of atoms; the 5 check_* functions + analyze_atom_paths
-- all run here, sharing a single tokenize_body + build_body_line_index per body.
-- Plex move: every piece of state derived from an atom body lives on `atom.paths` (the per-atom mega-struct);
-- Every piece of state derived from an atom body lives on `atom.paths` (the per-atom mega-struct);
-- readers (analyze_atom_paths, the 5 checks, the renderers) all consume `atom.paths`, not the raw `atoms` list.
-- Stage 1B: each check_* now takes `(atom, ...)` instead of `(atoms, findings)` — no more single-atom `{a}` shim.
-- Per-source rules run once after this loop completes (no parallel dispatch table).
@@ -1065,11 +1235,24 @@ local function validate(ctx, src)
a.paths.line_in_body = duffle.build_body_line_index(a.body)
a.paths.tok_class = classify_tokens(a.paths.tokens)
-- Precompute the semantic emitted-word event stream for this atom. The per-atom checks
-- (`check_gte_write_retire`, `check_cop2_gpr_load_delay`) read these to retire slots on the
-- actual emitted machine words (including `mac_X(...)`-expanded words from nested components).
local body_entry = {
body_tokens = a.body_tokens,
body_off = a.body_off,
line_of = src.scan.line_of,
source = src.path,
declaration = a.line,
}
a.paths.word_events, a.paths.word_event_errors =
duffle.expand_word_events(body_entry, pipe_ctx.component_body_index, ctx.shared.word_counts or {})
-- analyze_atom_paths fills the *cycles / branches / has_loops / unknown_macros* fields of a.paths.
analyze_atom_paths(a)
-- Run all per-atom checks on this one atom via the CHECK_RULES data table (Muratori: data over control flow).
-- Adding a new check = 1 row in CHECK_RULES; this loop never needs editing.
-- Adding a new check = 1 row in CHECK_RULES; this loop never needs editing.
for _, rule in ipairs(CHECK_RULES) do
if rule.per_atom then rule.per_atom(a, pipe_ctx, findings) end
end