Add bswap, popcnt, clz, ctz, cls, and rbit instructions

2 files changed, 50 insertions, 4 deletions

diff --git a/rust/src/low_level_il/expression.rs b/rust/src/low_level_il/expression.rs
index 8103518c..92d57675 100644
--- a/rust/src/low_level_il/expression.rs
+++ b/rust/src/low_level_il/expression.rs
@@ -309,6 +309,12 @@ where
 
     Neg(Operation<'func, M, F, operation::UnaryOp>),
     Not(Operation<'func, M, F, operation::UnaryOp>),
+    Bswap(Operation<'func, M, F, operation::UnaryOp>),
+    Popcnt(Operation<'func, M, F, operation::UnaryOp>),
+    Clz(Operation<'func, M, F, operation::UnaryOp>),
+    Ctz(Operation<'func, M, F, operation::UnaryOp>),
+    Rbit(Operation<'func, M, F, operation::UnaryOp>),
+    Cls(Operation<'func, M, F, operation::UnaryOp>),
     Sx(Operation<'func, M, F, operation::UnaryOp>),
     Zx(Operation<'func, M, F, operation::UnaryOp>),
     LowPart(Operation<'func, M, F, operation::UnaryOp>),
@@ -466,6 +472,12 @@ where
 
             LLIL_NEG => LowLevelILExpressionKind::Neg(Operation::new(function, op, index)),
             LLIL_NOT => LowLevelILExpressionKind::Not(Operation::new(function, op, index)),
+            LLIL_BSWAP => LowLevelILExpressionKind::Bswap(Operation::new(function, op, index)),
+            LLIL_POPCNT => LowLevelILExpressionKind::Popcnt(Operation::new(function, op, index)),
+            LLIL_CLZ => LowLevelILExpressionKind::Clz(Operation::new(function, op, index)),
+            LLIL_CTZ => LowLevelILExpressionKind::Ctz(Operation::new(function, op, index)),
+            LLIL_RBIT => LowLevelILExpressionKind::Rbit(Operation::new(function, op, index)),
+            LLIL_CLS => LowLevelILExpressionKind::Cls(Operation::new(function, op, index)),
 
             LLIL_SX => LowLevelILExpressionKind::Sx(Operation::new(function, op, index)),
             LLIL_ZX => LowLevelILExpressionKind::Zx(Operation::new(function, op, index)),
@@ -620,7 +632,8 @@ where
         use self::LowLevelILExpressionKind::*;
 
         match *self {
-            Neg(ref op) | Not(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
+            Neg(ref op) | Not(ref op) | Bswap(ref op) | Popcnt(ref op) | Clz(ref op) | Ctz(ref op)
+            | Rbit(ref op) | Cls(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
             | BoolToInt(ref op) | Fsqrt(ref op) | Fneg(ref op) | Fabs(ref op)
             | FloatToInt(ref op) | IntToFloat(ref op) | FloatConv(ref op) | RoundToInt(ref op)
             | Floor(ref op) | Ceil(ref op) | Ftrunc(ref op) => Some(op),
@@ -664,7 +677,8 @@ where
                 visit!(op.left());
                 visit!(op.right());
             }
-            Neg(ref op) | Not(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
+            Neg(ref op) | Not(ref op) | Bswap(ref op) | Popcnt(ref op) | Clz(ref op) | Ctz(ref op)
+            | Rbit(ref op) | Cls(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
             | BoolToInt(ref op) | Fsqrt(ref op) | Fneg(ref op) | Fabs(ref op)
             | FloatToInt(ref op) | IntToFloat(ref op) | FloatConv(ref op) | RoundToInt(ref op)
             | Floor(ref op) | Ceil(ref op) | Ftrunc(ref op) => {
@@ -758,7 +772,8 @@ where
 
             DivuDp(ref op) | DivsDp(ref op) | ModuDp(ref op) | ModsDp(ref op) => &op.op,
 
-            Neg(ref op) | Not(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
+            Neg(ref op) | Not(ref op) | Bswap(ref op) | Popcnt(ref op) | Clz(ref op) | Ctz(ref op)
+            | Rbit(ref op) | Cls(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
             | BoolToInt(ref op) | Fsqrt(ref op) | Fneg(ref op) | Fabs(ref op)
             | FloatToInt(ref op) | IntToFloat(ref op) | FloatConv(ref op) | RoundToInt(ref op)
             | Floor(ref op) | Ceil(ref op) | Ftrunc(ref op) => &op.op,
@@ -831,7 +846,8 @@ impl LowLevelILExpressionKind<'_, Mutable, NonSSA> {
 
             DivuDp(ref op) | DivsDp(ref op) | ModuDp(ref op) | ModsDp(ref op) => op.flag_write(),
 
-            Neg(ref op) | Not(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
+            Neg(ref op) | Not(ref op) | Bswap(ref op) | Popcnt(ref op) | Clz(ref op) | Ctz(ref op)
+            | Rbit(ref op) | Cls(ref op) | Sx(ref op) | Zx(ref op) | LowPart(ref op)
             | BoolToInt(ref op) | Fsqrt(ref op) | Fneg(ref op) | Fabs(ref op)
             | FloatToInt(ref op) | IntToFloat(ref op) | FloatConv(ref op) | RoundToInt(ref op)
             | Floor(ref op) | Ceil(ref op) | Ftrunc(ref op) => op.flag_write(),
diff --git a/rust/src/low_level_il/lifting.rs b/rust/src/low_level_il/lifting.rs
index 202c9ed6..ebd6e980 100644
--- a/rust/src/low_level_il/lifting.rs
+++ b/rust/src/low_level_il/lifting.rs
@@ -94,6 +94,12 @@ pub enum LowLevelILFlagWriteOp<R: ArchReg> {
     Push(usize, LowLevelILRegisterOrConstant<R>),
     Neg(usize, LowLevelILRegisterOrConstant<R>),
     Not(usize, LowLevelILRegisterOrConstant<R>),
+    Bswap(usize, LowLevelILRegisterOrConstant<R>),
+    Popcnt(usize, LowLevelILRegisterOrConstant<R>),
+    Clz(usize, LowLevelILRegisterOrConstant<R>),
+    Ctz(usize, LowLevelILRegisterOrConstant<R>),
+    Rbit(usize, LowLevelILRegisterOrConstant<R>),
+    Cls(usize, LowLevelILRegisterOrConstant<R>),
     Sx(usize, LowLevelILRegisterOrConstant<R>),
     Zx(usize, LowLevelILRegisterOrConstant<R>),
     LowPart(usize, LowLevelILRegisterOrConstant<R>),
@@ -293,6 +299,12 @@ impl<R: ArchReg> LowLevelILFlagWriteOp<R> {
             (1, LLIL_PUSH) => op!(Push, 0),
             (1, LLIL_NEG) => op!(Neg, 0),
             (1, LLIL_NOT) => op!(Not, 0),
+            (1, LLIL_BSWAP) => op!(Bswap, 0),
+            (1, LLIL_POPCNT) => op!(Popcnt, 0),
+            (1, LLIL_CLZ) => op!(Clz, 0),
+            (1, LLIL_CTZ) => op!(Ctz, 0),
+            (1, LLIL_RBIT) => op!(Rbit, 0),
+            (1, LLIL_CLS) => op!(Cls, 0),
             (1, LLIL_SX) => op!(Sx, 0),
             (1, LLIL_ZX) => op!(Zx, 0),
             (1, LLIL_LOW_PART) => op!(LowPart, 0),
@@ -351,6 +363,12 @@ impl<R: ArchReg> LowLevelILFlagWriteOp<R> {
             Push(size, ..) => (size, LLIL_PUSH),
             Neg(size, ..) => (size, LLIL_NEG),
             Not(size, ..) => (size, LLIL_NOT),
+            Bswap(size, ..) => (size, LLIL_BSWAP),
+            Popcnt(size, ..) => (size, LLIL_POPCNT),
+            Clz(size, ..) => (size, LLIL_CLZ),
+            Ctz(size, ..) => (size, LLIL_CTZ),
+            Rbit(size, ..) => (size, LLIL_RBIT),
+            Cls(size, ..) => (size, LLIL_CLS),
             Sx(size, ..) => (size, LLIL_SX),
             Zx(size, ..) => (size, LLIL_ZX),
             LowPart(size, ..) => (size, LLIL_LOW_PART),
@@ -404,6 +422,12 @@ impl<R: ArchReg> LowLevelILFlagWriteOp<R> {
             | Push(_, op0)
             | Neg(_, op0)
             | Not(_, op0)
+            | Bswap(_, op0)
+            | Popcnt(_, op0)
+            | Clz(_, op0)
+            | Ctz(_, op0)
+            | Rbit(_, op0)
+            | Cls(_, op0)
             | Sx(_, op0)
             | Zx(_, op0)
             | LowPart(_, op0)
@@ -1422,6 +1446,12 @@ impl LowLevelILMutableFunction {
 
     sized_unary_op_lifter!(neg, LLIL_NEG, ValueExpr);
     sized_unary_op_lifter!(not, LLIL_NOT, ValueExpr);
+    sized_unary_op_lifter!(bswap, LLIL_BSWAP, ValueExpr);
+    sized_unary_op_lifter!(popcnt, LLIL_POPCNT, ValueExpr);
+    sized_unary_op_lifter!(clz, LLIL_CLZ, ValueExpr);
+    sized_unary_op_lifter!(ctz, LLIL_CTZ, ValueExpr);
+    sized_unary_op_lifter!(rbit, LLIL_RBIT, ValueExpr);
+    sized_unary_op_lifter!(cls, LLIL_CLS, ValueExpr);
 
     size_changing_unary_op_lifter!(sx, LLIL_SX, ValueExpr);
     size_changing_unary_op_lifter!(zx, LLIL_ZX, ValueExpr);