1120 lines
33 KiB
Python
1120 lines
33 KiB
Python
|
import contextlib
|
||
|
|
import functools
|
||
|
|
|
||
|
|
from llvmlite.ir import instructions, types, values
|
||
|
|
|
||
|
|
_CMP_MAP = {
|
||
|
|
'>': 'gt',
|
||
|
|
'<': 'lt',
|
||
|
|
'==': 'eq',
|
||
|
|
'!=': 'ne',
|
||
|
|
'>=': 'ge',
|
||
|
|
'<=': 'le',
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
def _unop(opname, cls=instructions.Instruction):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, arg, name='', flags=()):
|
||
|
|
instr = cls(self.block, arg.type, opname, [arg], name, flags)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _binop(opname, cls=instructions.Instruction):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, lhs, rhs, name='', flags=()):
|
||
|
|
if lhs.type != rhs.type:
|
||
|
|
raise ValueError("Operands must be the same type, got (%s, %s)"
|
||
|
|
% (lhs.type, rhs.type))
|
||
|
|
instr = cls(self.block, lhs.type, opname, (lhs, rhs), name, flags)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _binop_with_overflow(opname, cls=instructions.Instruction):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, lhs, rhs, name=''):
|
||
|
|
if lhs.type != rhs.type:
|
||
|
|
raise ValueError("Operands must be the same type, got (%s, %s)"
|
||
|
|
% (lhs.type, rhs.type))
|
||
|
|
ty = lhs.type
|
||
|
|
if not isinstance(ty, types.IntType):
|
||
|
|
raise TypeError("expected an integer type, got %s" % (ty,))
|
||
|
|
bool_ty = types.IntType(1)
|
||
|
|
|
||
|
|
mod = self.module
|
||
|
|
fnty = types.FunctionType(types.LiteralStructType([ty, bool_ty]),
|
||
|
|
[ty, ty])
|
||
|
|
fn = mod.declare_intrinsic("llvm.%s.with.overflow" % (opname,),
|
||
|
|
[ty], fnty)
|
||
|
|
ret = self.call(fn, [lhs, rhs], name=name)
|
||
|
|
return ret
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _uniop(opname, cls=instructions.Instruction):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, operand, name=''):
|
||
|
|
instr = cls(self.block, operand.type, opname, [operand], name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _uniop_intrinsic_int(opname):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, operand, name=''):
|
||
|
|
if not isinstance(operand.type, types.IntType):
|
||
|
|
raise TypeError(
|
||
|
|
"expected an integer type, got %s" %
|
||
|
|
operand.type)
|
||
|
|
fn = self.module.declare_intrinsic(opname, [operand.type])
|
||
|
|
return self.call(fn, [operand], name)
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _uniop_intrinsic_float(opname):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, operand, name=''):
|
||
|
|
if not isinstance(
|
||
|
|
operand.type, (types.FloatType, types.DoubleType)):
|
||
|
|
raise TypeError("expected a float type, got %s" % operand.type)
|
||
|
|
fn = self.module.declare_intrinsic(opname, [operand.type])
|
||
|
|
return self.call(fn, [operand], name)
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _uniop_intrinsic_with_flag(opname):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, operand, flag, name=''):
|
||
|
|
if not isinstance(operand.type, types.IntType):
|
||
|
|
raise TypeError(
|
||
|
|
"expected an integer type, got %s" %
|
||
|
|
operand.type)
|
||
|
|
if not (isinstance(flag.type, types.IntType) and
|
||
|
|
flag.type.width == 1):
|
||
|
|
raise TypeError("expected an i1 type, got %s" % flag.type)
|
||
|
|
fn = self.module.declare_intrinsic(
|
||
|
|
opname, [operand.type, flag.type])
|
||
|
|
return self.call(fn, [operand, flag], name)
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _triop_intrinsic(opname):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, a, b, c, name=''):
|
||
|
|
if a.type != b.type or b.type != c.type:
|
||
|
|
raise TypeError(
|
||
|
|
"expected types to be the same, got %s, %s, %s" % (
|
||
|
|
a.type,
|
||
|
|
b.type,
|
||
|
|
c.type))
|
||
|
|
elif not isinstance(
|
||
|
|
a.type,
|
||
|
|
(types.HalfType, types.FloatType, types.DoubleType)):
|
||
|
|
raise TypeError(
|
||
|
|
"expected an floating point type, got %s" %
|
||
|
|
a.type)
|
||
|
|
fn = self.module.declare_intrinsic(opname, [a.type, b.type, c.type])
|
||
|
|
return self.call(fn, [a, b, c], name)
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _castop(opname, cls=instructions.CastInstr):
|
||
|
|
def wrap(fn):
|
||
|
|
@functools.wraps(fn)
|
||
|
|
def wrapped(self, val, typ, name=''):
|
||
|
|
if val.type == typ:
|
||
|
|
return val
|
||
|
|
instr = cls(self.block, opname, val, typ, name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
return wrapped
|
||
|
|
|
||
|
|
return wrap
|
||
|
|
|
||
|
|
|
||
|
|
def _label_suffix(label, suffix):
|
||
|
|
"""Returns (label + suffix) or a truncated version if it's too long.
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
label : str
|
||
|
|
Label name
|
||
|
|
suffix : str
|
||
|
|
Label suffix
|
||
|
|
"""
|
||
|
|
if len(label) > 50:
|
||
|
|
nhead = 25
|
||
|
|
return ''.join([label[:nhead], '..', suffix])
|
||
|
|
else:
|
||
|
|
return label + suffix
|
||
|
|
|
||
|
|
|
||
|
|
class IRBuilder(object):
|
||
|
|
def __init__(self, block=None):
|
||
|
|
self._block = block
|
||
|
|
self._anchor = len(block.instructions) if block else 0
|
||
|
|
self.debug_metadata = None
|
||
|
|
|
||
|
|
@property
|
||
|
|
def block(self):
|
||
|
|
"""
|
||
|
|
The current basic block.
|
||
|
|
"""
|
||
|
|
return self._block
|
||
|
|
|
||
|
|
basic_block = block
|
||
|
|
|
||
|
|
@property
|
||
|
|
def function(self):
|
||
|
|
"""
|
||
|
|
The current function.
|
||
|
|
"""
|
||
|
|
return self.block.parent
|
||
|
|
|
||
|
|
@property
|
||
|
|
def module(self):
|
||
|
|
"""
|
||
|
|
The current module.
|
||
|
|
"""
|
||
|
|
return self.block.parent.module
|
||
|
|
|
||
|
|
def position_before(self, instr):
|
||
|
|
"""
|
||
|
|
Position immediately before the given instruction. The current block
|
||
|
|
is also changed to the instruction's basic block.
|
||
|
|
"""
|
||
|
|
self._block = instr.parent
|
||
|
|
self._anchor = self._block.instructions.index(instr)
|
||
|
|
|
||
|
|
def position_after(self, instr):
|
||
|
|
"""
|
||
|
|
Position immediately after the given instruction. The current block
|
||
|
|
is also changed to the instruction's basic block.
|
||
|
|
"""
|
||
|
|
self._block = instr.parent
|
||
|
|
self._anchor = self._block.instructions.index(instr) + 1
|
||
|
|
|
||
|
|
def position_at_start(self, block):
|
||
|
|
"""
|
||
|
|
Position at the start of the basic *block*.
|
||
|
|
"""
|
||
|
|
self._block = block
|
||
|
|
self._anchor = 0
|
||
|
|
|
||
|
|
def position_at_end(self, block):
|
||
|
|
"""
|
||
|
|
Position at the end of the basic *block*.
|
||
|
|
"""
|
||
|
|
self._block = block
|
||
|
|
self._anchor = len(block.instructions)
|
||
|
|
|
||
|
|
def append_basic_block(self, name=''):
|
||
|
|
"""
|
||
|
|
Append a basic block, with the given optional *name*, to the current
|
||
|
|
function. The current block is not changed. The new block is returned.
|
||
|
|
"""
|
||
|
|
return self.function.append_basic_block(name)
|
||
|
|
|
||
|
|
def remove(self, instr):
|
||
|
|
"""Remove the given instruction."""
|
||
|
|
idx = self._block.instructions.index(instr)
|
||
|
|
del self._block.instructions[idx]
|
||
|
|
if self._block.terminator == instr:
|
||
|
|
self._block.terminator = None
|
||
|
|
if self._anchor > idx:
|
||
|
|
self._anchor -= 1
|
||
|
|
|
||
|
|
@contextlib.contextmanager
|
||
|
|
def goto_block(self, block):
|
||
|
|
"""
|
||
|
|
A context manager which temporarily positions the builder at the end
|
||
|
|
of basic block *bb* (but before any terminator).
|
||
|
|
"""
|
||
|
|
old_block = self.basic_block
|
||
|
|
term = block.terminator
|
||
|
|
if term is not None:
|
||
|
|
self.position_before(term)
|
||
|
|
else:
|
||
|
|
self.position_at_end(block)
|
||
|
|
try:
|
||
|
|
yield
|
||
|
|
finally:
|
||
|
|
self.position_at_end(old_block)
|
||
|
|
|
||
|
|
@contextlib.contextmanager
|
||
|
|
def goto_entry_block(self):
|
||
|
|
"""
|
||
|
|
A context manager which temporarily positions the builder at the
|
||
|
|
end of the function's entry block.
|
||
|
|
"""
|
||
|
|
with self.goto_block(self.function.entry_basic_block):
|
||
|
|
yield
|
||
|
|
|
||
|
|
@contextlib.contextmanager
|
||
|
|
def _branch_helper(self, bbenter, bbexit):
|
||
|
|
self.position_at_end(bbenter)
|
||
|
|
yield bbexit
|
||
|
|
if self.basic_block.terminator is None:
|
||
|
|
self.branch(bbexit)
|
||
|
|
|
||
|
|
@contextlib.contextmanager
|
||
|
|
def if_then(self, pred, likely=None):
|
||
|
|
"""
|
||
|
|
A context manager which sets up a conditional basic block based
|
||
|
|
on the given predicate (a i1 value). If the conditional block
|
||
|
|
is not explicitly terminated, a branch will be added to the next
|
||
|
|
block.
|
||
|
|
If *likely* is given, its boolean value indicates whether the
|
||
|
|
predicate is likely to be true or not, and metadata is issued
|
||
|
|
for LLVM's optimizers to account for that.
|
||
|
|
"""
|
||
|
|
bb = self.basic_block
|
||
|
|
bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
|
||
|
|
bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
|
||
|
|
br = self.cbranch(pred, bbif, bbend)
|
||
|
|
if likely is not None:
|
||
|
|
br.set_weights([99, 1] if likely else [1, 99])
|
||
|
|
|
||
|
|
with self._branch_helper(bbif, bbend):
|
||
|
|
yield bbend
|
||
|
|
|
||
|
|
self.position_at_end(bbend)
|
||
|
|
|
||
|
|
@contextlib.contextmanager
|
||
|
|
def if_else(self, pred, likely=None):
|
||
|
|
"""
|
||
|
|
A context manager which sets up two conditional basic blocks based
|
||
|
|
on the given predicate (a i1 value).
|
||
|
|
A tuple of context managers is yield'ed. Each context manager
|
||
|
|
acts as a if_then() block.
|
||
|
|
*likely* has the same meaning as in if_then().
|
||
|
|
|
||
|
|
Typical use::
|
||
|
|
with builder.if_else(pred) as (then, otherwise):
|
||
|
|
with then:
|
||
|
|
# emit instructions for when the predicate is true
|
||
|
|
with otherwise:
|
||
|
|
# emit instructions for when the predicate is false
|
||
|
|
"""
|
||
|
|
bb = self.basic_block
|
||
|
|
bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
|
||
|
|
bbelse = self.append_basic_block(name=_label_suffix(bb.name, '.else'))
|
||
|
|
bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
|
||
|
|
br = self.cbranch(pred, bbif, bbelse)
|
||
|
|
if likely is not None:
|
||
|
|
br.set_weights([99, 1] if likely else [1, 99])
|
||
|
|
|
||
|
|
then = self._branch_helper(bbif, bbend)
|
||
|
|
otherwise = self._branch_helper(bbelse, bbend)
|
||
|
|
|
||
|
|
yield then, otherwise
|
||
|
|
|
||
|
|
self.position_at_end(bbend)
|
||
|
|
|
||
|
|
def _insert(self, instr):
|
||
|
|
if self.debug_metadata is not None and 'dbg' not in instr.metadata:
|
||
|
|
instr.metadata['dbg'] = self.debug_metadata
|
||
|
|
self._block.instructions.insert(self._anchor, instr)
|
||
|
|
self._anchor += 1
|
||
|
|
|
||
|
|
def _set_terminator(self, term):
|
||
|
|
assert not self.block.is_terminated
|
||
|
|
self._insert(term)
|
||
|
|
self.block.terminator = term
|
||
|
|
return term
|
||
|
|
|
||
|
|
#
|
||
|
|
# Arithmetic APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
@_binop('shl')
|
||
|
|
def shl(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Left integer shift:
|
||
|
|
name = lhs << rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('lshr')
|
||
|
|
def lshr(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Logical (unsigned) right integer shift:
|
||
|
|
name = lhs >> rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('ashr')
|
||
|
|
def ashr(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Arithmetic (signed) right integer shift:
|
||
|
|
name = lhs >> rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('add')
|
||
|
|
def add(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Integer addition:
|
||
|
|
name = lhs + rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('fadd')
|
||
|
|
def fadd(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point addition:
|
||
|
|
name = lhs + rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('sub')
|
||
|
|
def sub(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Integer subtraction:
|
||
|
|
name = lhs - rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('fsub')
|
||
|
|
def fsub(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point subtraction:
|
||
|
|
name = lhs - rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('mul')
|
||
|
|
def mul(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Integer multiplication:
|
||
|
|
name = lhs * rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('fmul')
|
||
|
|
def fmul(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point multiplication:
|
||
|
|
name = lhs * rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('udiv')
|
||
|
|
def udiv(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer division:
|
||
|
|
name = lhs / rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('sdiv')
|
||
|
|
def sdiv(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer division:
|
||
|
|
name = lhs / rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('fdiv')
|
||
|
|
def fdiv(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point division:
|
||
|
|
name = lhs / rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('urem')
|
||
|
|
def urem(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer remainder:
|
||
|
|
name = lhs % rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('srem')
|
||
|
|
def srem(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer remainder:
|
||
|
|
name = lhs % rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('frem')
|
||
|
|
def frem(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point remainder:
|
||
|
|
name = lhs % rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('or')
|
||
|
|
def or_(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Bitwise integer OR:
|
||
|
|
name = lhs | rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('and')
|
||
|
|
def and_(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Bitwise integer AND:
|
||
|
|
name = lhs & rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop('xor')
|
||
|
|
def xor(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Bitwise integer XOR:
|
||
|
|
name = lhs ^ rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('sadd')
|
||
|
|
def sadd_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer addition with overflow:
|
||
|
|
name = {result, overflow bit} = lhs + rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('smul')
|
||
|
|
def smul_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer multiplication with overflow:
|
||
|
|
name = {result, overflow bit} = lhs * rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('ssub')
|
||
|
|
def ssub_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer subtraction with overflow:
|
||
|
|
name = {result, overflow bit} = lhs - rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('uadd')
|
||
|
|
def uadd_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer addition with overflow:
|
||
|
|
name = {result, overflow bit} = lhs + rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('umul')
|
||
|
|
def umul_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer multiplication with overflow:
|
||
|
|
name = {result, overflow bit} = lhs * rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_binop_with_overflow('usub')
|
||
|
|
def usub_with_overflow(self, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer subtraction with overflow:
|
||
|
|
name = {result, overflow bit} = lhs - rhs
|
||
|
|
"""
|
||
|
|
|
||
|
|
#
|
||
|
|
# Unary APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
def not_(self, value, name=''):
|
||
|
|
"""
|
||
|
|
Bitwise integer complement:
|
||
|
|
name = ~value
|
||
|
|
"""
|
||
|
|
if isinstance(value.type, types.VectorType):
|
||
|
|
rhs = values.Constant(value.type, (-1,) * value.type.count)
|
||
|
|
else:
|
||
|
|
rhs = values.Constant(value.type, -1)
|
||
|
|
return self.xor(value, rhs, name=name)
|
||
|
|
|
||
|
|
def neg(self, value, name=''):
|
||
|
|
"""
|
||
|
|
Integer negative:
|
||
|
|
name = -value
|
||
|
|
"""
|
||
|
|
return self.sub(values.Constant(value.type, 0), value, name=name)
|
||
|
|
|
||
|
|
@_unop('fneg')
|
||
|
|
def fneg(self, arg, name='', flags=()):
|
||
|
|
"""
|
||
|
|
Floating-point negative:
|
||
|
|
name = -arg
|
||
|
|
"""
|
||
|
|
|
||
|
|
#
|
||
|
|
# Comparison APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
def _icmp(self, prefix, cmpop, lhs, rhs, name):
|
||
|
|
try:
|
||
|
|
op = _CMP_MAP[cmpop]
|
||
|
|
except KeyError:
|
||
|
|
raise ValueError("invalid comparison %r for icmp" % (cmpop,))
|
||
|
|
if cmpop not in ('==', '!='):
|
||
|
|
op = prefix + op
|
||
|
|
instr = instructions.ICMPInstr(self.block, op, lhs, rhs, name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def icmp_signed(self, cmpop, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Signed integer comparison:
|
||
|
|
name = lhs <cmpop> rhs
|
||
|
|
|
||
|
|
where cmpop can be '==', '!=', '<', '<=', '>', '>='
|
||
|
|
"""
|
||
|
|
return self._icmp('s', cmpop, lhs, rhs, name)
|
||
|
|
|
||
|
|
def icmp_unsigned(self, cmpop, lhs, rhs, name=''):
|
||
|
|
"""
|
||
|
|
Unsigned integer (or pointer) comparison:
|
||
|
|
name = lhs <cmpop> rhs
|
||
|
|
|
||
|
|
where cmpop can be '==', '!=', '<', '<=', '>', '>='
|
||
|
|
"""
|
||
|
|
return self._icmp('u', cmpop, lhs, rhs, name)
|
||
|
|
|
||
|
|
def fcmp_ordered(self, cmpop, lhs, rhs, name='', flags=()):
|
||
|
|
"""
|
||
|
|
Floating-point ordered comparison:
|
||
|
|
name = lhs <cmpop> rhs
|
||
|
|
|
||
|
|
where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
|
||
|
|
"""
|
||
|
|
if cmpop in _CMP_MAP:
|
||
|
|
op = 'o' + _CMP_MAP[cmpop]
|
||
|
|
else:
|
||
|
|
op = cmpop
|
||
|
|
instr = instructions.FCMPInstr(
|
||
|
|
self.block, op, lhs, rhs, name=name, flags=flags)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def fcmp_unordered(self, cmpop, lhs, rhs, name='', flags=()):
|
||
|
|
"""
|
||
|
|
Floating-point unordered comparison:
|
||
|
|
name = lhs <cmpop> rhs
|
||
|
|
|
||
|
|
where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
|
||
|
|
"""
|
||
|
|
if cmpop in _CMP_MAP:
|
||
|
|
op = 'u' + _CMP_MAP[cmpop]
|
||
|
|
else:
|
||
|
|
op = cmpop
|
||
|
|
instr = instructions.FCMPInstr(
|
||
|
|
self.block, op, lhs, rhs, name=name, flags=flags)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def select(self, cond, lhs, rhs, name='', flags=()):
|
||
|
|
"""
|
||
|
|
Ternary select operator:
|
||
|
|
name = cond ? lhs : rhs
|
||
|
|
"""
|
||
|
|
instr = instructions.SelectInstr(self.block, cond, lhs, rhs, name=name,
|
||
|
|
flags=flags)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
#
|
||
|
|
# Cast APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
@_castop('trunc')
|
||
|
|
def trunc(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Truncating integer downcast to a smaller type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('zext')
|
||
|
|
def zext(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Zero-extending integer upcast to a larger type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('sext')
|
||
|
|
def sext(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Sign-extending integer upcast to a larger type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('fptrunc')
|
||
|
|
def fptrunc(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point downcast to a less precise type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('fpext')
|
||
|
|
def fpext(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Floating-point upcast to a more precise type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('bitcast')
|
||
|
|
def bitcast(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Pointer cast to a different pointer type:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('addrspacecast')
|
||
|
|
def addrspacecast(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Pointer cast to a different address space:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('fptoui')
|
||
|
|
def fptoui(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Convert floating-point to unsigned integer:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('uitofp')
|
||
|
|
def uitofp(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Convert unsigned integer to floating-point:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('fptosi')
|
||
|
|
def fptosi(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Convert floating-point to signed integer:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('sitofp')
|
||
|
|
def sitofp(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Convert signed integer to floating-point:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('ptrtoint')
|
||
|
|
def ptrtoint(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Cast pointer to integer:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_castop('inttoptr')
|
||
|
|
def inttoptr(self, value, typ, name=''):
|
||
|
|
"""
|
||
|
|
Cast integer to pointer:
|
||
|
|
name = (typ) value
|
||
|
|
"""
|
||
|
|
|
||
|
|
#
|
||
|
|
# Memory APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
def alloca(self, typ, size=None, name=''):
|
||
|
|
"""
|
||
|
|
Stack-allocate a slot for *size* elements of the given type.
|
||
|
|
(default one element)
|
||
|
|
"""
|
||
|
|
if size is None:
|
||
|
|
pass
|
||
|
|
elif isinstance(size, (values.Value, values.Constant)):
|
||
|
|
assert isinstance(size.type, types.IntType)
|
||
|
|
else:
|
||
|
|
# If it is not a Value instance,
|
||
|
|
# assume to be a Python integer.
|
||
|
|
size = values.Constant(types.IntType(32), size)
|
||
|
|
|
||
|
|
al = instructions.AllocaInstr(self.block, typ, size, name)
|
||
|
|
self._insert(al)
|
||
|
|
return al
|
||
|
|
|
||
|
|
def load(self, ptr, name='', align=None):
|
||
|
|
"""
|
||
|
|
Load value from pointer, with optional guaranteed alignment:
|
||
|
|
name = *ptr
|
||
|
|
"""
|
||
|
|
if not isinstance(ptr.type, types.PointerType):
|
||
|
|
msg = "cannot load from value of type %s (%r): not a pointer"
|
||
|
|
raise TypeError(msg % (ptr.type, str(ptr)))
|
||
|
|
ld = instructions.LoadInstr(self.block, ptr, name)
|
||
|
|
ld.align = align
|
||
|
|
self._insert(ld)
|
||
|
|
return ld
|
||
|
|
|
||
|
|
def store(self, value, ptr, align=None):
|
||
|
|
"""
|
||
|
|
Store value to pointer, with optional guaranteed alignment:
|
||
|
|
*ptr = name
|
||
|
|
"""
|
||
|
|
if not isinstance(ptr.type, types.PointerType):
|
||
|
|
msg = "cannot store to value of type %s (%r): not a pointer"
|
||
|
|
raise TypeError(msg % (ptr.type, str(ptr)))
|
||
|
|
if ptr.type.pointee != value.type:
|
||
|
|
raise TypeError("cannot store %s to %s: mismatching types"
|
||
|
|
% (value.type, ptr.type))
|
||
|
|
st = instructions.StoreInstr(self.block, value, ptr)
|
||
|
|
st.align = align
|
||
|
|
self._insert(st)
|
||
|
|
return st
|
||
|
|
|
||
|
|
def load_atomic(self, ptr, ordering, align, name=''):
|
||
|
|
"""
|
||
|
|
Load value from pointer, with optional guaranteed alignment:
|
||
|
|
name = *ptr
|
||
|
|
"""
|
||
|
|
if not isinstance(ptr.type, types.PointerType):
|
||
|
|
msg = "cannot load from value of type %s (%r): not a pointer"
|
||
|
|
raise TypeError(msg % (ptr.type, str(ptr)))
|
||
|
|
ld = instructions.LoadAtomicInstr(
|
||
|
|
self.block, ptr, ordering, align, name)
|
||
|
|
self._insert(ld)
|
||
|
|
return ld
|
||
|
|
|
||
|
|
def store_atomic(self, value, ptr, ordering, align):
|
||
|
|
"""
|
||
|
|
Store value to pointer, with optional guaranteed alignment:
|
||
|
|
*ptr = name
|
||
|
|
"""
|
||
|
|
if not isinstance(ptr.type, types.PointerType):
|
||
|
|
msg = "cannot store to value of type %s (%r): not a pointer"
|
||
|
|
raise TypeError(msg % (ptr.type, str(ptr)))
|
||
|
|
if ptr.type.pointee != value.type:
|
||
|
|
raise TypeError("cannot store %s to %s: mismatching types"
|
||
|
|
% (value.type, ptr.type))
|
||
|
|
st = instructions.StoreAtomicInstr(
|
||
|
|
self.block, value, ptr, ordering, align)
|
||
|
|
self._insert(st)
|
||
|
|
return st
|
||
|
|
|
||
|
|
#
|
||
|
|
# Terminators APIs
|
||
|
|
#
|
||
|
|
|
||
|
|
def switch(self, value, default):
|
||
|
|
"""
|
||
|
|
Create a switch-case with a single *default* target.
|
||
|
|
"""
|
||
|
|
swt = instructions.SwitchInstr(self.block, 'switch', value, default)
|
||
|
|
self._set_terminator(swt)
|
||
|
|
return swt
|
||
|
|
|
||
|
|
def branch(self, target):
|
||
|
|
"""
|
||
|
|
Unconditional branch to *target*.
|
||
|
|
"""
|
||
|
|
br = instructions.Branch(self.block, "br", [target])
|
||
|
|
self._set_terminator(br)
|
||
|
|
return br
|
||
|
|
|
||
|
|
def cbranch(self, cond, truebr, falsebr):
|
||
|
|
"""
|
||
|
|
Conditional branch to *truebr* if *cond* is true, else to *falsebr*.
|
||
|
|
"""
|
||
|
|
br = instructions.ConditionalBranch(self.block, "br",
|
||
|
|
[cond, truebr, falsebr])
|
||
|
|
self._set_terminator(br)
|
||
|
|
return br
|
||
|
|
|
||
|
|
def branch_indirect(self, addr):
|
||
|
|
"""
|
||
|
|
Indirect branch to target *addr*.
|
||
|
|
"""
|
||
|
|
br = instructions.IndirectBranch(self.block, "indirectbr", addr)
|
||
|
|
self._set_terminator(br)
|
||
|
|
return br
|
||
|
|
|
||
|
|
def ret_void(self):
|
||
|
|
"""
|
||
|
|
Return from function without a value.
|
||
|
|
"""
|
||
|
|
return self._set_terminator(
|
||
|
|
instructions.Ret(self.block, "ret void"))
|
||
|
|
|
||
|
|
def ret(self, value):
|
||
|
|
"""
|
||
|
|
Return from function with the given *value*.
|
||
|
|
"""
|
||
|
|
return self._set_terminator(
|
||
|
|
instructions.Ret(self.block, "ret", value))
|
||
|
|
|
||
|
|
def resume(self, landingpad):
|
||
|
|
"""
|
||
|
|
Resume an in-flight exception.
|
||
|
|
"""
|
||
|
|
br = instructions.Branch(self.block, "resume", [landingpad])
|
||
|
|
self._set_terminator(br)
|
||
|
|
return br
|
||
|
|
|
||
|
|
# Call APIs
|
||
|
|
|
||
|
|
def call(self, fn, args, name='', cconv=None, tail=False, fastmath=(),
|
||
|
|
attrs=(), arg_attrs=None):
|
||
|
|
"""
|
||
|
|
Call function *fn* with *args*:
|
||
|
|
name = fn(args...)
|
||
|
|
"""
|
||
|
|
inst = instructions.CallInstr(self.block, fn, args, name=name,
|
||
|
|
cconv=cconv, tail=tail, fastmath=fastmath,
|
||
|
|
attrs=attrs, arg_attrs=arg_attrs)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def asm(self, ftype, asm, constraint, args, side_effect, name=''):
|
||
|
|
"""
|
||
|
|
Inline assembler.
|
||
|
|
"""
|
||
|
|
asm = instructions.InlineAsm(ftype, asm, constraint, side_effect)
|
||
|
|
return self.call(asm, args, name)
|
||
|
|
|
||
|
|
def load_reg(self, reg_type, reg_name, name=''):
|
||
|
|
"""
|
||
|
|
Load a register value into an LLVM value.
|
||
|
|
Example: v = load_reg(IntType(32), "eax")
|
||
|
|
"""
|
||
|
|
ftype = types.FunctionType(reg_type, [])
|
||
|
|
return self.asm(ftype, "", "={%s}" % reg_name, [], False, name)
|
||
|
|
|
||
|
|
def store_reg(self, value, reg_type, reg_name, name=''):
|
||
|
|
"""
|
||
|
|
Store an LLVM value inside a register
|
||
|
|
Example:
|
||
|
|
store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax")
|
||
|
|
"""
|
||
|
|
ftype = types.FunctionType(types.VoidType(), [reg_type])
|
||
|
|
return self.asm(ftype, "", "{%s}" % reg_name, [value], True, name)
|
||
|
|
|
||
|
|
def invoke(self, fn, args, normal_to, unwind_to,
|
||
|
|
name='', cconv=None, fastmath=(), attrs=(), arg_attrs=None):
|
||
|
|
inst = instructions.InvokeInstr(self.block, fn, args, normal_to,
|
||
|
|
unwind_to, name=name, cconv=cconv,
|
||
|
|
fastmath=fastmath, attrs=attrs,
|
||
|
|
arg_attrs=arg_attrs)
|
||
|
|
self._set_terminator(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
# GEP APIs
|
||
|
|
|
||
|
|
def gep(self, ptr, indices, inbounds=False, name=''):
|
||
|
|
"""
|
||
|
|
Compute effective address (getelementptr):
|
||
|
|
name = getelementptr ptr, <indices...>
|
||
|
|
"""
|
||
|
|
instr = instructions.GEPInstr(self.block, ptr, indices,
|
||
|
|
inbounds=inbounds, name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
# Vector Operations APIs
|
||
|
|
|
||
|
|
def extract_element(self, vector, idx, name=''):
|
||
|
|
"""
|
||
|
|
Returns the value at position idx.
|
||
|
|
"""
|
||
|
|
instr = instructions.ExtractElement(self.block, vector, idx, name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def insert_element(self, vector, value, idx, name=''):
|
||
|
|
"""
|
||
|
|
Returns vector with vector[idx] replaced by value.
|
||
|
|
The result is undefined if the idx is larger or equal the vector length.
|
||
|
|
"""
|
||
|
|
instr = instructions.InsertElement(self.block, vector, value, idx,
|
||
|
|
name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def shuffle_vector(self, vector1, vector2, mask, name=''):
|
||
|
|
"""
|
||
|
|
Constructs a permutation of elements from *vector1* and *vector2*.
|
||
|
|
Returns a new vector in the same length of *mask*.
|
||
|
|
|
||
|
|
* *vector1* and *vector2* must have the same element type.
|
||
|
|
* *mask* must be a constant vector of integer types.
|
||
|
|
"""
|
||
|
|
instr = instructions.ShuffleVector(self.block, vector1, vector2, mask,
|
||
|
|
name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
# Aggregate APIs
|
||
|
|
|
||
|
|
def extract_value(self, agg, idx, name=''):
|
||
|
|
"""
|
||
|
|
Extract member number *idx* from aggregate.
|
||
|
|
"""
|
||
|
|
if not isinstance(idx, (tuple, list)):
|
||
|
|
idx = [idx]
|
||
|
|
instr = instructions.ExtractValue(self.block, agg, idx, name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
def insert_value(self, agg, value, idx, name=''):
|
||
|
|
"""
|
||
|
|
Insert *value* into member number *idx* from aggregate.
|
||
|
|
"""
|
||
|
|
if not isinstance(idx, (tuple, list)):
|
||
|
|
idx = [idx]
|
||
|
|
instr = instructions.InsertValue(self.block, agg, value, idx, name=name)
|
||
|
|
self._insert(instr)
|
||
|
|
return instr
|
||
|
|
|
||
|
|
# PHI APIs
|
||
|
|
|
||
|
|
def phi(self, typ, name='', flags=()):
|
||
|
|
inst = instructions.PhiInstr(self.block, typ, name=name, flags=flags)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
# Special API
|
||
|
|
|
||
|
|
def unreachable(self):
|
||
|
|
inst = instructions.Unreachable(self.block)
|
||
|
|
self._set_terminator(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def atomic_rmw(self, op, ptr, val, ordering, name=''):
|
||
|
|
inst = instructions.AtomicRMW(
|
||
|
|
self.block, op, ptr, val, ordering, name=name)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def cmpxchg(self, ptr, cmp, val, ordering, failordering=None, name=''):
|
||
|
|
"""
|
||
|
|
Atomic compared-and-set:
|
||
|
|
atomic {
|
||
|
|
old = *ptr
|
||
|
|
success = (old == cmp)
|
||
|
|
if (success)
|
||
|
|
*ptr = val
|
||
|
|
}
|
||
|
|
name = { old, success }
|
||
|
|
|
||
|
|
If failordering is `None`, the value of `ordering` is used.
|
||
|
|
"""
|
||
|
|
failordering = ordering if failordering is None else failordering
|
||
|
|
inst = instructions.CmpXchg(self.block, ptr, cmp, val, ordering,
|
||
|
|
failordering, name=name)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def landingpad(self, typ, name='', cleanup=False):
|
||
|
|
inst = instructions.LandingPadInstr(self.block, typ, name, cleanup)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def assume(self, cond):
|
||
|
|
"""
|
||
|
|
Optimizer hint: assume *cond* is always true.
|
||
|
|
"""
|
||
|
|
fn = self.module.declare_intrinsic("llvm.assume")
|
||
|
|
return self.call(fn, [cond])
|
||
|
|
|
||
|
|
def fence(self, ordering, targetscope=None, name=''):
|
||
|
|
"""
|
||
|
|
Add a memory barrier, preventing certain reorderings of load and/or
|
||
|
|
store accesses with
|
||
|
|
respect to other processors and devices.
|
||
|
|
"""
|
||
|
|
inst = instructions.Fence(self.block, ordering, targetscope, name=name)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
def comment(self, text):
|
||
|
|
"""
|
||
|
|
Puts a single-line comment into the generated IR. This will be ignored
|
||
|
|
by LLVM, but can be useful for debugging the output of a compiler. Adds
|
||
|
|
a comment to the source file.
|
||
|
|
|
||
|
|
* *text* is a string that does not contain new line characters.
|
||
|
|
"""
|
||
|
|
inst = instructions.Comment(self.block, text)
|
||
|
|
self._insert(inst)
|
||
|
|
return inst
|
||
|
|
|
||
|
|
@_uniop_intrinsic_int("llvm.bswap")
|
||
|
|
def bswap(self, cond):
|
||
|
|
"""
|
||
|
|
Used to byte swap integer values with an even number of bytes (positive
|
||
|
|
multiple of 16 bits)
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_uniop_intrinsic_int("llvm.bitreverse")
|
||
|
|
def bitreverse(self, cond):
|
||
|
|
"""
|
||
|
|
Reverse the bitpattern of an integer value; for example 0b10110110
|
||
|
|
becomes 0b01101101.
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_uniop_intrinsic_int("llvm.ctpop")
|
||
|
|
def ctpop(self, cond):
|
||
|
|
"""
|
||
|
|
Counts the number of bits set in a value.
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_uniop_intrinsic_with_flag("llvm.ctlz")
|
||
|
|
def ctlz(self, cond, flag):
|
||
|
|
"""
|
||
|
|
Counts leading zero bits in *value*. Boolean *flag* indicates whether
|
||
|
|
the result is defined for ``0``.
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_uniop_intrinsic_with_flag("llvm.cttz")
|
||
|
|
def cttz(self, cond, flag):
|
||
|
|
"""
|
||
|
|
Counts trailing zero bits in *value*. Boolean *flag* indicates whether
|
||
|
|
the result is defined for ``0``.
|
||
|
|
"""
|
||
|
|
|
||
|
|
@_triop_intrinsic("llvm.fma")
|
||
|
|
def fma(self, a, b, c):
|
||
|
|
"""
|
||
|
|
Perform the fused multiply-add operation.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def convert_from_fp16(self, a, to=None, name=''):
|
||
|
|
"""
|
||
|
|
Convert from an i16 to the given FP type
|
||
|
|
"""
|
||
|
|
if not to:
|
||
|
|
raise TypeError("expected a float return type")
|
||
|
|
if not isinstance(to, (types.FloatType, types.DoubleType)):
|
||
|
|
raise TypeError("expected a float type, got %s" % to)
|
||
|
|
if not (isinstance(a.type, types.IntType) and a.type.width == 16):
|
||
|
|
raise TypeError("expected an i16 type, got %s" % a.type)
|
||
|
|
|
||
|
|
opname = 'llvm.convert.from.fp16'
|
||
|
|
fn = self.module.declare_intrinsic(opname, [to])
|
||
|
|
return self.call(fn, [a], name)
|
||
|
|
|
||
|
|
@_uniop_intrinsic_float("llvm.convert.to.fp16")
|
||
|
|
def convert_to_fp16(self, a):
|
||
|
|
"""
|
||
|
|
Convert the given FP number to an i16
|
||
|
|
"""
|