Method executeBinaryOp

src/codegen/executeBinaryOp.go:10–197

(step *Step, instr *ssa.BinaryOp)

	"git.urbach.dev/cli/q/src/ssa"
	"git.urbach.dev/cli/q/src/token"
	"git.urbach.dev/cli/q/src/types"
)

func (f *Function) executeBinaryOp(step *Step, instr *ssa.BinaryOp) {
	if step.Register == -1 && !instr.Op.IsComparison() {
		return
	}

	left := f.ValueToStep[instr.Left]
	right := f.ValueToStep[instr.Right]
	live := slices.Concat(step.Live, []*Step{left, right})
	source := f.resolveOperand(left, live)
	avoid := []cpu.Register{source}

	if instr.Op == token.Div || instr.Op == token.Mod {
		avoid = append(avoid, f.CPU.DivisorRestricted...)
	}

	operand := f.resolveOperand(right, live, avoid...)
	destination := step.Register
	isSpilled := f.isSpilled(destination)

	if isSpilled {
		avoid = append(avoid, operand)

		if instr.Op == token.Shl || instr.Op == token.Shr {
			avoid = append(avoid, f.CPU.ShiftRestricted...)
		}

		destination = f.findTempRegister(live, avoid...)
	}

	if instr.Op.IsComparison() {
		f.emitComparison(step, left, right, source, operand, destination, instr.Op)
	} else if isImmediate(right) {
		f.emitArithmeticImmediate(left, source, destination, right.Value.(*ssa.Int).Int, instr.Op)
	} else {
		f.emitArithmeticRegister(left, source, operand, destination, instr.Op)
	}

	if isSpilled {
		f.storeSpill(step, destination)
	}
}

// emitComparison emits a compare followed by a conditional set when the result register is needed.
func (f *Function) emitComparison(step *Step, left *Step, right *Step, source cpu.Register, operand cpu.Register, destination cpu.Register, op token.Kind) {
	if isImmediate(right) {
		f.Assembler.Append(&asm.CompareNumber{Destination: source, Number: right.Value.(*ssa.Int).Int})
	} else {
		f.Assembler.Append(&asm.Compare{Destination: source, Source: operand})
	}

	if step.Register != -1 {
		unsigned := types.IsUnsigned(left.Value.Type()) || types.IsUnsigned(right.Value.Type())
		f.conditionalSet(destination, op, unsigned)
	}
}