Enum ConstValue 

pub enum ConstValue<T: Target> {
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    NativeInt(i64),
    NativeUInt(u64),
    F32(f32),
    F64(f64),
    Vector(Box<[ConstValue<T>]>),
    String(u32),
    DecryptedString(Box<str>),
    Null,
    True,
    False,
    Type(T::TypeRef),
    MethodHandle(T::MethodRef),
    FieldHandle(T::FieldRef),
    DecryptedArray(Box<DecryptedArrayData<T>>),
}

Compile-time constant values tracked through SSA analysis.

Represents all constant forms that can appear in the IR: numeric literals, string references, null, booleans, and runtime handles. Supports constant folding for arithmetic, bitwise, comparison, and conversion operations.

Generic over T: Target so metadata handles (type refs, method refs, field refs) carry the host’s reference types rather than generic placeholders.

Equality

PartialEq/Eq/Hash model structural constant identity: “are these the same constant?”, not “would these compare equal at runtime?”. Floating-point arms are therefore compared and hashed bitwise, which is what makes Eq sound (NaN is reflexive here) and lets constants be used as hash-map keys — global value numbering keys on exactly this.

Two consequences follow, both deliberate:

• F64(NAN) == F64(NAN) is true (identical bit patterns).
• F64(0.0) == F64(-0.0) is false (distinct bit patterns, and distinguishable at runtime via 1.0 / x).

IEEE-754 semantic comparison is a separate operation: use Self::ceq and the c*_un family, which implement CIL/IEEE ordering and unordered semantics.

Variants

I8(i8)

Signed 8-bit integer constant (CIL: int8).

I16(i16)

Signed 16-bit integer constant (CIL: int16).

I32(i32)

Signed 32-bit integer constant (CIL: int32).

I64(i64)

Signed 64-bit integer constant (CIL: int64).

U8(u8)

Unsigned 8-bit integer constant (CIL: uint8).

U16(u16)

Unsigned 16-bit integer constant (CIL: uint16).

U32(u32)

Unsigned 32-bit integer constant (CIL: uint32).

U64(u64)

Unsigned 64-bit integer constant (CIL: uint64).

NativeInt(i64)

Native-size signed integer constant. Width depends on the target pointer size (32-bit or 64-bit). Automatically masked to pointer width by mask_native().

NativeUInt(u64)

Native-size unsigned integer constant. Width depends on the target pointer size.

F32(f32)

32-bit IEEE 754 floating point constant.

F64(f64)

64-bit IEEE 754 floating point constant.

Vector(Box<[ConstValue<T>]>)

Vector constant with one constant per lane.

Boxed so the rarely-used vector arm does not widen every scalar ConstValue.

String(u32)

String constant referenced by its metadata token (index into #US heap). The actual string content is resolved during code generation.

DecryptedString(Box<str>)

Decrypted string with inline content (not just a heap index). Used by deobfuscation passes that decrypt strings at analysis time. Contains the actual string bytes for codegen to emit. Boxed to keep the common scalar ConstValue variants compact.

Null

Null reference constant.

True

Boolean true constant.

False

Boolean false constant.

Type(T::TypeRef)

Runtime type handle (result of typeof() or ldtoken).

MethodHandle(T::MethodRef)

Runtime method handle (result of ldtoken for a method).

FieldHandle(T::FieldRef)

Runtime field handle (result of ldtoken for a field).

DecryptedArray(Box<DecryptedArrayData<T>>)

Decrypted array data from deobfuscation.

Stores the raw bytes and element type of an array that was decrypted at analysis time. Code generation emits newarr + element stores to reconstruct the array in the output. The payload is boxed (see DecryptedArrayData) to keep ConstValue small.

Implementations

impl<T: Target> ConstValue<T>

pub const fn is_null(&self) -> bool

Returns true if this is the null constant.

pub const fn is_bool(&self) -> bool

Returns true if this is a boolean constant.

pub const fn is_integer(&self) -> bool

Returns true if this is an integer constant (signed or unsigned).

pub const fn is_signed(&self) -> bool

Returns true if this is a signed integer constant.

pub const fn is_unsigned(&self) -> bool

Returns true if this is an unsigned integer constant.

pub const fn is_float(&self) -> bool

Returns true if this is a floating-point constant.

pub const fn is_vector(&self) -> bool

Returns true if this is a vector constant.

pub const fn is_string_like(&self) -> bool

Returns true if this value is a string (String or DecryptedString).

pub const fn as_i32(&self) -> Option<i32>

Returns the constant as an i32 if applicable.

pub const fn as_i64(&self) -> Option<i64>

Returns the constant as an i64 if applicable.

pub const fn as_u64(&self) -> Option<u64>

Returns the constant as a u64 if applicable (for unsigned operations).

pub const fn as_u32(&self) -> Option<u32>

Returns the constant as a u32 if applicable (for unsigned operations).

pub const fn as_f32(&self) -> Option<f32>

Returns the constant as an f32 if it’s stored as F32.

pub const fn as_f64(&self) -> Option<f64>

Returns the constant as an f64 if it’s stored as F64.

pub const fn as_bool(&self) -> Option<bool>

Returns the constant as a bool if applicable.

pub const fn from_bool(value: bool) -> Self

Creates a boolean constant from a bool value.

pub fn as_decrypted_string(&self) -> Option<&str>

Returns the string content if this is a DecryptedString.

String variants are heap references and do not carry inline content.

pub const fn is_zero(&self) -> bool

Returns true if this constant represents zero.

This includes all numeric zero values and False. Useful for opaque predicate detection where x ^ x, x - x, x * 0, etc. produce zero.

pub const fn is_one(&self) -> bool

Returns true if this constant represents one.

This includes all numeric one values and True. Useful for identity operations and opaque predicate detection.

pub const fn is_minus_one(&self) -> bool

Returns true if this constant represents negative one (-1).

This is useful for detecting x | -1 = -1 patterns in opaque predicates.

pub const fn is_all_ones(&self) -> bool

Returns true if this constant has all bits set (e.g., -1 for signed, MAX for unsigned).

This is useful for detecting x & -1 = x and x | -1 = -1 patterns.

pub fn integer_of_same_type(&self, value: i64) -> Option<Self>

Returns value as a constant of this constant’s own integer type.

Returns None when self is not an integer, or when value does not fit the target variant. Use this when a rewrite must materialise a new constant alongside an existing one — a mask, a shift amount — so the replacement keeps the width the surrounding IR declares. Hard-coding Self::I32 there silently narrows the type, and mixed-width folds then sign-extend the narrowed operand rather than using the value meant.

Examples

use analyssa::{ir::ConstValue, testing::MockTarget};

let wide: ConstValue<MockTarget> = ConstValue::I64(1 << 32);
assert_eq!(wide.integer_of_same_type(255), Some(ConstValue::I64(255)));

// A value that does not fit the variant is rejected rather than wrapped.
let narrow: ConstValue<MockTarget> = ConstValue::I8(1);
assert_eq!(narrow.integer_of_same_type(1 << 20), None);

pub const fn zero_of_same_type(&self) -> Self

Returns a zero constant of the same type as this constant.

Useful for algebraic simplifications like x * 0 = 0 where the result should preserve the type of the operands.

fn zip_lanes( a: &[Self], b: &[Self], f: impl Fn(&Self, &Self) -> Option<Self>, ) -> Option<Self>

Folds a binary operation lane-wise over two equal-length vector constants, returning None if the lane counts differ or any lane fails to fold. This lifts every scalar fold method (Self::add, Self::mul, …) to SIMD vector constants with no per-op code.

fn map_lanes(a: &[Self], f: impl Fn(&Self) -> Option<Self>) -> Option<Self>

Folds a unary operation lane-wise over a vector constant, returning None if any lane fails to fold.

pub fn negate(&self, ptr_size: PointerSize) -> Option<Self>

Attempts to negate this constant.

pub fn bitwise_not(&self, ptr_size: PointerSize) -> Option<Self>

Attempts to perform bitwise NOT on this constant.

pub fn bitwise_and(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to perform bitwise AND on two constants.

pub fn bitwise_or(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to perform bitwise OR on two constants.

pub fn bitwise_xor(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to perform bitwise XOR on two constants.

fn integer_bits(&self, ptr_size: PointerSize) -> Option<u32>

Returns this constant’s bit width, for the integer arms.

NativeInt/NativeUInt report the target’s pointer width; everything non-integral reports None.

fn shift_distance(amount: &Self, bits: u32) -> Option<u32>

Returns the shift distance if it is representable and in range for a value of bits width, or None to decline the fold.

SsaOp::Shl/Shr document only dest = value << amount and define no out-of-range behaviour, and real ISAs disagree about it — x86 masks the count by 31 (63 with REX.W) regardless of the destination’s sub-register width, while AArch64 and RISC-V mask by the register width. Rust’s wrapping_shl masks by the value’s own type, so an I8 arm masked by 7: shl bl, 8 is 0 on hardware, but folding U8(0x81) << 8 returned U8(0x81) — a third semantics that matches neither.

Declining to fold is sound under every convention, so an out-of-range or negative count is simply not folded.

pub fn shl(&self, amount: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to shift left.

Returns None when the shift distance is negative or at least the value’s own width — see shift_distance for why declining is the only convention-independent answer.

pub fn shr( &self, amount: &Self, unsigned: bool, ptr_size: PointerSize, ) -> Option<Self>

Attempts to shift right (arithmetic for signed, logical for unsigned).

Returns None when the shift distance is negative or at least the value’s own width — see shift_distance.

pub fn add(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to add two constants.

pub fn sub(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to subtract two constants.

pub fn mul(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to multiply two constants.

pub fn add_checked( &self, other: &Self, unsigned: bool, ptr_size: PointerSize, ) -> Option<Self>

Attempts to add two constants with overflow checking.

Returns None if the addition would overflow. When unsigned is true, operands are treated as unsigned for overflow detection.

pub fn sub_checked( &self, other: &Self, unsigned: bool, ptr_size: PointerSize, ) -> Option<Self>

Attempts to subtract two constants with overflow checking.

Returns None if the subtraction would overflow. When unsigned is true, operands are treated as unsigned for overflow detection.

pub fn mul_checked( &self, other: &Self, unsigned: bool, ptr_size: PointerSize, ) -> Option<Self>

Attempts to multiply two constants with overflow checking.

Returns None if the multiplication would overflow. When unsigned is true, operands are treated as unsigned for overflow detection.

pub fn div(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to divide two constants. Uses checked_div/checked_rem so MIN/-1 overflows fold to None rather than wrapping silently.

pub fn rem(&self, other: &Self, ptr_size: PointerSize) -> Option<Self>

Attempts to compute remainder (modulo) of two constants. Uses checked_rem so MIN%-1 overflows fold to None.

pub fn ceq(&self, other: &Self) -> Option<Self>

Attempts to compare two constants for equality.

pub fn clt(&self, other: &Self) -> Option<Self>

Attempts to compare two constants for less-than (signed).

pub fn clt_un(&self, other: &Self) -> Option<Self>

Attempts to compare two constants for less-than (unsigned).

pub fn cgt(&self, other: &Self) -> Option<Self>

Attempts to compare two constants for greater-than (signed).

pub fn cgt_un(&self, other: &Self) -> Option<Self>

Attempts to compare two constants for greater-than (unsigned).

pub fn mask_native(self, ptr_size: PointerSize) -> Self

Masks a ConstValue to the target pointer width.

For NativeInt, sign-extends from 32-bit on Bit32. For NativeUInt, zero-extends from 32-bit on Bit32. All other variants are returned unchanged.

pub fn to_bytes( &self, endianness: Endianness, ptr_size: PointerSize, ) -> Option<Vec<u8>>

Serializes an integer constant to bytes in the given endianness.

Returns None for non-integer variants (floats, strings, handles, etc.).

Examples

use analyssa::{ir::value::ConstValue, target::Endianness, MockTarget, PointerSize};

let val = ConstValue::<MockTarget>::U32(0x01020304);
let le = val.to_bytes(Endianness::Little, PointerSize::Bit64).unwrap();
let be = val.to_bytes(Endianness::Big, PointerSize::Bit64).unwrap();
assert_eq!(le, vec![0x04, 0x03, 0x02, 0x01]);
assert_eq!(be, vec![0x01, 0x02, 0x03, 0x04]);

// A native-width value follows the target's pointer size, not `u64`.
let native = ConstValue::<MockTarget>::NativeUInt(0x0102_0304);
assert_eq!(native.to_bytes(Endianness::Little, PointerSize::Bit32).unwrap().len(), 4);
assert_eq!(native.to_bytes(Endianness::Little, PointerSize::Bit64).unwrap().len(), 8);

pub fn from_bytes(bytes: &[u8], endianness: Endianness) -> Option<Self>

Deserializes a byte slice into an unsigned integer constant.

The byte slice is interpreted as an unsigned integer in the given endianness. The variant is chosen based on the slice length:

Length	Variant
1	U8
2	U16
4	U32
8	U64

Returns None for other slice lengths.

Examples

use analyssa::{ir::value::ConstValue, target::Endianness, MockTarget};

let be_bytes = vec![0x01, 0x02, 0x03, 0x04];
let val = ConstValue::<MockTarget>::from_bytes(&be_bytes, Endianness::Big);
assert_eq!(val, Some(ConstValue::U32(0x01020304)));

impl<T: Target> ConstValue<T>

pub fn convert_to( &self, target: &T::Type, unsigned_source: bool, ptr_bytes: u32, ) -> Option<Self>

Converts this constant to a different type. Forwards to Target::convert_const; non-CIL hosts that don’t override the hook always observe None.

pub fn convert_to_checked( &self, target: &T::Type, unsigned_source: bool, ptr_bytes: u32, ) -> Option<Self>

Converts this constant with overflow checking. Forwards to Target::convert_const_checked.

Trait Implementations

impl<T: Clone + Target> Clone for ConstValue<T>

where T::TypeRef: Clone, T::MethodRef: Clone, T::FieldRef: Clone,

fn clone(&self) -> ConstValue<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Target> Debug for ConstValue<T>

where T::TypeRef: Debug, T::MethodRef: Debug, T::FieldRef: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T: Target> Deserialize<'de> for ConstValue<T>

where T::TypeRef: Deserialize<'de>, T::MethodRef: Deserialize<'de>, T::FieldRef: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Target> Display for ConstValue<T>

where T::TypeRef: Display, T::MethodRef: Display, T::FieldRef: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Target> Eq for ConstValue<T>

Structural identity is reflexive: the float arms compare bitwise, so NaN == NaN holds here even though IEEE-754 says otherwise.

impl<T: Target> From<ConstValue<T>> for SymbolicExpr<T>

fn from(value: ConstValue<T>) -> Self

Converts to this type from the input type.

impl<T: Target> Hash for ConstValue<T>

fn hash<H: Hasher>(&self, state: &mut H)

Hashes the constant consistently with PartialEq: the arm followed by its payload, with floats hashed by their bit pattern.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Target> PartialEq for ConstValue<T>

fn eq(&self, other: &Self) -> bool

Compares two constants for structural identity.

Constants of different arms are never equal, even when they denote the same mathematical value (I32(4) != I64(4)) — the arm is part of the constant’s identity. Floats compare bitwise; see the type-level documentation for why.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: Target> Serialize for ConstValue<T>

where T::TypeRef: Serialize, T::MethodRef: Serialize, T::FieldRef: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.