def copy_module(module, temper=None):
raise NotImplementedError("not finished, needs to insert all functions"
"in valuemap first")
new_module = Module(temper=temper)
valuemap = {}
### Copy Globals
for name, gv in module.globals.iteritems():
name = new_module.temp(name)
new_global = GlobalValue(name, gv.type, gv.external, gv.address,
gv.value)
new_module.add_global(new_global)
valuemap[gv] = new_global
### Copy Functions
for name, func in module.functions.iteritems():
new_func, _ = copy_function(func, module=new_module)
new_func.name = new_module.temp(name)
new_module.add_function(new_func)
valuemap[func] = new_func
return new_module
def conversion_runtime(convertable=types.scalar_set):
"""Returns a Module with declared external runtime conversion functions"""
table = build_conversion_table(convertable)
mod = Module()
for (from_type, to_type), funcname in table.iteritems():
signature = types.Function(to_type, [from_type])
gv = GlobalValue(funcname, signature, external=True, address=0)
mod.add_global(gv)
return mod
def from_assembly(source, parser=grammar_parser):
"""Parse pykit assembly and return a Module"""
result = build(parse(source, parser))
mod = Module()
for value in result:
if isinstance(value, GlobalValue):
mod.add_global(value)
else:
mod.add_function(value)
return mod
def from_assembly(source, parser=grammar_parser):
"""Parse pykit assembly and return a Module"""
result = build(parse(source, parser))
mod = Module()
for value in result:
if isinstance(value, GlobalValue):
mod.add_global(value)
else:
mod.add_function(value)
return mod
def copy_module(module, temper=None):
raise NotImplementedError("not finished, needs to insert all functions"
"in valuemap first")
new_module = Module(temper=temper)
valuemap = {}
### Copy Globals
for name, gv in module.globals.iteritems():
name = new_module.temp(name)
new_global = GlobalValue(name, gv.type, gv.external, gv.address, gv.value)
new_module.add_global(new_global)
valuemap[gv] = new_global
### Copy Functions
for name, func in module.functions.iteritems():
new_func, _ = copy_function(func, module=new_module)
new_func.name = new_module.temp(name)
new_module.add_function(new_func)
valuemap[func] = new_func
return new_module
class PykitIRVisitor(c_ast.NodeVisitor):
"""
Map pykit IR in the form of polymorphic C to in-memory pykit IR.
int function(float x) {
int i = 0; /* I am a comment */
while (i < 10) { /*: { "unroll": true } :*/
x = call_external("sqrt", x * x);
}
return (int) x;
}
Attributes:
"""
in_function = False
def __init__(self, type_env=None):
self.mod = Module()
self.type_env = type_env or {}
self.func = None
self.builder = None
self.local_vars = None
self.allocas = None
self.global_vars = {}
self.functions = {}
# ______________________________________________________________________
@property
def vars(self):
if self.in_function:
return self.local_vars
else:
return self.global_vars
def enter_func(self):
self.in_function = True
self.local_vars = {}
self.allocas = {}
def leave_func(self):
self.in_function = False
self.mod.add_function(self.func)
self.local_vars = None
self.allocas = None
self.func = None
def visit(self, node, type=None):
"""
Visit a node.
:type: Whether we have a type for this opcode, which is an LHS type
or a cast. E.g.:
(Int) call(...) // cast
result = call(...) // assmnt, assuming 'result' is declared
result = call(..., call(...)) // second 'call' isn't typed
"""
self.type = type
method = 'visit_' + node.__class__.__name__
visitor = getattr(self, method, self.generic_visit)
# if visitor is None:
# raise SyntaxError(
# "Node %s not supported in %s:%s" % (node, node.coord.file,
# node.coord.line))
return visitor(node)
def visitif(self, node):
if node:
return self.visit(node)
def visits(self, node):
return list(map(self.visit, node))
# ______________________________________________________________________
def alloca(self, varname):
if varname not in self.allocas:
# Allocate variable with alloca
with self.builder.at_front(self.func.startblock):
type = types.Pointer(self.local_vars[varname])
result = self.func.temp(varname)
self.allocas[varname] = self.builder.alloca(type, [], result)
return self.allocas[varname]
def assignvar(self, varname, rhs):
self.builder.store(rhs, self.alloca(varname))
def assign(self, varname, rhs):
if self.in_function:
# Local variable
type = self.local_vars[varname]
self.assignvar(varname, self.visit(rhs, type=type))
else:
# Global variable
type = self.global_vars[varname]
self.mod.add_global(GlobalValue(varname, type=self.type,
value=self.visit(rhs, type=type)))
# ______________________________________________________________________
def visit_Decl(self, decl):
if decl.name in self.vars:
error(decl, "Var '%s' already declared!" % (decl.name,))
type = self.visit(decl.type)
self.vars[decl.name] = type
if decl.init:
self.assign(decl.name, decl.init)
elif not self.in_function:
extern = decl.storage == 'external'
self.mod.add_global(GlobalValue(decl.name, type, external=extern))
return type
def visit_TypeDecl(self, decl):
return self.visit(decl.type)
visit_Typename = visit_TypeDecl
def visit_PtrDecl(self, decl):
return types.Pointer(self.visit(decl.type.type))
def visit_FuncDecl(self, decl):
if decl.args:
params = self.visits(decl.args.params)
else:
params = []
return types.Function(self.visit(decl.type), params)
def visit_IdentifierType(self, node):
name, = node.names
return self.type_env[name]
def visit_Typedef(self, node):
if node.name in ("Type", "_list"):
type = self.type_env[node.name]
else:
type = self.visit(node.type)
if type == types.Type:
type = getattr(types, node.name)
self.type_env[node.name] = type
return type
def visit_Template(self, node):
left = self.visit(node.left)
subtypes = self.visits(node.right)
if left is list:
return list(subtypes)
else:
assert issubclass(left, types.Type)
subtypes = self.visits(node.right)
return left(*subtypes)
# ______________________________________________________________________
def visit_FuncDef(self, node):
assert not node.param_decls
self.enter_func()
name = node.decl.name
type = self.visit(node.decl.type)
if node.decl.type.args:
argnames = [p.name or "" for p in node.decl.type.args.params]
else:
argnames = []
self.func = Function(name, argnames, type)
self.func.new_block('entry')
self.builder = Builder(self.func)
self.builder.position_at_end(self.func.startblock)
# Store arguments in stack variables
for argname in argnames:
self.assignvar(argname, self.func.get_arg(argname))
self.generic_visit(node.body)
self.leave_func()
# ______________________________________________________________________
def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
if opcode in self.mod.functions:
return self.builder.call(type, [self.mod.get_function(opcode),
args])
error(node, "No opcode %s" % (opcode,))
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or "Unset", args)
def visit_ID(self, node):
if self.in_function:
if node.name in self.local_vars:
result = self.alloca(node.name)
return self.builder.load(result.type.base, [result])
global_val = (self.mod.get_function(node.name) or
self.mod.get_global(node.name))
if not global_val:
error(node, "Not a local or global: %r" % node.name)
return global_val
def visit_Cast(self, node):
type = self.visit(node.to_type)
if isinstance(node.expr, c_ast.FuncCall):
op = self.visit(node.expr, type=type)
op.type = type
return op
else:
result = self.visit(node.expr)
if result.type == type:
return result
return self.builder.convert(type, [result])
def visit_Assignment(self, node):
if node.op != '=':
error(node, "Only assignment with '=' is supported")
if not isinstance(node.lvalue, c_ast.ID):
error(node, "Canot only assign to a name")
self.assign(node.lvalue.name, node.rvalue)
def visit_Constant(self, node):
type = self.type_env[node.type]
const = types.convert(node.value, types.resolve_typedef(type))
if isinstance(const, basestring):
const = const[1:-1] # slice away quotes
return Const(const)
def visit_UnaryOp(self, node):
op = defs.unary_defs[node.op]
buildop = getattr(self.builder, op)
arg = self.visit(node.expr)
type = self.type or arg.type
return buildop(type, [arg])
def visit_BinaryOp(self, node):
op = binary_defs[node.op]
buildop = getattr(self.builder, op)
left, right = self.visits([node.left, node.right])
type = self.type
if not type:
l, r = map(types.resolve_typedef, [left.type, right.type])
assert l == r, (l, r)
if node.op in defs.compare_defs:
type = types.Bool
return buildop(type or left.type, [left, right])
def visit_If(self, node):
cond = self.visit(node.cond)
ifpos, elsepos, exit_block = self.builder.ifelse(cond)
with ifpos:
self.visit(node.iftrue)
self.builder.jump(exit_block)
with elsepos:
if node.iffalse:
self.visit(node.iffalse)
self.builder.jump(exit_block)
self.builder.position_at_end(exit_block)
def _loop(self, init, cond, next, body):
_, exit_block = self.builder.splitblock(self.func.temp("exit"))
_, body_block = self.builder.splitblock(self.func.temp("body"))
_, cond_block = self.builder.splitblock(self.func.temp("cond"))
self.visitif(init)
self.builder.jump(cond_block)
with self.builder.at_front(cond_block):
cond = self.visit(cond, type=types.Bool)
self.builder.cbranch(cond, body_block, exit_block)
with self.builder.at_front(body_block):
self.visit(body)
self.visitif(next)
bb = self.builder.basic_block
if not bb.tail or not ops.is_terminator(bb.tail.opcode):
self.builder.jump(cond_block)
self.builder.position_at_end(exit_block)
def visit_While(self, node):
self._loop(None, node.cond, None, node.stmt)
def visit_For(self, node):
# avoid silly 2to3 rewrite to 'node.__next__'
next = getattr(node, 'next')
self._loop(node.init, node.cond, next, node.stmt)
def visit_Return(self, node):
b = self.builder
value = self.visit(node.expr)
t = self.func.temp
b.ret(b.convert(self.func.type.restype, [value]))
class PykitIRVisitor(c_ast.NodeVisitor):
"""
Map pykit IR in the form of polymorphic C to in-memory pykit IR.
int function(float x) {
int i = 0; /* I am a comment */
while (i < 10) { /*: { "unroll": true } :*/
x = call_external("sqrt", x * x);
}
return (int) x;
}
Attributes:
"""
in_function = False
def __init__(self, type_env=None):
self.mod = Module()
self.type_env = type_env or {}
self.func = None
self.builder = None
self.local_vars = None
self.allocas = None
self.global_vars = {}
self.functions = {}
# ______________________________________________________________________
@property
def vars(self):
if self.in_function:
return self.local_vars
else:
return self.global_vars
def enter_func(self):
self.in_function = True
self.local_vars = {}
self.allocas = {}
def leave_func(self):
self.in_function = False
self.mod.add_function(self.func)
self.local_vars = None
self.allocas = None
self.func = None
def visit(self, node, type=None):
"""
Visit a node.
:type: Whether we have a type for this opcode, which is an LHS type
or a cast. E.g.:
(Int) call(...) // cast
result = call(...) // assmnt, assuming 'result' is declared
result = call(..., call(...)) // second 'call' isn't typed
"""
self.type = type
method = 'visit_' + node.__class__.__name__
visitor = getattr(self, method, self.generic_visit)
# if visitor is None:
# raise SyntaxError(
# "Node %s not supported in %s:%s" % (node, node.coord.file,
# node.coord.line))
return visitor(node)
def visitif(self, node):
if node:
return self.visit(node)
def visits(self, node):
return list(map(self.visit, node))
# ______________________________________________________________________
def alloca(self, varname):
if varname not in self.allocas:
# Allocate variable with alloca
with self.builder.at_front(self.func.startblock):
type = types.Pointer(self.local_vars[varname])
result = self.func.temp(varname)
self.allocas[varname] = self.builder.alloca(type, [], result)
return self.allocas[varname]
def assignvar(self, varname, rhs):
self.builder.store(rhs, self.alloca(varname))
def assign(self, varname, rhs):
if self.in_function:
# Local variable
type = self.local_vars[varname]
self.assignvar(varname, self.visit(rhs, type=type))
else:
# Global variable
type = self.global_vars[varname]
self.mod.add_global(
GlobalValue(varname,
type=self.type,
value=self.visit(rhs, type=type)))
# ______________________________________________________________________
def visit_Decl(self, decl):
if decl.name in self.vars:
error(decl, "Var '%s' already declared!" % (decl.name, ))
type = self.visit(decl.type)
self.vars[decl.name] = type
if decl.init:
self.assign(decl.name, decl.init)
elif not self.in_function:
extern = decl.storage == 'external'
self.mod.add_global(GlobalValue(decl.name, type, external=extern))
return type
def visit_TypeDecl(self, decl):
return self.visit(decl.type)
visit_Typename = visit_TypeDecl
def visit_PtrDecl(self, decl):
return types.Pointer(self.visit(decl.type.type))
def visit_FuncDecl(self, decl):
if decl.args:
params = self.visits(decl.args.params)
else:
params = []
return types.Function(self.visit(decl.type), params)
def visit_IdentifierType(self, node):
name, = node.names
return self.type_env[name]
def visit_Typedef(self, node):
if node.name in ("Type", "_list"):
type = self.type_env[node.name]
else:
type = self.visit(node.type)
if type == types.Type:
type = getattr(types, node.name)
self.type_env[node.name] = type
return type
def visit_Template(self, node):
left = self.visit(node.left)
subtypes = self.visits(node.right)
if left is list:
return list(subtypes)
else:
assert issubclass(left, types.Type)
subtypes = self.visits(node.right)
return left(*subtypes)
# ______________________________________________________________________
def visit_FuncDef(self, node):
assert not node.param_decls
self.enter_func()
name = node.decl.name
type = self.visit(node.decl.type)
if node.decl.type.args:
argnames = [p.name or "" for p in node.decl.type.args.params]
else:
argnames = []
self.func = Function(name, argnames, type)
self.func.new_block('entry')
self.builder = Builder(self.func)
self.builder.position_at_end(self.func.startblock)
# Store arguments in stack variables
for argname in argnames:
self.assignvar(argname, self.func.get_arg(argname))
self.generic_visit(node.body)
self.leave_func()
# ______________________________________________________________________
def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(
node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
if opcode in self.mod.functions:
return self.builder.call(type,
[self.mod.get_function(opcode), args])
error(node, "No opcode %s" % (opcode, ))
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or "Unset", args)
def visit_ID(self, node):
if self.in_function:
if node.name in self.local_vars:
result = self.alloca(node.name)
return self.builder.load(result.type.base, [result])
global_val = (self.mod.get_function(node.name)
or self.mod.get_global(node.name))
if not global_val:
error(node, "Not a local or global: %r" % node.name)
return global_val
def visit_Cast(self, node):
type = self.visit(node.to_type)
if isinstance(node.expr, c_ast.FuncCall):
op = self.visit(node.expr, type=type)
op.type = type
return op
else:
result = self.visit(node.expr)
if result.type == type:
return result
return self.builder.convert(type, [result])
def visit_Assignment(self, node):
if node.op != '=':
error(node, "Only assignment with '=' is supported")
if not isinstance(node.lvalue, c_ast.ID):
error(node, "Canot only assign to a name")
self.assign(node.lvalue.name, node.rvalue)
def visit_Constant(self, node):
type = self.type_env[node.type]
const = types.convert(node.value, types.resolve_typedef(type))
if isinstance(const, basestring):
const = const[1:-1] # slice away quotes
return Const(const)
def visit_UnaryOp(self, node):
op = defs.unary_defs[node.op]
buildop = getattr(self.builder, op)
arg = self.visit(node.expr)
type = self.type or arg.type
return buildop(type, [arg])
def visit_BinaryOp(self, node):
op = binary_defs[node.op]
buildop = getattr(self.builder, op)
left, right = self.visits([node.left, node.right])
type = self.type
if not type:
l, r = map(types.resolve_typedef, [left.type, right.type])
assert l == r, (l, r)
if node.op in defs.compare_defs:
type = types.Bool
return buildop(type or left.type, [left, right])
def visit_If(self, node):
cond = self.visit(node.cond)
ifpos, elsepos, exit_block = self.builder.ifelse(cond)
with ifpos:
self.visit(node.iftrue)
self.builder.jump(exit_block)
with elsepos:
if node.iffalse:
self.visit(node.iffalse)
self.builder.jump(exit_block)
self.builder.position_at_end(exit_block)
def _loop(self, init, cond, next, body):
_, exit_block = self.builder.splitblock(self.func.temp("exit"))
_, body_block = self.builder.splitblock(self.func.temp("body"))
_, cond_block = self.builder.splitblock(self.func.temp("cond"))
self.visitif(init)
self.builder.jump(cond_block)
with self.builder.at_front(cond_block):
cond = self.visit(cond, type=types.Bool)
self.builder.cbranch(cond, body_block, exit_block)
with self.builder.at_front(body_block):
self.visit(body)
self.visitif(next)
bb = self.builder.basic_block
if not bb.tail or not ops.is_terminator(bb.tail.opcode):
self.builder.jump(cond_block)
self.builder.position_at_end(exit_block)
def visit_While(self, node):
self._loop(None, node.cond, None, node.stmt)
def visit_For(self, node):
# avoid silly 2to3 rewrite to 'node.__next__'
next = getattr(node, 'next')
self._loop(node.init, node.cond, next, node.stmt)
def visit_Return(self, node):
b = self.builder
value = self.visit(node.expr)
t = self.func.temp
b.ret(b.convert(self.func.type.restype, [value]))