Multi-Target
Compiler Architecture

from llvmlite.ir import (
    Module, Function, FunctionType, IRBuilder,
    IntType, DoubleType, VoidType, Constant
)

# Create module and types
mod = Module('mycompiler')
int_type = IntType(32)      # i32
float_type = DoubleType()   # f64
void_type = VoidType()

# Declare a function: int hello()
hello_func = Function(mod, 
    FunctionType(int_type, []), 
    name='hello')

# Add a basic block and builder
block = hello_func.append_basic_block('entry')
builder = IRBuilder(block)

# Return a constant
builder.ret(Constant(int_type, 42))

class GenerateLLVM:
    def __init__(self):
        self.stack = []        # LLVM value stack
        self.locals = {}       # Local variable pointers
        self.globals = {}      # Global variable pointers
        self.block_stack = []  # Control flow blocks
    
    def push(self, value):
        self.stack.append(value)
    
    def pop(self):
        return self.stack.pop()
    
    def emit_ADDI(self):
        right = self.pop()
        left = self.pop()
        result = self.builder.add(left, right)  # SSA!
        self.push(result)
    
    def emit_MULI(self):
        right = self.pop()
        left = self.pop()
        self.push(self.builder.mul(left, right))
    
    def emit_ADDF(self):
        right = self.pop()
        left = self.pop()
        self.push(self.builder.fadd(left, right))  # Float add

from llvmlite.ir import GlobalVariable

def emit_VARI(self, name):
    '''Declare local integer variable.'''
    self.locals[name] = self.builder.alloca(int_type, name=name)

def emit_GLOBALI(self, name):
    '''Declare global integer variable.'''
    var = GlobalVariable(self.module, int_type, name=name)
    var.initializer = Constant(int_type, 0)
    self.globals[name] = var

def emit_LOAD(self, name):
    '''Load variable onto stack.'''
    ptr = self.locals.get(name) or self.globals.get(name)
    self.push(self.builder.load(ptr, name))

def emit_STORE(self, name):
    '''Store top of stack to variable.'''
    ptr = self.locals.get(name) or self.globals.get(name)
    self.builder.store(self.pop(), ptr)

def emit_LTI(self):
    '''Integer less-than comparison.'''
    right = self.pop()
    left = self.pop()
    # icmp returns i1 (1-bit bool)
    result = self.builder.icmp_signed('<', left, right)
    # Zero-extend i1 → i32 for stack
    self.push(self.builder.zext(result, IntType(32)))

def emit_LTF(self):
    '''Float less-than comparison.'''
    right = self.pop()
    left = self.pop()
    result = self.builder.fcmp_ordered('<', left, right)
    self.push(self.builder.zext(result, IntType(32)))

# Available comparisons:
# icmp_signed: '<', '<=', '>', '>=', '==', '!='
# fcmp_ordered: '<', '<=', '>', '>=', '==', '!='

def emit_IF(self):
    then_block = self.function.append_basic_block('then')
    else_block = self.function.append_basic_block('else')
    exit_block = self.function.append_basic_block('endif')
    
    # Truncate i32 → i1 for branch condition
    cond = self.builder.trunc(self.pop(), IntType(1))
    self.builder.cbranch(cond, then_block, else_block)
    self.builder.position_at_end(then_block)
    self.block_stack.append((then_block, else_block, exit_block))

def emit_ELSE(self):
    _, else_block, exit_block = self.block_stack[-1]
    self.builder.branch(exit_block)  # End of then-block
    self.builder.position_at_end(else_block)

def emit_ENDIF(self):
    _, _, exit_block = self.block_stack.pop()
    self.builder.branch(exit_block)
    self.builder.position_at_end(exit_block)

def emit_LOOP(self):
    loop_block = self.function.append_basic_block('loop')
    exit_block = self.function.append_basic_block('endloop')
    self.builder.branch(loop_block)
    self.builder.position_at_end(loop_block)
    self.block_stack.append((loop_block, exit_block))

# Declare external C function: void _print_int(int x)
_print_int = Function(mod,
    FunctionType(void_type, [int_type]),
    name='_print_int')

def emit_PRINTI(self):
    self.builder.call(_print_int, [self.pop()])

def emit_CALL(self, name):
    func = self.globals[name]
    # Pop args in reverse order
    args = [self.pop() for _ in range(len(func.args))][::-1]
    result = self.builder.call(func, args)
    self.push(result)