forked from M-Labs/artiq
1
0
Fork 0

Add conversion to LLVM IR (except handling of exception handling).

This commit is contained in:
whitequark 2015-07-21 04:54:34 +03:00
parent c6cd318f19
commit 6f11fa6bb1
8 changed files with 456 additions and 15 deletions

View File

@ -19,10 +19,16 @@ class TBasicBlock(types.TMono):
def __init__(self):
super().__init__("label")
def is_basic_block(typ):
return isinstance(typ, TBasicBlock)
class TOption(types.TMono):
def __init__(self, inner):
super().__init__("option", {"inner": inner})
def is_option(typ):
return isinstance(typ, TOption)
class Value:
"""
An SSA value that keeps track of its uses.
@ -571,7 +577,7 @@ class GetAttr(Instruction):
def opcode(self):
return "getattr({})".format(repr(self.attr))
def env(self):
def object(self):
return self.operands[0]
class SetAttr(Instruction):
@ -600,7 +606,7 @@ class SetAttr(Instruction):
def opcode(self):
return "setattr({})".format(repr(self.attr))
def env(self):
def object(self):
return self.operands[0]
def value(self):

View File

@ -18,9 +18,10 @@ class Module:
int_monomorphizer = transforms.IntMonomorphizer(engine=engine)
monomorphism_validator = validators.MonomorphismValidator(engine=engine)
escape_validator = validators.EscapeValidator(engine=engine)
ir_generator = transforms.IRGenerator(engine=engine, module_name=self.name)
artiq_ir_generator = transforms.ARTIQIRGenerator(engine=engine, module_name=self.name)
dead_code_eliminator = transforms.DeadCodeEliminator(engine=engine)
local_access_validator = validators.LocalAccessValidator(engine=engine)
llvm_ir_generator = transforms.LLVMIRGenerator(engine=engine, module_name=self.name)
self.parsetree, self.comments = parse_buffer(source_buffer, engine=engine)
self.typedtree = asttyped_rewriter.visit(self.parsetree)
@ -30,9 +31,11 @@ class Module:
inferencer.visit(self.typedtree)
monomorphism_validator.visit(self.typedtree)
escape_validator.visit(self.typedtree)
self.ir = ir_generator.visit(self.typedtree)
dead_code_eliminator.process(self.ir)
local_access_validator.process(self.ir)
self.artiq_ir = artiq_ir_generator.visit(self.typedtree)
dead_code_eliminator.process(self.artiq_ir)
local_access_validator.process(self.artiq_ir)
llvm_ir_generator.process(self.artiq_ir)
self.llvm_ir = llvm_ir_generator.llmodule
@classmethod
def from_string(cls, source_string, name="input.py", first_line=1, engine=None):

View File

@ -12,7 +12,7 @@ def main():
engine.process = process_diagnostic
mod = Module.from_string("".join(fileinput.input()).expandtabs(), engine=engine)
for fn in mod.ir:
for fn in mod.artiq_ir:
print(fn)
if __name__ == "__main__":

View File

@ -0,0 +1,18 @@
import sys, fileinput
from pythonparser import diagnostic
from .. import Module
def main():
def process_diagnostic(diag):
print("\n".join(diag.render()))
if diag.level in ("fatal", "error"):
exit(1)
engine = diagnostic.Engine()
engine.process = process_diagnostic
mod = Module.from_string("".join(fileinput.input()).expandtabs(), engine=engine)
print(mod.llvm_ir)
if __name__ == "__main__":
main()

View File

@ -1,5 +1,6 @@
from .asttyped_rewriter import ASTTypedRewriter
from .inferencer import Inferencer
from .int_monomorphizer import IntMonomorphizer
from .ir_generator import IRGenerator
from .artiq_ir_generator import ARTIQIRGenerator
from .dead_code_eliminator import DeadCodeEliminator
from .llvm_ir_generator import LLVMIRGenerator

View File

@ -1,5 +1,5 @@
"""
:class:`IRGenerator` transforms typed AST into ARTIQ intermediate
:class:`ARTIQIRGenerator` transforms typed AST into ARTIQ intermediate
representation. ARTIQ IR is designed to be low-level enough that
its operations are elementary--contain no internal branching--
but without too much detail, such as exposing the reference/value
@ -25,9 +25,9 @@ def _extract_loc(node):
# We put some effort in keeping generated IR readable,
# i.e. with a more or less linear correspondence to the source.
# This is why basic blocks sometimes seem to be produced in an odd order.
class IRGenerator(algorithm.Visitor):
class ARTIQIRGenerator(algorithm.Visitor):
"""
:class:`IRGenerator` contains a lot of internal state,
:class:`ARTIQIRGenerator` contains a lot of internal state,
which is effectively maintained in a stack--with push/pop
pairs around any state updates. It is comprised of following:
@ -255,8 +255,7 @@ class IRGenerator(algorithm.Visitor):
def visit_Pass(self, node):
# Insert a dummy instruction so that analyses which extract
# locations from CFG have something to use.
self.append(ir.Arith(ast.Add(loc=None),
ir.Constant(0, self._size_type), ir.Constant(0, self._size_type)))
self.append(ir.Builtin("nop", [], builtins.TNone()))
def visit_Assign(self, node):
try:
@ -367,12 +366,13 @@ class IRGenerator(algorithm.Visitor):
try:
iterable = self.visit(node.iter)
length = self._iterable_len(iterable)
prehead = self.current_block
head = self.add_block("for.head")
self.append(ir.Branch(head))
self.current_block = head
phi = self.append(ir.Phi(length.type))
phi.add_incoming(ir.Constant(0, phi.type), head)
phi.add_incoming(ir.Constant(0, phi.type), prehead)
cond = self.append(ir.Compare(ast.Lt(loc=None), phi, length))
break_block = self.add_block("for.break")
@ -842,6 +842,8 @@ class IRGenerator(algorithm.Visitor):
def visit_BinOpT(self, node):
if builtins.is_numeric(node.type):
# TODO: check for division by zero
# TODO: check for shift by too many bits
return self.append(ir.Arith(node.op, self.visit(node.left), self.visit(node.right)))
elif isinstance(node.op, ast.Add): # list + list, tuple + tuple
lhs, rhs = self.visit(node.left), self.visit(node.right)

View File

@ -335,9 +335,12 @@ class Inferencer(algorithm.Visitor):
return list_.type, left.type, right.type
else:
return self._coerce_numeric((left, right), lambda typ: (typ, typ, typ))
elif isinstance(op, (ast.Div, ast.FloorDiv, ast.Mod, ast.Pow, ast.Sub)):
elif isinstance(op, (ast.FloorDiv, ast.Mod, ast.Pow, ast.Sub)):
# numeric operators work on any kind of number
return self._coerce_numeric((left, right), lambda typ: (typ, typ, typ))
elif isinstance(op, ast.Div):
# division always returns a float
return self._coerce_numeric((left, right), lambda typ: (builtins.TFloat(), typ, typ))
else: # MatMult
diag = diagnostic.Diagnostic("error",
"operator '{op}' is not supported", {"op": op.loc.source()},

View File

@ -0,0 +1,408 @@
"""
:class:`LLVMIRGenerator` transforms ARTIQ intermediate representation
into LLVM intermediate representation.
"""
import llvmlite.ir as ll
from pythonparser import ast
from .. import types, builtins, ir
class LLVMIRGenerator:
def __init__(self, engine, module_name, context=ll.Context()):
self.engine = engine
self.llcontext = context
self.llmodule = ll.Module(context=self.llcontext, name=module_name)
self.llfunction = None
self.llmap = {}
self.fixups = []
def llty_of_type(self, typ, for_alloc=False, for_return=False):
if types.is_tuple(typ):
return ll.LiteralStructType([self.llty_of_type(eltty) for eltty in typ.elts])
elif types.is_function(typ):
envarg = ll.IntType(8).as_pointer
llty = ll.FunctionType(args=[envarg] +
[self.llty_of_type(typ.args[arg])
for arg in typ.args] +
[self.llty_of_type(ir.TOption(typ.optargs[arg]))
for arg in typ.optargs],
return_type=self.llty_of_type(typ.ret, for_return=True))
return llty.as_pointer()
elif builtins.is_none(typ):
if for_return:
return ll.VoidType()
else:
return ll.LiteralStructType([])
elif builtins.is_bool(typ):
return ll.IntType(1)
elif builtins.is_int(typ):
return ll.IntType(builtins.get_int_width(typ))
elif builtins.is_float(typ):
return ll.DoubleType()
elif builtins.is_list(typ):
lleltty = self.llty_of_type(builtins.get_iterable_elt(typ))
return ll.LiteralStructType([ll.IntType(32), lleltty.as_pointer()])
elif builtins.is_range(typ):
lleltty = self.llty_of_type(builtins.get_iterable_elt(typ))
return ll.LiteralStructType([lleltty, lleltty, lleltty])
elif builtins.is_exception(typ):
# TODO: hack before EH is working
return ll.LiteralStructType([])
elif ir.is_basic_block(typ):
return ll.LabelType()
elif ir.is_option(typ):
return ll.LiteralStructType([ll.IntType(1), self.llty_of_type(typ.params["inner"])])
elif ir.is_environment(typ):
llty = ll.LiteralStructType([self.llty_of_type(typ.params[name])
for name in typ.params])
if for_alloc:
return llty
else:
return llty.as_pointer()
else:
assert False
def llconst_of_const(self, const):
llty = self.llty_of_type(const.type)
if const.value is None:
return ll.Constant(llty, [])
elif const.value is True:
return ll.Constant(llty, True)
elif const.value is False:
return ll.Constant(llty, False)
elif isinstance(const.value, (int, float)):
return ll.Constant(llty, const.value)
else:
assert False
def map(self, value):
if isinstance(value, (ir.Instruction, ir.BasicBlock)):
return self.llmap[value]
elif isinstance(value, ir.Constant):
return self.llconst_of_const(value)
else:
assert False
def process(self, functions):
for func in functions:
self.process_function(func)
def process_function(self, func):
llargtys = []
for arg in func.arguments:
llargtys.append(self.llty_of_type(arg.type))
llfunty = ll.FunctionType(args=llargtys,
return_type=self.llty_of_type(func.type.ret, for_return=True))
try:
self.llfunction = ll.Function(self.llmodule, llfunty, func.name)
self.llmap = {}
self.llbuilder = ll.IRBuilder()
self.fixups = []
# First, create all basic blocks.
for block in func.basic_blocks:
llblock = self.llfunction.append_basic_block(block.name)
self.llmap[block] = llblock
# Second, translate all instructions.
for block in func.basic_blocks:
self.llbuilder.position_at_end(self.llmap[block])
for insn in block.instructions:
llinsn = getattr(self, "process_" + type(insn).__name__)(insn)
assert llinsn is not None
self.llmap[insn] = llinsn
# Third, fixup phis.
for fixup in self.fixups:
fixup()
finally:
self.llfunction = None
self.llmap = None
self.fixups = []
def process_Phi(self, insn):
llinsn = self.llbuilder.phi(self.llty_of_type(insn.type), name=insn.name)
def fixup():
for value, block in insn.incoming():
llinsn.add_incoming(self.map(value), self.map(block))
self.fixups.append(fixup)
return llinsn
def process_Alloc(self, insn):
if ir.is_environment(insn.type):
return self.llbuilder.alloca(self.llty_of_type(insn.type, for_alloc=True),
name=insn.name)
elif builtins.is_list(insn.type):
llsize = self.map(insn.operands[0])
llvalue = ll.Constant(self.llty_of_type(insn.type), ll.Undefined)
llvalue = self.llbuilder.insert_value(llvalue, llsize, 0)
llalloc = self.llbuilder.alloca(self.llty_of_type(builtins.get_iterable_elt(insn.type)),
size=llsize)
llvalue = self.llbuilder.insert_value(llvalue, llalloc, 1, name=insn.name)
return llvalue
elif builtins.is_mutable(insn.type):
assert False
else: # immutable
llvalue = ll.Constant(self.llty_of_type(insn.type), ll.Undefined)
for index, elt in enumerate(insn.operands):
llvalue = self.llbuilder.insert_value(llvalue, self.map(elt), index)
llvalue.name = insn.name
return llvalue
def llindex(self, index):
return ll.Constant(ll.IntType(32), index)
def llptr_to_var(self, llenv, env_ty, var_name):
if var_name in env_ty.params:
var_index = list(env_ty.params.keys()).index(var_name)
return self.llbuilder.gep(llenv, [self.llindex(0), self.llindex(var_index)])
else:
outer_index = list(env_ty.params.keys()).index(".outer")
llptr = self.llbuilder.gep(llenv, [self.llindex(0), self.llindex(outer_index)])
llouterenv = self.llbuilder.load(llptr)
return self.llptr_to_var(llouterenv, env_ty.params[".outer"], var_name)
def process_GetLocal(self, insn):
env = insn.environment()
llptr = self.llptr_to_var(self.map(env), env.type, insn.var_name)
return self.llbuilder.load(llptr)
def process_SetLocal(self, insn):
env = insn.environment()
llptr = self.llptr_to_var(self.map(env), env.type, insn.var_name)
return self.llbuilder.store(self.map(insn.value()), llptr)
def attr_index(self, insn):
return list(insn.object().type.attributes.keys()).index(insn.attr)
def process_GetAttr(self, insn):
if types.is_tuple(insn.object().type):
return self.llbuilder.extract_value(self.map(insn.object()), self.attr_index(insn),
name=insn.name)
elif not builtins.is_mutable(insn.object().type):
return self.llbuilder.extract_value(self.map(insn.object()), self.attr_index(insn),
name=insn.name)
else:
llptr = self.llbuilder.gep(self.map(insn.object()),
[self.llindex(0), self.llindex(self.attr_index(insn))],
name=insn.name)
return self.llbuilder.load(llptr)
def process_SetAttr(self, insn):
assert builtins.is_mutable(insns.object().type)
llptr = self.llbuilder.gep(self.map(insn.object()),
[self.llindex(0), self.llindex(self.attr_index(insn))],
name=insn.name)
return self.llbuilder.store(llptr, self.map(insn.value()))
def process_GetElem(self, insn):
llelts = self.llbuilder.extract_value(self.map(insn.list()), 1)
llelt = self.llbuilder.gep(llelts, [self.map(insn.index())],
inbounds=True)
return self.llbuilder.load(llelt)
def process_SetElem(self, insn):
llelts = self.llbuilder.extract_value(self.map(insn.list()), 1)
llelt = self.llbuilder.gep(llelts, [self.map(insn.index())],
inbounds=True)
return self.llbuilder.store(self.map(insn.value()), llelt)
def process_Coerce(self, insn):
typ, value_typ = insn.type, insn.value().type
if builtins.is_int(typ) and builtins.is_float(value_typ):
return self.llbuilder.fptosi(self.map(insn.value()), self.llty_of_type(typ),
name=insn.name)
elif builtins.is_float(typ) and builtins.is_int(value_typ):
return self.llbuilder.sitofp(self.map(insn.value()), self.llty_of_type(typ),
name=insn.name)
elif builtins.is_int(typ) and builtins.is_int(value_typ):
if builtins.get_int_width(typ) > builtins.get_int_width(value_typ):
return self.llbuilder.sext(self.map(insn.value()), self.llty_of_type(typ),
name=insn.name)
else: # builtins.get_int_width(typ) < builtins.get_int_width(value_typ):
return self.llbuilder.trunc(self.map(insn.value()), self.llty_of_type(typ),
name=insn.name)
else:
assert False
def process_Arith(self, insn):
if isinstance(insn.op, ast.Add):
if builtins.is_float(insn.type):
return self.llbuilder.fadd(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
return self.llbuilder.add(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.Sub):
if builtins.is_float(insn.type):
return self.llbuilder.fsub(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
return self.llbuilder.sub(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.Mult):
if builtins.is_float(insn.type):
return self.llbuilder.fmul(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
return self.llbuilder.mul(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.Div):
if builtins.is_float(insn.lhs().type):
return self.llbuilder.fdiv(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
lllhs = self.llbuilder.sitofp(self.map(insn.lhs()), self.llty_of_type(insn.type))
llrhs = self.llbuilder.sitofp(self.map(insn.rhs()), self.llty_of_type(insn.type))
return self.llbuilder.fdiv(lllhs, llrhs,
name=insn.name)
elif isinstance(insn.op, ast.FloorDiv):
if builtins.is_float(insn.type):
llvalue = self.llbuilder.fdiv(self.map(insn.lhs()), self.map(insn.rhs()))
llfnty = ll.FunctionType(ll.DoubleType(), [ll.DoubleType()])
llfn = ll.Function(self.llmodule, llfnty, "llvm.round.f64")
return self.llbuilder.call(llfn, [llvalue],
name=insn.name)
else:
return self.llbuilder.sdiv(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.Mod):
if builtins.is_float(insn.type):
return self.llbuilder.frem(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
return self.llbuilder.srem(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.Pow):
if builtins.is_float(insn.type):
llfnty = ll.FunctionType(ll.DoubleType(), [ll.DoubleType(), ll.DoubleType()])
llfn = ll.Function(self.llmodule, llfnty, "llvm.pow.f64")
return self.llbuilder.call(llfn, [self.map(insn.lhs()), self.map(insn.rhs())],
name=insn.name)
else:
llrhs = self.llbuilder.trunc(self.map(insn.rhs()), ll.IntType(32))
llfnty = ll.FunctionType(ll.DoubleType(), [ll.DoubleType(), ll.IntType(32)])
llfn = ll.Function(self.llmodule, llfnty, "llvm.powi.f64")
llvalue = self.llbuilder.call(llfn, [self.map(insn.lhs()), llrhs])
return self.llbuilder.fptosi(llvalue, self.llty_of_type(insn.type),
name=insn.name)
elif isinstance(insn.op, ast.LShift):
return self.llbuilder.shl(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.RShift):
return self.llbuilder.ashr(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.BitAnd):
return self.llbuilder.and_(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.BitOr):
return self.llbuilder.or_(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
elif isinstance(insn.op, ast.BitXor):
return self.llbuilder.xor(self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
assert False
def process_Compare(self, insn):
if isinstance(insn.op, ast.Eq):
op = '=='
elif isinstance(insn.op, ast.NotEq):
op = '!='
elif isinstance(insn.op, ast.Gt):
op = '>'
elif isinstance(insn.op, ast.GtE):
op = '>='
elif isinstance(insn.op, ast.Lt):
op = '<'
elif isinstance(insn.op, ast.LtE):
op = '<='
else:
assert False
if builtins.is_float(insn.lhs().type):
return self.llbuilder.fcmp_ordered(op, self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
else:
return self.llbuilder.icmp_signed(op, self.map(insn.lhs()), self.map(insn.rhs()),
name=insn.name)
def process_Builtin(self, insn):
if insn.op == "nop":
fn = ll.Function(self.llmodule, ll.FunctionType(ll.VoidType(), []), "llvm.donothing")
return self.llbuilder.call(fn, [])
elif insn.op == "unwrap":
optarg, default = map(self.map, insn.operands)
has_arg = self.llbuilder.extract_value(optarg, 0)
arg = self.llbuilder.extract_value(optarg, 1)
return self.llbuilder.select(has_arg, arg, default,
name=insn.name)
elif insn.op == "round":
llfnty = ll.FunctionType(ll.DoubleType(), [ll.DoubleType()])
llfn = ll.Function(self.llmodule, llfnty, "llvm.round.f64")
return self.llbuilder.call(llfn, [llvalue],
name=insn.name)
elif insn.op == "globalenv":
def get_outer(llenv, env_ty):
if ".outer" in env_ty.params:
outer_index = list(env_ty.params.keys()).index(".outer")
llptr = self.llbuilder.gep(llenv, [self.llindex(0), self.llindex(outer_index)])
llouterenv = self.llbuilder.load(llptr)
return self.llptr_to_var(llouterenv, env_ty.params[".outer"], var_name)
else:
return llenv
env, = insn.operands
return get_outer(self.map(env), env.type)
elif insn.op == "len":
lst, = insn.operands
return self.llbuilder.extract_value(self.map(lst), 0)
# elif insn.op == "exncast":
else:
assert False
# def process_Closure(self, insn):
# pass
# def process_Call(self, insn):
# pass
def process_Select(self, insn):
return self.llbuilder.select(self.map(insn.cond()),
self.map(insn.lhs()), self.map(insn.rhs()))
def process_Branch(self, insn):
return self.llbuilder.branch(self.map(insn.target()))
def process_BranchIf(self, insn):
return self.llbuilder.cbranch(self.map(insn.condition()),
self.map(insn.if_true()), self.map(insn.if_false()))
# def process_IndirectBranch(self, insn):
# pass
def process_Return(self, insn):
if builtins.is_none(insn.type):
return self.llbuilder.ret_void()
else:
return self.llbuilder.ret(self.llmap[insn.value()])
def process_Unreachable(self, insn):
return self.llbuilder.unreachable()
def process_Raise(self, insn):
# TODO: hack before EH is working
llfnty = ll.FunctionType(ll.VoidType(), [])
llfn = ll.Function(self.llmodule, llfnty, "llvm.abort")
llinsn = self.llbuilder.call(llfn, [],
name=insn.name)
self.llbuilder.unreachable()
return llinsn
# def process_Invoke(self, insn):
# pass
# def process_LandingPad(self, insn):
# pass