}

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

}

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

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

}

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

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

}

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

    try emitJmp(self, target);

    switchToBlock(self, target);

}

/// Emit a conditional branch based on `cond`.

    assert thenBlock <> elseBlock;

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

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

}

/// Emit a compare-and-branch instruction with the given comparison op.

    self: &mut FnLowerer 'arena 'phase 'function,

    op: il::CmpOp,

    typ: il::Type,

    a: il::Val,

    b: il::Val,

    thenBlock: BlockId,

    elseBlock: BlockId

) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    assert thenBlock <> elseBlock;

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

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

}

/// Emit a guard that traps with `ebreak` when a comparison is false.

    self: &mut FnLowerer 'arena 'phase 'function,

    op: il::CmpOp,

    typ: il::Type,

    a: il::Val,

    b: il::Val

    }

    return aa <= bb;

}

/// Emit an `ebreak` when `a < b` holds.

    self: &mut FnLowerer 'arena 'phase 'function,

    typ: il::Type,

    a: il::Val,

    b: il::Val

) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

/// Emit a match binding pattern.

/// Binding patterns always match for regular values, but for optionals they

/// check for the presence of a value. Jumps to `valuePresent` on success,

/// `valueAbsent` on failure.

    self: &mut FnLowerer 'arena 'phase 'function,

    subject: &MatchSubject,

    valuePresent: BlockId,

    valueAbsent: BlockId

) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

        }

    }

}

/// Emit a jump to target if the current block hasn't terminated, then seal the target block.

    if not blockHasTerminator(&self.blockData[*currentBlock(self)].instrs[..]) {

        try emitJmp(self, target);

    }

    try sealBlock(self, target);

}

///         return 0;   // @else diverges, no jump to merge.

///     }

///

/// In the above example, the merge block stays `nil`, and no code is generated

/// after the `if`. The merge block is created on first use.

    if not blockHasTerminator(&self.blockData[*currentBlock(self)].instrs[..]) {

        if *mergeBlock == nil {

            set *mergeBlock = try createBlock(self, "merge");

        }

        let target = *mergeBlock else { throw LowerError::MissingTarget; };

    try switchToAndSeal(self, endBlock);

    exitLoop(self);

}

/// Emit an increment of a variable by `1`.

    let cur = try useVar(self, v);

    let next = nextReg(self);

    emit(self, il::Instr::BinOp { op: il::BinOp::Add, typ, dst: next, a: cur, b: il::Val::Imm(1) });

    defVar(self, v, il::Val::Reg(next));

    }

    exitVarScope(&mut self.vars, savedVarsLen);

}

/// Lower a break statement.

    let ctx = currentLoop(self) else {

        throw LowerError::OutsideOfLoop;

    };

    try emitJmp(self, ctx.breakTarget);

}

/// Lower a continue statement.

    let block = try getOrCreateContinueBlock(self);

    try emitJmp(self, block);

}

/// Emit a return, blitting into the caller's return buffer if needed.

/// Emit a byte-copy loop: `for i in 0..size { dst[i] = src[i]; }`.

///

/// Used when `blit` cannot be used because the copy size is dynamic.

/// Terminates the current block and leaves the builder positioned

/// after the loop.

    self: &mut FnLowerer 'arena 'phase 'function,

    dst: il::Reg,

    src: il::Reg,

    size: il::Val,

    label: *[u8]