Emit one half of a 2x-unrolled forward body loop iteration. word0_reg: register holding the carry word from previous iteration load_reg:

Emit a binary tree dispatch for shift amounts in [lo, hi]. Uses binary search on reg (R22). R22 is consumed (dead after dispatch). prefix

Generate wrappers with sret support using REGISTER-BASED calling convention (new ABI).

Fused combine: dest = (word0 >> shift) | (word1 << (32-shift)) Single unified lattice approach: directly extracts all 32 result bits from

Generate Biased Non-Restoring Lattice code to: 1. Extract T3 into T4 (Result), SKIPPING bits in the target halfword range. 2. Add shifted

Emit the lattice core for shifting R21 into result_reg (default T2). Assumes Bit 31 handled/cleared. Assumes R21 biased by +1. prefix:

Generate all memory operation functions.

Generate __subleq_mul: R3 = R3 * R4 (signed multiplication) - O(32) single-phase.

Generate __subleq_sdivrem: R21 = R21 / R22, R22 = R21 % R22 (signed). Register usage: - R21 = dividend (input), then quotient (output)

Generate __subleq_sdivrem64: 64-bit signed division with remainder. This does the division INLINE (like emit_sdivrem_o32.py), not by calling

Generate __ashldi3, __lshrdi3, __ashrdi3 shift functions.

Generate __subleq_shl: R3 = R3 << R4 (left shift). Algorithm: Unrolled Linear Dispatch. 1. Check shift amount (R4). If <= 0, copy R21

Emit code to store T5 (lo) and T6 (hi) to *T9 using indirect addressing.

Store val_reg to m[ptr_reg] using indirect addressing (no SMC).

Generate __subleq_udivrem: R21 = R21 / R22, R22 = R21 % R22 (unsigned). Register usage: - R21 = dividend (input), then quotient (output)

Generate __subleq_udivrem64: 64-bit unsigned division with remainder. Matches emit_udivrem_o32.py per-bit structure: 1. Double remainder

getSector() Will return a sector_t given the number of the current sector, the line number and the side (0/1) that you want.

* Get the RTTI name of a type_info object's own class. * This comes from vptr[-1], which points to the type_info's own type_info. */

Read encoded pointer */

Read signed LEB128 value */

twoSided() Given the sector number and the line number, it will tell you whether the line is two-sided or not.

32x32 --> 64 bit multiply

should be called at the start of every level right now, i figure it out myself

Handle events (user inputs) in automap mode

Updates on Game Tick

adds a marker at the current location

Zooming

Clear automap frame buffer.

Automap clipping of lines. Based on Cohen-Sutherland clipping algorithm but with a slightly faster reject and precalculated slopes. If the speed is

Classic Bresenham w/ whatever optimizations needed for speed

Draws flat (floor/ceiling tile) aligned grid lines.

Determines visible lines, draws them. This is LineDef based, not LineSeg based.

Determines bounding box of all vertices, sets global variables controlling zoom range.

set the window scale to the minimum size

A_ReFire The player can re-fire the weapon without lowering it entirely.

BindToLocalPort

D_ArbitrateNetStart

D_DoomMain

D_PageDrawer

D_PageTicker Handles timing for warped projection

D_PostEvent Called by the I/O functions when input is detected

Special Stuff that can not be categorized

Start strobing lights (usually from a trigger)

TURN LINE'S TAG LIGHTS OFF

EV_VerticalDoor : open a door manually, no tag value

F_BunnyScroll

F_CastTicker

F_Drawer

F_Ticker

Find a Response File

G_DoReborn

G_PlayerFinishLevel Can when a player completes a level.

G_RecordDemo

G_Responder Get info needed to make ticcmd_ts for the players.

G_SaveGame Called by the menu task. Description is a 24 byte text string