| 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 |
|
|
| |
| |
| |
|
|
| @_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 |
| """ |
|
|
| |
| |
| |
|
|
| 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 |
| """ |
|
|
| |
| |
| |
|
|
| 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 |
|
|
| |
| |
| |
|
|
| @_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 |
| """ |
|
|
| |
| |
| |
|
|
| 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: |
| |
| |
| 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 |
|
|
| |
| |
| |
|
|
| 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 |
|
|
| |
|
|
| 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 |
|
|
| |
|
|
| 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 |
|
|
| |
|
|
| 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 |
|
|
| |
|
|
| 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 |
|
|
| |
|
|
| def phi(self, typ, name='', flags=()): |
| inst = instructions.PhiInstr(self.block, typ, name=name, flags=flags) |
| self._insert(inst) |
| return inst |
|
|
| |
|
|
| 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 |
| """ |
|
|
