// Emission Helpers  //

///////////////////////

/// Emit a single instruction.

pub fn emit(e: *mut Emitter, instr: u32) {

    e.code[e.codeLen] = instr;

    e.codeLen += 1;

}

/// Compute branch offset to a function by name.

    dict::insert(&mut e.labels.funcs, name, e.codeLen as i32 * super::INSTR_SIZE);

}

/// Record a function's start position for printing.

pub fn recordFunc(e: *mut Emitter, name: *[u8]) {

    e.funcs[e.funcsLen] = types::FuncAddr { name, index: e.codeLen };

    e.funcsLen += 1;

}

/// Record a local branch needing later patching.

/// Unconditional jumps use a single slot (J-type, +-1MB range).

/// Conditional branches use two slots (B-type has only +-4KB range,

/// so large functions may need the inverted-branch + JAL fallback).

pub fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {

    e.pendingBranches[e.pendingBranchesLen] = PendingBranch {

        index: e.codeLen,

        target: targetBlock,

        kind: kind,

    };

/// Record a function call needing later patching.

/// Emits placeholder instructions that will be patched later.

/// Uses two slots to support long-distance calls.

pub fn recordCall(e: *mut Emitter, target: *[u8]) {

    e.pendingCalls[e.pendingCallsLen] = PendingCall {

        index: e.codeLen,

        target,

    };

    e.pendingCallsLen += 1;

/// Record a function address load needing later patching.

/// Emits placeholder instructions that will be patched to load the function's address.

/// Uses two slots to compute long-distance addresses.

pub fn recordAddrLoad(e: *mut Emitter, target: *[u8], rd: super::Reg) {

    e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {

        index: e.codeLen,

        target,

        rd: rd,

    };

                    patch(e, p.index + 1, encode::jal(super::ZERO, adj));

                }

            },

            case BranchKind::Jump => {

                // Single-slot jump (J-type, +-1MB range).

                patch(e, p.index, encode::jal(super::ZERO, offset));

            },

        }

    }

    e.pendingBranchesLen = 0;

        let prev = &e.debugEntries[e.debugEntriesLen - 1];

        if prev.offset == loc.offset and prev.moduleId == loc.moduleId {

            return;

        }

    }

    e.debugEntries[e.debugEntriesLen] = types::DebugEntry {

        pc,

        moduleId: loc.moduleId,

        offset: loc.offset,

    };

                and regalloc::spill::isSpilled(&s.ralloc.spill, src);

            // When both are spilled, offsets must fit 12-bit immediates

            // since we can't advance base registers (they live in spill

            // slots, not real registers we can mutate).

            // Resolve dst/src base registers.

            let mut rdst = super::SCRATCH2;

            let mut rsrc = super::SCRATCH1;

            let mut srcReload: ?i32 = nil;

            if let case il::Val::Reg(r) = func {

                let target = getSrcReg(s, r, super::SCRATCH2);

                emitMv(s, super::SCRATCH2, target);

            }

            // Move arguments to A0-A7 using parallel move resolution.

            emitParallelMoves(s, &super::ARG_REGS[..], args);

            // Emit call.

            match func {

                case il::Val::FnAddr(name) => {

fn emitParallelMoves(s: *mut Selector, dsts: *[super::Reg], args: *[il::Val]) {

    let n: u32 = args.len;

    if n == 0 {

        return;

    }

    // Source registers for each arg.

    let mut srcRegs: [super::Reg; MAX_BLOCK_ARGS] = [super::ZERO; MAX_BLOCK_ARGS];

    // If this is a register-to-register move.

    let mut isRegMove: [bool; MAX_BLOCK_ARGS] = [false; MAX_BLOCK_ARGS];

    // If this move still needs to be executed.

fn emitBlockArgs(s: *mut Selector, func: *il::Fn, target: u32, args: *mut [il::Val]) {

    if args.len == 0 {

        return;

    }

    let block = &func.blocks[target];

    // Destination registers for each arg.

    // Zero means the destination is spilled or skipped.

    let mut dsts: [super::Reg; MAX_BLOCK_ARGS] = [super::ZERO; MAX_BLOCK_ARGS];

    let mut idx = hash(key) & mask;

    loop {

        let entry = m.entries[idx];

        if entry.key.len == 0 {

            m.entries[idx] = Entry { key, value };

            m.count += 1;

            return;

        }

        if mem::eq(entry.key, key) {

    for i in 0..program.data.len {

        let data = &program.data[i];

        if data.readOnly == readOnly and not data.isUndefined {

            offset = mem::alignUp(offset, data.alignment);

            for j in 0..data.values.len {

                let v = &data.values[j];

                for _ in 0..v.count {

                    match v.item {

                        case il::DataItem::Val { typ, val } => {

    l.blockCount = 0;

}

/// Record a block's code offset by its index. O(1).

pub fn recordBlock(l: *mut Labels, blockIdx: u32, offset: i32) {

    l.blockOffsets[blockIdx] = offset;

    l.blockCount += 1;

}

/// Look up a block's byte offset by index. O(1).

pub fn blockOffset(l: *Labels, blockIdx: u32) -> i32 {

    return l.blockOffsets[blockIdx];

}

/// Look up a function's byte offset by name.

pub fn funcOffset(l: *Labels, name: *[u8]) -> i32 {

    return nil;

}

/// Add a mapping to the register map.

fn rmapSet(rmap: *mut RegMap, virtReg: u32, physReg: u8) {

    rmap.virtRegs[rmap.n] = virtReg;

    rmap.physRegs[rmap.n] = physReg;

    rmap.n += 1;

}

        if let phys = rmapFind(ctx.current, reg.n) {

            bitset::clear(ctx.usedRegs, phys as u32);

            rmapRemove(ctx.current, reg.n);

        }

    }

    if spill::isSpilled(ctx.spillInfo, reg) {

        return; // Spilled values don't get physical registers.

    }

    if ctx.assignments[reg.n] == nil {

        ctx.assignments[reg.n] = rallocReg(

            if let dst = il::instrDst(block.instrs[i]) {

                maxReg = maxRegNum(dst.n, maxReg);

            }

        }

    }

    // Allocate per-block bitsets.

    let liveIn = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let liveOut = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let defs = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let uses = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

/// Collect all values from a bitset into a candidates buffer with their costs.

fn collectCandidates(set: *bitset::Bitset, costs: *[SpillCost]) -> Candidates {

    let mut c = Candidates { entries: undefined, n: 0 };

    let mut it = bitset::iter(set);

    while let reg = bitset::iterNext(&mut it) {

        if reg < costs.len {

            c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };

            c.n += 1;

        }

    }

}

/// Callback for [`il::forEachReg`]: increments use count for register.

fn countRegUseCallback(reg: il::Reg, ctxPtr: *mut opaque) {

    let ctx = ctxPtr as *mut CountCtx;

    ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;

}

/// Callback for [`il::forEachReg`]: adds register to live set.

fn addRegToSetCallback(reg: il::Reg, ctx: *mut opaque) {

/// Add a predecessor edge from `pred` to `target`.

/// Must be called before the target block is sealed. Duplicates are ignored.

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

    let blk = getBlockMut(self, target);

    let preds = &mut blk.preds;

    for i in 0..preds.len {

        if preds[i] == pred.n { // Avoid duplicate predecessor entries.

            return;

        }

/////////////////////

/// Enter a loop context for break/continue handling.

/// `continueBlock` is `nil` when the continue target is created lazily.

fn enterLoop(self: *mut FnLowerer, breakBlock: BlockId, continueBlock: ?BlockId) {

    let slot = &mut self.loopStack[self.loopDepth];

    slot.breakTarget = breakBlock;

    slot.continueTarget = continueBlock;

    self.loopDepth += 1;

}

/// Exit the current loop context.

fn exitLoop(self: *mut FnLowerer) {

    self.loopDepth -= 1;

}

/// Get the current loop context.

fn currentLoop(self: *mut FnLowerer) -> ?*mut LoopCtx {

///

/// This function creates a fresh register `%1` as a block parameter, then patches

/// each predecessor's jump to pass its value of `x` as an argument.

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

    // Entry block must not have block parameters.

    // Allocate a register to hold the merged value.

    let reg = nextReg(self);

    let type = getVar(self, v).type;

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

    for predId in blk.preds {

        let pred = BlockId { n: predId };

        // 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);

        patchTerminatorArg(self, pred, block.n, paramIdx, val);

    }

}

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

    // Check for an existing scope for this node, and don't allocate a new

    // one in that case.

    if let scope = scopeFor(self, owner) {

        return scope;

    }

    let p = try! alloc::alloc(&mut self.arena, @sizeOf(Scope), @alignOf(Scope));

    let entry = p as *mut Scope;

    // Allocate symbols from the arena.

    let ptr = try! alloc::allocSlice(&mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), capacity);

/// Visit the body of a loop while tracking nesting depth.

fn visitLoop(self: *mut Resolver, body: *ast::Node) -> Type

    throws (ResolveError)

{

    self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };

    self.loopDepth += 1;

    let ty = try infer(self, body) catch {

        self.loopDepth -= 1;

        throw ResolveError::Failure;

    };

    // Pop and check if break was encountered.

    self.loopDepth -= 1;

    }

}

/// Set the expected return type for a new function body.

fn enterFn(self: *mut Resolver, node: *ast::Node, ty: *FnType) {

    self.currentFn = ty;

    enterScope(self, node);

}

/// Clear the expected return type when leaving a function body.

) -> *[*[u8]] throws (ResolveError) {

    let mut out: *[*[u8]] = &[];

    match node.value {

        case ast::NodeValue::Ident(name) if name.len > 0 => {

            buf[0] = name;

            out = &buf[..1];

        }

        case ast::NodeValue::ScopeAccess(access) => {

            // Recursively flatten parent path.

            let parent = try flattenPath(self, access.parent, buf);

            let child = try nodeName(self, access.child);

            buf[parent.len] = child;

            out = &buf[..parent.len + 1];

        }

        case ast::NodeValue::Super => {

    node: *ast::Node,

    access: ast::Access,

    path: *[*[u8]],

    scope: *Scope

) -> *mut Symbol throws (ResolveError) {

    // Start by finding the root of the path.

    let root = path[0];

    let sym = findInScopeRecursive(scope, root, isAnySymbol) else

        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

    let suffix = &path[1..];

        isAllVoid: true

    });

    try visitList(self, decl.derives);

    let mut iota: u32 = 0;

    for variantNode, i in decl.variants {

        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value

            else panic "resolveUnionBody: invalid union variant";

        let variantName = try nodeName(self, variantDecl.name);

/// Otherwise, adds the string pointer to the pool and returns it.

pub fn intern(sp: *mut Pool, str: *[u8]) -> *[u8] {

    match lookup(sp, str) {

        case Lookup::Found(entry) => return entry,

        case Lookup::Empty(idx) => {

            sp.table[idx] = str;

            sp.count += 1;

            return str;

        }