gbuoy/lib/regalloc.ts

import { colorGreedy, createGraph, Graph, maxCardinalitySearch } from "./data/graph"
import { R8, StackOffset } from "./sm83/cpu"
import type { Loc } from "./ir/loc"
import type { SSA } from "./ir/ssa"

export type LivenessInfo = Array<Set<Loc>>

export const liveness = (block: Array<SSA>): LivenessInfo => {
    const info: LivenessInfo = []

    info[block.length] = new Set()
    for (let i = block.length - 1; i >= 0; --i) {
        const insn = block[i]
        const last = info[i + 1]

        info[i] = new Set()

        if (typeof insn.source !== "number") {
            info[i].add(insn.source)
        }

        last.forEach(loc => {
            if (loc.toString() === insn.dest.toString()) {
                return
            }

            info[i].add(loc)
        })
    }

    return info
}

export const locations = (block: Array<SSA>): Set<Loc> => {
    const ls: Set<Loc> = new Set()

    block.forEach(ssa => {
        ls.add(ssa.dest)

        if (typeof ssa.source !== "number") {
            ls.add(ssa.source)
        }
    })

    return ls
}

export const interference = (block: Array<SSA>, live: LivenessInfo): Graph<Loc> =>
    createGraph((v, e) => {
        const locs = locations(block)
        locs.forEach(loc => {
            v(loc.toString(), loc)
        })

        block.forEach((ssa, i) =>
            live[i + 1].forEach(u => {
                if (ssa.dest.toString() !== u.toString()) {
                    e(ssa.dest.toString(), u.toString())
                }
            })
        )
    })

export type RegAlloc = {
    [s: string]: string | StackOffset,
}

export const allocateRegisters = (block: Array<SSA>, registers: Array<string>): RegAlloc => {
    const info = liveness(block)
    const graph = interference(block, info)
    const ordering = maxCardinalitySearch(graph)
    const coloring = colorGreedy(graph, ordering)

    const allocation: RegAlloc = {}
    const availableRegisters = new Set(registers)
    const colorMap: { [c: number]: string | StackOffset } = {}
    let nextStackOffset = 0

    Object.entries(coloring.colors).forEach(([vertex, color]) => {
        if (typeof colorMap[color] !== 'undefined') {
            allocation[vertex] = colorMap[color]
            return
        }

        let value = null
        if (availableRegisters.size == 0) {
            value = { offset: nextStackOffset++ }
        } else {
            const result = availableRegisters.values().next()
            value = result.value
            availableRegisters.delete(value)
        }

        allocation[vertex] = value
        colorMap[color] = value
    })

    return allocation
}