angr 9.2.192__cp311-cp311-macosx_10_12_x86_64.whl

angr/engines/pcode/behavior.py

@@ -0,0 +1,998 @@
+from __future__ import annotations
+import operator
+from collections.abc import Callable, Iterable
+
+import claripy
+from claripy.ast.bv import BV
+from pypcode import OpCode
+
+from angr.errors import AngrError
+
+
+# pylint:disable=abstract-method
+
+
+def make_bv_sizes_equal(bv1: BV, bv2: BV, zero_ext: bool = False) -> tuple[BV, BV]:
+    """
+    Makes two BVs equal in length through sign extension.
+    """
+    if bv1.size() < bv2.size():
+        if zero_ext:
+            return (bv1.zero_extend(bv2.size() - bv1.size()), bv2)
+        return (bv1.sign_extend(bv2.size() - bv1.size()), bv2)
+    if bv1.size() > bv2.size():
+        if zero_ext:
+            return (bv1, bv2.zero_extend(bv1.size() - bv2.size()))
+        return (bv1, bv2.sign_extend(bv1.size() - bv2.size()))
+    return (bv1, bv2)
+
+
+# FIXME: Unimplemented ops (mostly floating point related) have associated C++
+# reference code from Ghidra which will need to be ported.
+
+
+class OpBehavior:
+    """
+    Base class for all operation behaviors.
+    """
+
+    __slots__ = ("is_special", "is_unary", "opcode")
+    opcode: OpCode
+    is_unary: bool
+    is_special: bool
+
+    def __init__(self, opcode: OpCode, is_unary: bool, is_special: bool = False) -> None:
+        self.opcode = opcode
+        self.is_unary = is_unary
+        self.is_special = is_special
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:  # pylint:disable=no-self-use
+        raise AngrError("Not implemented!")
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:  # pylint:disable=no-self-use
+        raise AngrError("Not implemented!")
+
+    @staticmethod
+    def generic_compare(args: Iterable[BV], comparison: Callable[[BV, BV], BV]) -> BV:
+        return claripy.If(comparison(args[0], args[1]), claripy.BVV(1, 1), claripy.BVV(0, 1))
+
+    @classmethod
+    def booleanize(cls, in1: BV) -> BV:
+        """
+        Reduce input BV to a single bit of truth: out <- 1 if (in1 != 0) else 0.
+        """
+        return cls.generic_compare((in1, claripy.BVV(0, in1.size())), operator.ne)
+
+
+class OpBehaviorCopy(OpBehavior):
+    """
+    Behavior for the COPY operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.COPY, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return in1
+
+
+class OpBehaviorEqual(OpBehavior):
+    """
+    Behavior for the INT_EQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_EQUAL, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), operator.eq)
+
+
+class OpBehaviorNotEqual(OpBehavior):
+    """
+    Behavior for the INT_NOTEQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_NOTEQUAL, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), operator.ne)
+
+
+class OpBehaviorIntSless(OpBehavior):
+    """
+    Behavior for the INT_SLESS operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SLESS, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), claripy.SLT)
+
+
+class OpBehaviorIntSlessEqual(OpBehavior):
+    """
+    Behavior for the INT_SLESSEQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SLESSEQUAL, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), claripy.SLE)
+
+
+class OpBehaviorIntLess(OpBehavior):
+    """
+    Behavior for the INT_LESS operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_LESS, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), claripy.ULT)
+
+
+class OpBehaviorIntLessEqual(OpBehavior):
+    """
+    Behavior for the INT_LESSEQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_LESSEQUAL, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.generic_compare((in1, in2), claripy.ULE)
+
+
+class OpBehaviorIntZext(OpBehavior):
+    """
+    Behavior for the INT_ZEXT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_ZEXT, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return in1.zero_extend((size_out - size_in) * 8)
+
+
+class OpBehaviorIntSext(OpBehavior):
+    """
+    Behavior for the INT_SEXT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SEXT, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return in1.sign_extend((size_out - size_in) * 8)
+
+
+class OpBehaviorIntAdd(OpBehavior):
+    """
+    Behavior for the INT_ADD operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_ADD, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 + in2
+
+
+class OpBehaviorIntSub(OpBehavior):
+    """
+    Behavior for the INT_SUB operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SUB, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 - in2
+
+
+class OpBehaviorIntCarry(OpBehavior):
+    """
+    Behavior for the INT_CARRY operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_CARRY, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        # origin: ccall.py pc_actions_ADD
+        res = in1 + in2
+        return claripy.If(claripy.ULT(res, in1), claripy.BVV(1, 1), claripy.BVV(0, 1))
+
+
+class OpBehaviorIntScarry(OpBehavior):
+    """
+    Behavior for the INT_SCARRY operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SCARRY, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        res = in1 + in2
+
+        a = (in1 >> (size_in * 8 - 1)) & 1
+        b = (in2 >> (size_in * 8 - 1)) & 1
+        r = (res >> (size_in * 8 - 1)) & 1
+
+        r ^= a
+        a ^= b
+        a ^= 1
+        r &= a
+
+        return r
+
+
+class OpBehaviorIntSborrow(OpBehavior):
+    """
+    Behavior for the INT_SBORROW operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SBORROW, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        res = in1 - in2
+
+        a = (in1 >> (size_in * 8 - 1)) & 1  # Grab sign bit
+        b = (in2 >> (size_in * 8 - 1)) & 1  # Grab sign bit
+        r = (res >> (size_in * 8 - 1)) & 1  # Grab sign bit
+
+        a ^= r
+        r ^= b
+        r ^= 1
+        a &= r
+        return a
+
+
+class OpBehaviorInt2Comp(OpBehavior):
+    """
+    Behavior for the INT_2COMP operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_2COMP, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return -in1
+
+    # uintb OpBehaviorInt2Comp::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   uintb res = uintb_negate(in1-1,size_in);
+    #   return res;
+    # }
+
+
+class OpBehaviorIntNegate(OpBehavior):
+    """
+    Behavior for the INT_NEGATE operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_NEGATE, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return ~in1
+
+
+class OpBehaviorIntXor(OpBehavior):
+    """
+    Behavior for the INT_XOR operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_XOR, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 ^ in2
+
+
+class OpBehaviorIntAnd(OpBehavior):
+    """
+    Behavior for the INT_AND operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_AND, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 & in2
+
+
+class OpBehaviorIntOr(OpBehavior):
+    """
+    Behavior for the INT_OR operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_OR, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 | in2
+
+
+class OpBehaviorIntLeft(OpBehavior):
+    """
+    Behavior for the INT_LEFT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_LEFT, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        in1, in2 = make_bv_sizes_equal(in1, in2)
+        return in1 << in2
+
+
+class OpBehaviorIntRight(OpBehavior):
+    """
+    Behavior for the INT_RIGHT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_RIGHT, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        in1, in2 = make_bv_sizes_equal(in1, in2, zero_ext=True)
+        return in1.LShR(in2)
+
+
+class OpBehaviorIntSright(OpBehavior):
+    """
+    Behavior for the INT_SRIGHT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SRIGHT, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        in1, in2 = make_bv_sizes_equal(in1, in2)
+        return in1 >> in2
+
+
+class OpBehaviorIntMult(OpBehavior):
+    """
+    Behavior for the INT_MULT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_MULT, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1.zero_extend(size_out - size_in) * in2.zero_extend(size_out - size_in)
+
+
+class OpBehaviorIntDiv(OpBehavior):
+    """
+    Behavior for the INT_DIV operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_DIV, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 / in2
+
+
+class OpBehaviorIntSdiv(OpBehavior):
+    """
+    Behavior for the INT_SDIV operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SDIV, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 / in2
+
+    # uintb OpBehaviorIntSdiv::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   if (in2 == 0)
+    #     throw EvaluationError("Divide by 0");
+    #   intb num = in1;               // Convert to signed
+    #   intb denom = in2;
+    #   sign_extend(num,8*size_in-1);
+    #   sign_extend(denom,8*size_in-1);
+    #   intb sres = num/denom;        // Do the signed division
+    #   zero_extend(sres,8*size_out-1); // Cut to appropriate size
+    #   return (uintb)sres;           // Recast as unsigned
+    # }
+
+
+class OpBehaviorIntRem(OpBehavior):
+    """
+    Behavior for the INT_REM operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_REM, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 % in2
+
+
+class OpBehaviorIntSrem(OpBehavior):
+    """
+    Behavior for the INT_SREM operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.INT_SREM, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return in1 % in2
+
+    # uintb OpBehaviorIntSrem::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   if (in2 == 0)
+    #     throw EvaluationError("Remainder by 0");
+    #   intb val = in1;
+    #   intb mod = in2;
+    #   sign_extend(val,8*size_in-1);  // Convert inputs to signed values
+    #   sign_extend(mod,8*size_in-1);
+    #   intb sres = in1 % in2;        // Do the remainder
+    #   zero_extend(sres,8*size_out-1); // Convert back to unsigned
+    #   return (uintb)sres;
+    # }
+
+
+class OpBehaviorBoolNegate(OpBehavior):
+    """
+    Behavior for the BOOL_NEGATE operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.BOOL_NEGATE, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        return self.generic_compare((in1, claripy.BVV(0, in1.size())), operator.eq)
+
+
+class OpBehaviorBoolXor(OpBehavior):
+    """
+    Behavior for the BOOL_XOR operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.BOOL_XOR, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.booleanize(in1) ^ self.booleanize(in2)
+
+
+class OpBehaviorBoolAnd(OpBehavior):
+    """
+    Behavior for the BOOL_AND operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.BOOL_AND, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.booleanize(in1) & self.booleanize(in2)
+
+
+class OpBehaviorBoolOr(OpBehavior):
+    """
+    Behavior for the BOOL_OR operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.BOOL_OR, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        return self.booleanize(in1) | self.booleanize(in2)
+
+
+class OpBehaviorFloatEqual(OpBehavior):
+    """
+    Behavior for the FLOAT_EQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_EQUAL, False)
+
+    # uintb OpBehaviorFloatEqual::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opEqual(in1,in2);
+    # }
+
+
+class OpBehaviorFloatNotEqual(OpBehavior):
+    """
+    Behavior for the FLOAT_NOTEQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_NOTEQUAL, False)
+
+    # uintb OpBehaviorFloatNotEqual::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opNotEqual(in1,in2);
+    # }
+
+
+class OpBehaviorFloatLess(OpBehavior):
+    """
+    Behavior for the FLOAT_LESS operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_LESS, False)
+
+    # uintb OpBehaviorFloatLess::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opLess(in1,in2);
+    # }
+
+
+class OpBehaviorFloatLessEqual(OpBehavior):
+    """
+    Behavior for the FLOAT_LESSEQUAL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_LESSEQUAL, False)
+
+    # uintb OpBehaviorFloatLessEqual::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opLessEqual(in1,in2);
+    # }
+
+
+class OpBehaviorFloatNan(OpBehavior):
+    """
+    Behavior for the FLOAT_NAN operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_NAN, True)
+
+    # uintb OpBehaviorFloatNan::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opNan(in1);
+    # }
+
+
+class OpBehaviorFloatAdd(OpBehavior):
+    """
+    Behavior for the FLOAT_ADD operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_ADD, False)
+
+    # uintb OpBehaviorFloatAdd::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opAdd(in1,in2);
+    # }
+
+
+class OpBehaviorFloatDiv(OpBehavior):
+    """
+    Behavior for the FLOAT_DIV operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_DIV, False)
+
+    # uintb OpBehaviorFloatDiv::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opDiv(in1,in2);
+    # }
+
+
+class OpBehaviorFloatMult(OpBehavior):
+    """
+    Behavior for the FLOAT_MULT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_MULT, False)
+
+    # uintb OpBehaviorFloatMult::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opMult(in1,in2);
+    # }
+
+
+class OpBehaviorFloatSub(OpBehavior):
+    """
+    Behavior for the FLOAT_SUB operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_SUB, False)
+
+    # uintb OpBehaviorFloatSub::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateBinary(size_out,size_in,in1,in2);
+    #
+    #   return format->opSub(in1,in2);
+    # }
+
+
+class OpBehaviorFloatNeg(OpBehavior):
+    """
+    Behavior for the FLOAT_NEG operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_NEG, True)
+
+    # uintb OpBehaviorFloatNeg::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opNeg(in1);
+    # }
+
+
+class OpBehaviorFloatAbs(OpBehavior):
+    """
+    Behavior for the FLOAT_ABS operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_ABS, True)
+
+    # uintb OpBehaviorFloatAbs::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opAbs(in1);
+    # }
+
+
+class OpBehaviorFloatSqrt(OpBehavior):
+    """
+    Behavior for the FLOAT_SQRT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_SQRT, True)
+
+    # uintb OpBehaviorFloatSqrt::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opSqrt(in1);
+    # }
+
+
+class OpBehaviorFloatInt2Float(OpBehavior):
+    """
+    Behavior for the FLOAT_INT2FLOAT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_INT2FLOAT, True)
+
+    # uintb OpBehaviorFloatInt2Float::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_out);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opInt2Float(in1,size_in);
+    # }
+
+
+class OpBehaviorFloatFloat2Float(OpBehavior):
+    """
+    Behavior for the FLOAT_FLOAT2FLOAT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_FLOAT2FLOAT, True)
+
+    # uintb OpBehaviorFloatFloat2Float::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *formatout = translate->getFloatFormat(size_out);
+    #   if (formatout == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #   const FloatFormat *formatin = translate->getFloatFormat(size_in);
+    #   if (formatin == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return formatin->opFloat2Float(in1,*formatout);
+    # }
+
+
+class OpBehaviorFloatTrunc(OpBehavior):
+    """
+    Behavior for the FLOAT_TRUNC operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_TRUNC, True)
+
+    # uintb OpBehaviorFloatTrunc::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opTrunc(in1,size_out);
+    # }
+
+
+class OpBehaviorFloatCeil(OpBehavior):
+    """
+    Behavior for the FLOAT_CEIL operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_CEIL, True)
+
+    # uintb OpBehaviorFloatCeil::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opCeil(in1);
+    # }
+
+
+class OpBehaviorFloatFloor(OpBehavior):
+    """
+    Behavior for the FLOAT_FLOOR operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_FLOOR, True)
+
+    # uintb OpBehaviorFloatFloor::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opFloor(in1);
+    # }
+
+
+class OpBehaviorFloatRound(OpBehavior):
+    """
+    Behavior for the FLOAT_ROUND operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.FLOAT_ROUND, True)
+
+    # uintb OpBehaviorFloatRound::evaluateUnary(int4 size_out,int4 size_in,uintb in1) const
+    #
+    # {
+    #   const FloatFormat *format = translate->getFloatFormat(size_in);
+    #   if (format == (const FloatFormat *)0)
+    #     return OpBehavior::evaluateUnary(size_out,size_in,in1);
+    #
+    #   return format->opRound(in1);
+    # }
+
+
+class OpBehaviorPiece(OpBehavior):
+    """
+    Behavior for the PIECE operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.PIECE, False)
+
+    # uintb OpBehaviorPiece::evaluateBinary(int4 size_out,int4 size_in,uintb in1,uintb in2) const
+    #
+    # {
+    #   uintb res = ( in1<<((size_out-size_in)*8)) | in2;
+    #   return res;
+    # }
+
+
+class OpBehaviorSubpiece(OpBehavior):
+    """
+    Behavior for the SUBPIECE operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.SUBPIECE, False)
+
+    def evaluate_binary(self, size_out: int, size_in: int, in1: BV, in2: BV) -> BV:
+        if in2.size() < in1.size():
+            in2 = in2.sign_extend(in1.size() - in2.size())
+        if in1.size() < in2.size():
+            in1 = in1.sign_extend(in2.size() - in1.size())
+        return (in1 >> (in2 * 8)) & (2 ** (size_out * 8) - 1)
+
+
+class OpBehaviorPopcount(OpBehavior):
+    """
+    Behavior for the POPCOUNT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.POPCOUNT, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        expr = claripy.BVV(0, size_out * 8)
+        for a in range(len(in1)):
+            expr += claripy.Extract(a, a, in1).zero_extend(size_out * 8 - 1)
+        return expr
+
+
+class OpBehaviorLzcount(OpBehavior):
+    """
+    Behavior for the LZCOUNT operation.
+    """
+
+    def __init__(self):
+        super().__init__(OpCode.LZCOUNT, True)
+
+    def evaluate_unary(self, size_out: int, size_in: int, in1: BV) -> BV:
+        expr = claripy.BVV(len(in1), size_out * 8)
+        for pos in range(len(in1)):
+            expr = claripy.If(
+                claripy.Extract(pos, pos, in1) == claripy.BVV(1, 1), claripy.BVV(len(in1) - pos - 1, size_out * 8), expr
+            )
+        return expr
+
+
+class BehaviorFactory:
+    """
+    Returns the behavior object for a given opcode.
+    """
+
+    def __init__(self):
+        self._behaviors = {}
+        if OpCode:
+            self._register_behaviors()
+
+    def get_behavior_for_opcode(self, opcode: OpCode) -> OpBehavior:
+        return self._behaviors[opcode]
+
+    def _register_behaviors(self) -> None:
+        self._behaviors.update(
+            {
+                OpCode.COPY: OpBehaviorCopy(),
+                OpCode.LOAD: OpBehavior(OpCode.LOAD, False, True),
+                OpCode.STORE: OpBehavior(OpCode.STORE, False, True),
+                OpCode.BRANCH: OpBehavior(OpCode.BRANCH, False, True),
+                OpCode.CBRANCH: OpBehavior(OpCode.CBRANCH, False, True),
+                OpCode.BRANCHIND: OpBehavior(OpCode.BRANCHIND, False, True),
+                OpCode.CALL: OpBehavior(OpCode.CALL, False, True),
+                OpCode.CALLIND: OpBehavior(OpCode.CALLIND, False, True),
+                OpCode.CALLOTHER: OpBehavior(OpCode.CALLOTHER, False, True),
+                OpCode.RETURN: OpBehavior(OpCode.RETURN, False, True),
+                OpCode.MULTIEQUAL: OpBehavior(OpCode.MULTIEQUAL, False, True),
+                OpCode.INDIRECT: OpBehavior(OpCode.INDIRECT, False, True),
+                OpCode.PIECE: OpBehaviorPiece(),
+                OpCode.SUBPIECE: OpBehaviorSubpiece(),
+                OpCode.INT_EQUAL: OpBehaviorEqual(),
+                OpCode.INT_NOTEQUAL: OpBehaviorNotEqual(),
+                OpCode.INT_SLESS: OpBehaviorIntSless(),
+                OpCode.INT_SLESSEQUAL: OpBehaviorIntSlessEqual(),
+                OpCode.INT_LESS: OpBehaviorIntLess(),
+                OpCode.INT_LESSEQUAL: OpBehaviorIntLessEqual(),
+                OpCode.INT_ZEXT: OpBehaviorIntZext(),
+                OpCode.INT_SEXT: OpBehaviorIntSext(),
+                OpCode.INT_ADD: OpBehaviorIntAdd(),
+                OpCode.INT_SUB: OpBehaviorIntSub(),
+                OpCode.INT_CARRY: OpBehaviorIntCarry(),
+                OpCode.INT_SCARRY: OpBehaviorIntScarry(),
+                OpCode.INT_SBORROW: OpBehaviorIntSborrow(),
+                OpCode.INT_2COMP: OpBehaviorInt2Comp(),
+                OpCode.INT_NEGATE: OpBehaviorIntNegate(),
+                OpCode.INT_XOR: OpBehaviorIntXor(),
+                OpCode.INT_AND: OpBehaviorIntAnd(),
+                OpCode.INT_OR: OpBehaviorIntOr(),
+                OpCode.INT_LEFT: OpBehaviorIntLeft(),
+                OpCode.INT_RIGHT: OpBehaviorIntRight(),
+                OpCode.INT_SRIGHT: OpBehaviorIntSright(),
+                OpCode.INT_MULT: OpBehaviorIntMult(),
+                OpCode.INT_DIV: OpBehaviorIntDiv(),
+                OpCode.INT_SDIV: OpBehaviorIntSdiv(),
+                OpCode.INT_REM: OpBehaviorIntRem(),
+                OpCode.INT_SREM: OpBehaviorIntSrem(),
+                OpCode.BOOL_NEGATE: OpBehaviorBoolNegate(),
+                OpCode.BOOL_XOR: OpBehaviorBoolXor(),
+                OpCode.BOOL_AND: OpBehaviorBoolAnd(),
+                OpCode.BOOL_OR: OpBehaviorBoolOr(),
+                OpCode.CAST: OpBehavior(OpCode.CAST, False, True),
+                OpCode.PTRADD: OpBehavior(OpCode.PTRADD, False, True),
+                OpCode.PTRSUB: OpBehavior(OpCode.PTRSUB, False, True),
+                OpCode.FLOAT_EQUAL: OpBehaviorFloatEqual(),
+                OpCode.FLOAT_NOTEQUAL: OpBehaviorFloatNotEqual(),
+                OpCode.FLOAT_LESS: OpBehaviorFloatLess(),
+                OpCode.FLOAT_LESSEQUAL: OpBehaviorFloatLessEqual(),
+                OpCode.FLOAT_NAN: OpBehaviorFloatNan(),
+                OpCode.FLOAT_ADD: OpBehaviorFloatAdd(),
+                OpCode.FLOAT_DIV: OpBehaviorFloatDiv(),
+                OpCode.FLOAT_MULT: OpBehaviorFloatMult(),
+                OpCode.FLOAT_SUB: OpBehaviorFloatSub(),
+                OpCode.FLOAT_NEG: OpBehaviorFloatNeg(),
+                OpCode.FLOAT_ABS: OpBehaviorFloatAbs(),
+                OpCode.FLOAT_SQRT: OpBehaviorFloatSqrt(),
+                OpCode.FLOAT_INT2FLOAT: OpBehaviorFloatInt2Float(),
+                OpCode.FLOAT_FLOAT2FLOAT: OpBehaviorFloatFloat2Float(),
+                OpCode.FLOAT_TRUNC: OpBehaviorFloatTrunc(),
+                OpCode.FLOAT_CEIL: OpBehaviorFloatCeil(),
+                OpCode.FLOAT_FLOOR: OpBehaviorFloatFloor(),
+                OpCode.FLOAT_ROUND: OpBehaviorFloatRound(),
+                OpCode.SEGMENTOP: OpBehavior(OpCode.SEGMENTOP, False, True),
+                OpCode.CPOOLREF: OpBehavior(OpCode.CPOOLREF, False, True),
+                OpCode.NEW: OpBehavior(OpCode.NEW, False, True),
+                OpCode.INSERT: OpBehavior(OpCode.INSERT, False, True),
+                OpCode.EXTRACT: OpBehavior(OpCode.EXTRACT, False, True),
+                OpCode.POPCOUNT: OpBehaviorPopcount(),
+                OpCode.LZCOUNT: OpBehaviorLzcount(),
+            }
+        )