// a mapping from [`Var`] to current SSA value. When control flow merges,

// block parameters are inserted to merge values from different control flow paths.

/// A variable handle. Represents a source-level variable during lowering.

/// The same [`Var`] can have different SSA values in different blocks.

/// Metadata for a source-level variable, stored once per function.

///

/// Each variable declaration in the source creates one [`VarData`] entry in the

/// function's `variables` array, indexed by `id`. This contains static

// instructions until terminated by a jump, branch, return, or unreachable.

// Blocks can be created before they're filled (forward references for jumps).

/// A handle to a basic block within the current function.

/// Block handles are stable, they don't change as more blocks are added.

/// Internal block state during construction.

///

/// The key invariants:

///

/// The latter is necessary because recursive SSA resolution may have already

/// patched terminator arguments with the provisional value before it was

/// found to be trivial.

fn rewriteCachedVarValue(self: *mut FnLowerer, v: Var, from: il::Val, to: il::Val) {

    for i in 0..self.blockData.len {

        }

        if blk.instrs.len > 0 {

            let ix = blk.instrs.len - 1;

            match &mut blk.instrs[ix] {

                case il::Instr::Jmp { args, .. } =>

/// The block is initially unsealed (predecessors may be added later) and empty.

/// Returns a [`BlockId`] that can be used for jumps and branches. The block must

/// be switched to via [`switchToBlock`] before instructions can be emitted.

fn createBlock(self: *mut FnLowerer, labelBase: *[u8]) -> BlockId throws (LowerError) {

    let label = try nextLabel(self, labelBase);

    let varCount = self.fnType.localCount;

    let vars = try! alloc::allocSlice(self.low.arena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *mut [?il::Val];

    for i in 0..varCount {

        vars[i] = nil;

    };

    blk.sealState = Sealed::Yes;

    // Complete all incomplete block parameters.

    for varId in incompleteVars {

    }

}

/// Seal a block and switch to it.

fn switchToAndSeal(self: *mut FnLowerer, block: BlockId) throws (LowerError) {

    switchToBlock(self, block);

}

/// Get block data by block id.

fn getBlock(self: *FnLowerer, block: BlockId) -> *BlockData {

}

/// Get mutable block data by block id.

fn getBlockMut(self: *mut FnLowerer, block: BlockId) -> *mut BlockData {

}

/// Get the current block being built.

fn currentBlock(self: *FnLowerer) -> BlockId {

    let block = self.currentBlock else {

    block.instrs.append(instr, self.allocator);

}

/// Emit an unconditional jump to `target`.

fn emitJmp(self: *mut FnLowerer, target: BlockId) throws (LowerError) {

    addPredecessor(self, target, currentBlock(self));

}

/// Emit an unconditional jump to `target` with a single argument.

fn emitJmpWithArg(self: *mut FnLowerer, target: BlockId, arg: il::Val) throws (LowerError) {

    let args = try allocVal(self, arg);

    addPredecessor(self, target, currentBlock(self));

}

/// Emit an unconditional jump to `target` and switch to it.

fn switchAndJumpTo(self: *mut FnLowerer, target: BlockId) throws (LowerError) {

    emit(self, il::Instr::Br {

        op: il::CmpOp::Ne,

        typ: il::Type::W32,

        a: il::Val::Reg(cond),

        b: il::Val::Imm(0),

        thenArgs: &mut [],

        elseArgs: &mut [],

    });

    addPredecessor(self, thenBlock, currentBlock(self));

    addPredecessor(self, elseBlock, currentBlock(self));

}

    elseBlock: BlockId

) throws (LowerError) {

    assert thenBlock != elseBlock;

    emit(self, il::Instr::Br {

        op, typ, a, b,

    });

    addPredecessor(self, thenBlock, currentBlock(self));

    addPredecessor(self, elseBlock, currentBlock(self));

}

fn addPredecessor(self: *mut FnLowerer, target: BlockId, pred: BlockId) {

    let blk = getBlockMut(self, target);

    assert blk.sealState != Sealed::Yes, "addPredecessor: adding predecessor to sealed block";

    let preds = &mut blk.preds;

    for i in 0..preds.len {

            return;

        }

    }

}

/// Finalize all blocks and return the block array.

fn finalizeBlocks(self: *mut FnLowerer) -> *[il::Block] throws (LowerError) {

    let blocks = try! alloc::allocSlice(

    val: il::Val

) -> Var {

    let id = self.vars.len;

    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);

    if self.currentBlock != nil {

        defVar(self, v, val);

    }

    return v;

}

/// Define (write) a variable. Record the SSA value of a variable in the

/// current block. Called when a variable is assigned or initialized (`let`

/// bindings, assignments, loop updates). When [`useVar`] is later called,

/// it will retrieve this value.

fn defVar(self: *mut FnLowerer, v: Var, val: il::Val) {

}

/// Use (read) the current value of a variable in the current block.

/// May insert block parameters if the value must come from predecessors.

fn useVar(self: *mut FnLowerer, v: Var) -> il::Val throws (LowerError) {

/// Given a variable and a block where it's used, this function finds the

/// correct [`il::Val`] that holds the variable's value at that program point.

/// When control flow merges from multiple predecessors with different

/// definitions, it creates a block parameter to unify them.

fn useVarInBlock(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {

    let blk = getBlockMut(self, block);

        return val;

    }

    // Entry block cannot have block parameters. If variable isn't defined

    // in entry, we return undefined.

    if block == self.entryBlock {

            throw LowerError::InvalidUse;

        }

        // Single predecessor means no merge needed, variable is implicitly

        // available without a block parameter.

        if blk.preds.len == 1 {

                let val = try useVarInBlock(self, pred, v);

                return val;

            }

        }

    }

    // Multiple predecessors or unsealed block: need a block parameter to merge

    while id > 0 {

        id -= 1;

        if let varName = self.vars[id].name {

            // Names are interned strings, so pointer comparison suffices.

            if varName == name {

            }

        }

    }

    return nil;

}

    self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);

}

/// Get the metadata for a variable.

fn getVar(self: *FnLowerer, v: Var) -> *VarData {

}

/// Create a block parameter to merge a variable's value from multiple

/// control flow paths.

///

    // Create block parameter and add it to the block.

    let param = il::Param { value: reg, type };

    let blk = getBlockMut(self, block);

    blk.params.append(param, self.allocator);

    // Record that this variable's value in this block is now the parameter register.

    // This must happen before the predecessor loop to handle self-referential loops.

    match &mut blk.sealState {

        case Sealed::No { incompleteVars } => {

            // Block unsealed: defer until sealing.

        },

        case Sealed::Yes => {

            // Block sealed: check for trivial phi before committing. If all

            // predecessors provide the same value, we can remove the param we

            // just created and use that value directly.

            if let trivial = try getTrivialPhiVal(self, block, v) {

                let provisional = il::Val::Reg(reg);

                removeLastBlockParam(self, block);

                rewriteCachedVarValue(self, v, provisional, trivial);

                return trivial;

            }

            // Non-trivial phi: patch predecessors to pass their values.

            try resolveBlockArgs(self, block, v);

        },

    // Find the parameter index corresponding to this variable.

    // Each variable that needs merging gets its own block parameter slot.

    let mut paramIdx: u32 = 0;

    for i in 0..blk.paramVars.len {

            paramIdx = i;

            break;

        }

    }

    // For each predecessor, recursively look up the variable's reaching definition

    // in that block, then patch the predecessor's terminator to pass that value

    // as an argument to this block's parameter.

    for predId in blk.preds {

        // This may recursively trigger more block arg resolution if the

        // predecessor also needs to look up the variable from its predecessors.

        let val = try useVarInBlock(self, pred, v);

        assert val != il::Val::Undef, "createBlockParam: predecessor provides undef value for block parameter";

    }

}

/// Check if a block parameter is trivial, i.e. all predecessors provide

/// the same value. Returns the trivial value if so.

fn getTrivialPhiVal(self: *mut FnLowerer, block: BlockId, v: Var) -> ?il::Val throws (LowerError) {

    let blk = getBlock(self, block);

    // Get the block parameter register.

    // Check if all predecessors provide the same value.

    let mut sameVal: ?il::Val = nil;

    for predId in blk.preds {

        let val = try useVarInBlock(self, pred, v);

        // Check if this is a self-reference.

        // This happens in cycles where the loop back-edge passes the phi to

        // itself. We skip self-references when checking for trivial phis.

                    let cv = resolver::constValueEntry(self.low.resolver, pat)

                        else throw LowerError::MissingConst(pat);

                    cases.append(il::SwitchCase {

                        value: constToScalar(cv),

                        args: &mut []

                    }, self.allocator);

                }

            }

        }

        addPredecessor(self, blocks[i], entry);

    }

    emit(self, il::Instr::Switch {

        val: subject.val,

        defaultArgs: &mut [],

        cases: &mut cases[..]

    });

    for p, i in prongs {

        }

        // Evaluate guard if present; can still fail to next arm.

        if let g = prong.guard {

            try emitCondBranch(self, g, bodyBlock, nextArm);

            // Nested tests changed the current block. Create a new body block

            // after the nest blocks to maintain RPO ordering, and jump to it.

            bodyBlock = try createBlock(self, bodyLabel);

            try emitJmp(self, bodyBlock);

        }

    }

    // Handle guard: on success jump to `successBlock`, on failure jump to `failBlock`.

    if let g = pat.guard {

        try emitCondBranch(self, g, *successBlock, failBlock);

        try switchToAndSeal(self, *successBlock);

        // Nested tests changed the current block. Create a new success block

        // after the nest blocks to maintain RPO ordering, and jump to it.

        *successBlock = try createBlock(self, successLabel);

        try emitJmp(self, *successBlock);

    let trueArgs = try allocVal(self, il::Val::Imm(1));

    // Check if tags differ.

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

    });

    addPredecessor(self, nilCheck, currentBlock(self));

    addPredecessor(self, mergeBlock, currentBlock(self));

    // Check if both are `nil`.

    try switchToAndSeal(self, nilCheck);

    emit(self, il::Instr::Br {

        op: il::CmpOp::Ne, typ: il::Type::W8, a: tagA, b: il::Val::Imm(0),

    });

    addPredecessor(self, payloadCmp, currentBlock(self));

    addPredecessor(self, mergeBlock, currentBlock(self));

    // Both are non-`nil`, compare payloads.

    assert tagBlock != mergeBlock;

    // TODO: Use the helper once the compiler supports more than eight function params.

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

    });

    addPredecessor(self, tagBlock, currentBlock(self));

    addPredecessor(self, mergeBlock, currentBlock(self));

    // Create comparison blocks for each non-void variant and build switch cases.

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;

    for variant, i in unionInfo.variants {

        if variant.valueType == resolver::Type::Void {

            cases[i] = il::SwitchCase {

                value: i as i64,

                args: trueArgs

            };

            caseBlocks[i] = nil;

        } else {

            let payloadBlock = try createBlock(self, "eq#payload");

            cases[i] = il::SwitchCase {

                value: i as i64,

                args: &mut []

            };

            caseBlocks[i] = payloadBlock;

        }

    }

    // Emit switch in @tag block. Default arm is unreachable since we cover all variants.

    let unreachableBlock = try createBlock(self, "eq#unreachable");

    try switchToAndSeal(self, tagBlock);

    emit(self, il::Instr::Switch {

        val: tagA,

        defaultArgs: &mut [],

        cases

    });

    // Add predecessor edges for switch targets.

            if isAggregateType(typ) {

                return val;

            }

            // For scalars, if we've already materialized a stack slot for this

            // variable, the SSA value is that slot pointer.

                // Already address-taken; return existing stack pointer.

                return val;

            }

            // Materialize a stack slot using the declaration's resolved

            // layout so `align(N)` on locals is honored.

            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);

            let slot = emitReserveLayout(self, layout);

            try emitStore(self, slot, 0, typ, val);

            let stackVal = il::Val::Reg(slot);

            defVar(self, v, stackVal);

            return stackVal;

        }

        // Fall back to symbol lookup for constants/statics.

                let layout = resolver::getLayout(self.low.resolver, node, typ);

                let slot = emitReserveLayout(self, layout);

                try emitStore(self, slot, 0, typ, varVal);

                let v = newVar(self, name, ilType, l.mutable, il::Val::Reg(slot));

                return;

            }

        }

    }

            let errTy = try typeOf(self, typeNode);

            errTypes[i] = errTy;

            cases.append(il::SwitchCase {

                value: getOrAssignErrorTag(self.low, errTy) as i64,

                args: &mut []

            }, self.allocator);

        } else {

            errTypes[i] = nil;

            defaultIdx = i;

        defaultTarget = try createBlock(self, "unreachable");

        addPredecessor(self, defaultTarget, entry);

    }

    emit(self, il::Instr::Switch {

        val: il::Val::Reg(tagReg),

        defaultArgs: &mut [],

        cases

    });

    // Second pass: emit each catch clause body.

        case ast::NodeValue::Ident(_) => {

            // First try local variable lookup.

            // Otherwise fall back to global symbol lookup.

            if let v = lookupLocalVar(self, node) {

                val = try useVar(self, v);

                    let typ = try typeOf(self, node);

                    let ptr = emitValToReg(self, val);

                    val = emitRead(self, ptr, 0, typ);

                }

            } else {

//! Unix-specific system calls and utilities.

use std::intrinsics;

/// File access modes.

/// Open file for reading only.

/// Open file for writing only.

/// Open file for reading and writing.

/// Create file if it doesn't exist.

/// Truncate file to zero length.

/// Standard file descriptor for stdin.

pub const STDIN: i64 = 0;

/// Standard file descriptor for stdout.

const AT_FDCWD: i64 = -100;

/// Opens a file at the given path and returns a file descriptor.

/// Returns a negative value on error.

pub fn open(path: *[u8], flags: OpenFlags) -> i64 {

}

/// Opens a file at the given path with mode, returns a file descriptor.

pub fn openOpts(path: *[u8], flags: OpenFlags, mode: i64) -> i64 {

}

/// Reads from a file descriptor into the provided buffer.

/// Returns the number of bytes read, or a negative value on error.

pub fn read(fd: i64, buf: *mut [u8]) -> i64 {

/// Writes the entire contents of a buffer to a file at the given path.

/// Creates the file if it doesn't exist, truncates if it does.

/// Returns `true` on success.

pub fn writeFile(path: *[u8], data: *[u8]) -> bool {

    let fd = openOpts(path, flags, 420); // 0644 in octal.

    if fd < 0 {

        return false;

    }

    let mut written: u32 = 0;