target.jou

# LLVM makes a mess of how to define what kind of computer will run the
# compiled programs. Sometimes it wants a target triple, sometimes a
# data layout. Sometimes it wants a string, sometimes an object
# representing the thing.
#
# This file aims to provide everything you may ever need. Hopefully it
# will make the mess slightly less miserable to you. Just use the global
# "target" variable, it contains everything you will ever need.

import "./llvm.jou"
import "stdlib/str.jou"
import "stdlib/io.jou"
import "stdlib/process.jou"

class Target:
    triple: byte[100]
    data_layout: byte[500]
    target: LLVMTarget*
    target_machine: LLVMTargetMachine*
    target_data: LLVMTargetData*

global target: Target


def init_target() -> None:
    LLVMInitializeX86TargetInfo()
    LLVMInitializeX86Target()
    LLVMInitializeX86TargetMC()
    LLVMInitializeX86AsmParser()
    LLVMInitializeX86AsmPrinter()

    if MACOS:
        # Support the new M1 macs. This will enable the target also on x86_64
        # macs, but it doesn't matter.
        LLVMInitializeAArch64TargetInfo()
        LLVMInitializeAArch64Target()
        LLVMInitializeAArch64TargetMC()
        LLVMInitializeAArch64AsmParser()
        LLVMInitializeAArch64AsmPrinter()

    if WINDOWS:
        # LLVM's default is x86_64-pc-windows-msvc
        target.triple = "x86_64-pc-windows-gnu"
    else:
        triple = LLVMGetDefaultTargetTriple()
        assert strlen(triple) < sizeof target.triple
        strcpy(target.triple, triple)
        LLVMDisposeMessage(triple)

    error: byte* = NULL
    if LLVMGetTargetFromTriple(target.triple, &target.target, &error) != 0:
        assert error != NULL
        fprintf(stderr, "LLVMGetTargetFromTriple(\"%s\") failed: %s\n", target.triple, error)
        exit(1)
    assert error == NULL
    assert target.target != NULL

    target.target_machine = LLVMCreateTargetMachine(
        target.target,
        target.triple,
        "",
        "",
        LLVMCodeGenOptLevel.Default,
        LLVMRelocMode.PIC,
        LLVMCodeModel.Default,
    )
    assert target.target_machine != NULL

    target.target_data = LLVMCreateTargetDataLayout(target.target_machine)
    assert target.target_data != NULL

    tmp = LLVMCopyStringRepOfTargetData(target.target_data)
    assert strlen(tmp) < sizeof target.data_layout
    strcpy(target.data_layout, tmp)
    LLVMDisposeMessage(tmp)

def cleanup_target() -> None:
    LLVMDisposeTargetMachine(target.target_machine)
    LLVMDisposeTargetData(target.target_data)