#MachV

MilkIR
  |
  | target lowering and instruction selection
  v
MachV with virtual registers
  |
  | machv_regalloc
  v
allocation locations and edits, or rewritten MachV
  |
  | machv_emit
  v
machine code and relocation metadata

#Start with one small function

///|
test "build a 64-bit add function" {
  let builder = FunctionBuilder::FunctionBuilder("add64")

  let lhs = builder.add_param(Int)
  let rhs = builder.add_param(Int)
  builder.add_result(I64)

  let sum = builder.new_vreg(Int)
  builder.append(Add(true), uses=[Virtual(lhs), Virtual(rhs)], defs=[
    { reg: Virtual(sum) },
  ])
  |> ignore
  builder.terminate(Return([Virtual(sum)]))

  let func = builder.finish()
  inspect(
    func.print(),
    content=(
      #|machv add64(v0:int, v1:int) {
      #|block0:
      #|    v2 = add v0, v1
      #|    ret v2
      #|}
      #|
    ),
  )
  debug_inspect(func.get_result_kinds(), content="[I64]")
}

machv add64(v0:int, v1:int) {  two integer-register parameters
block0:                        execution starts in block0
    v2 = add v0, v1           read v0 and v1, then define v2
    ret v2                     return the value in v2
}

1. add_param(Int) creates an incoming virtual register in the integer register class.
2. add_result(I64) records the full result kind used by ABI decisions.
3. append(...) adds one machine instruction to the current block.
4. terminate(...) gives the block its control-flow exit.

#How MachV differs from MilkIR

#Registers: virtual, physical, and writable

uses = [v0, v1]
defs = [v2]

#Register classes and value kinds

#Instructions: opcode, uses, definitions, and constraints

• an Opcode describing the operation;
• uses, the registers read by the instruction;
• defs, the registers written by the instruction;
• optional constraints for operands that must use particular physical registers.

Add(true)     uses [lhs, rhs]       defs [result]
Load(I64, 8)  uses [base]           defs [loaded]
Store(I64, 8) uses [value, base]    defs []
Move          uses [source]         defs [destination]

#Operand constraints

///|
test "attach a fixed-register constraint" {
  let builder = FunctionBuilder::FunctionBuilder("fixed_result")
  let src = builder.add_param(Int)
  let dst = builder.new_vreg(Int)
  let required : PReg = { index: 1, class: Int }

  builder.append(Move, uses=[Virtual(src)], defs=[{ reg: Virtual(dst) }], def_constraints=[
    FixedReg(required),
  ])
  |> ignore
  builder.terminate(Return([Virtual(dst)]))

  let func = builder.finish()
  inspect(
    func.blocks[0].insts[0].def_constraints[0] == FixedReg(required),
    content="true",
  )
}

#Blocks and terminators

///|
test "build conditional control flow" {
  let builder = FunctionBuilder::FunctionBuilder("choose_path")
  let condition = builder.add_param(Int)
  let then_block = builder.create_block()
  let else_block = builder.create_block()

  builder.terminate(Branch(Virtual(condition), then_block, else_block))

  builder.switch_to_block(then_block)
  builder.terminate(Return([]))

  builder.switch_to_block(else_block)
  builder.terminate(Return([]))

  let func = builder.finish()
  inspect(func.blocks.length(), content="3")
  inspect(func.blocks[0].terminator is Some(Branch(_, _, _)), content="true")
  inspect(func.blocks[1].terminator is Some(Return([])), content="true")
  inspect(func.blocks[2].terminator is Some(Return([])), content="true")
}

#Calls, ABI data, and stack state

• CallConventionLayout describes argument and result registers plus overflow stack layout.
• EmbeddingABI groups the calling convention with reserved-register and context-layout data.
• call opcodes record argument counts, result register classes, symbolic targets, and clobber classes.
• max_outgoing_args_size records the largest outgoing stack-argument area needed by the function.
• num_spill_slots records spill space assigned during register allocation.

#Construction rules

1. Give every block exactly one terminator.
2. Supply uses and defs in the order required by the opcode.
3. Use register classes compatible with the selected instruction form.
4. Keep constraint arrays aligned with their corresponding operands.
5. Use Function::print() in lowering tests so instruction and control-flow mistakes are easy to inspect.

#Packages

#Integration