DeCarabas/oden
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
oden/third-party/vendor/gimli/src/read/op.rs
John Doty 977e3c17e5 Vendor things
2024-03-08 11:03:01 -08:00

4140 lines
141 KiB
Rust
Raw Blame History

//! Functions for parsing and evaluating DWARF expressions.
#[cfg(feature = "read")]
use alloc::vec::Vec;
use core::mem;
use super::util::{ArrayLike, ArrayVec};
use crate::common::{DebugAddrIndex, DebugInfoOffset, Encoding, Register};
use crate::constants;
use crate::read::{Error, Reader, ReaderOffset, Result, StoreOnHeap, UnitOffset, Value, ValueType};
/// A reference to a DIE, either relative to the current CU or
/// relative to the section.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DieReference<T = usize> {
/// A CU-relative reference.
UnitRef(UnitOffset<T>),
/// A section-relative reference.
DebugInfoRef(DebugInfoOffset<T>),
}
/// A single decoded DWARF expression operation.
///
/// DWARF expression evaluation is done in two parts: first the raw
/// bytes of the next part of the expression are decoded; and then the
/// decoded operation is evaluated. This approach lets other
/// consumers inspect the DWARF expression without reimplementing the
/// decoding operation.
///
/// Multiple DWARF opcodes may decode into a single `Operation`. For
/// example, both `DW_OP_deref` and `DW_OP_xderef` are represented
/// using `Operation::Deref`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Operation<R, Offset = <R as Reader>::Offset>
where
R: Reader<Offset = Offset>,
Offset: ReaderOffset,
{
/// Dereference the topmost value of the stack.
Deref {
/// The DIE of the base type or 0 to indicate the generic type
base_type: UnitOffset<Offset>,
/// The size of the data to dereference.
size: u8,
/// True if the dereference operation takes an address space
/// argument from the stack; false otherwise.
space: bool,
},
/// Drop an item from the stack.
Drop,
/// Pick an item from the stack and push it on top of the stack.
/// This operation handles `DW_OP_pick`, `DW_OP_dup`, and
/// `DW_OP_over`.
Pick {
/// The index, from the top of the stack, of the item to copy.
index: u8,
},
/// Swap the top two stack items.
Swap,
/// Rotate the top three stack items.
Rot,
/// Take the absolute value of the top of the stack.
Abs,
/// Bitwise `and` of the top two values on the stack.
And,
/// Divide the top two values on the stack.
Div,
/// Subtract the top two values on the stack.
Minus,
/// Modulus of the top two values on the stack.
Mod,
/// Multiply the top two values on the stack.
Mul,
/// Negate the top of the stack.
Neg,
/// Bitwise `not` of the top of the stack.
Not,
/// Bitwise `or` of the top two values on the stack.
Or,
/// Add the top two values on the stack.
Plus,
/// Add a constant to the topmost value on the stack.
PlusConstant {
/// The value to add.
value: u64,
},
/// Logical left shift of the 2nd value on the stack by the number
/// of bits given by the topmost value on the stack.
Shl,
/// Right shift of the 2nd value on the stack by the number of
/// bits given by the topmost value on the stack.
Shr,
/// Arithmetic left shift of the 2nd value on the stack by the
/// number of bits given by the topmost value on the stack.
Shra,
/// Bitwise `xor` of the top two values on the stack.
Xor,
/// Branch to the target location if the top of stack is nonzero.
Bra {
/// The relative offset to the target bytecode.
target: i16,
},
/// Compare the top two stack values for equality.
Eq,
/// Compare the top two stack values using `>=`.
Ge,
/// Compare the top two stack values using `>`.
Gt,
/// Compare the top two stack values using `<=`.
Le,
/// Compare the top two stack values using `<`.
Lt,
/// Compare the top two stack values using `!=`.
Ne,
/// Unconditional branch to the target location.
Skip {
/// The relative offset to the target bytecode.
target: i16,
},
/// Push an unsigned constant value on the stack. This handles multiple
/// DWARF opcodes.
UnsignedConstant {
/// The value to push.
value: u64,
},
/// Push a signed constant value on the stack. This handles multiple
/// DWARF opcodes.
SignedConstant {
/// The value to push.
value: i64,
},
/// Indicate that this piece's location is in the given register.
///
/// Completes the piece or expression.
Register {
/// The register number.
register: Register,
},
/// Find the value of the given register, add the offset, and then
/// push the resulting sum on the stack.
RegisterOffset {
/// The register number.
register: Register,
/// The offset to add.
offset: i64,
/// The DIE of the base type or 0 to indicate the generic type
base_type: UnitOffset<Offset>,
},
/// Compute the frame base (using `DW_AT_frame_base`), add the
/// given offset, and then push the resulting sum on the stack.
FrameOffset {
/// The offset to add.
offset: i64,
},
/// No operation.
Nop,
/// Push the object address on the stack.
PushObjectAddress,
/// Evaluate a DWARF expression as a subroutine. The expression
/// comes from the `DW_AT_location` attribute of the indicated
/// DIE.
Call {
/// The DIE to use.
offset: DieReference<Offset>,
},
/// Compute the address of a thread-local variable and push it on
/// the stack.
TLS,
/// Compute the call frame CFA and push it on the stack.
CallFrameCFA,
/// Terminate a piece.
Piece {
/// The size of this piece in bits.
size_in_bits: u64,
/// The bit offset of this piece. If `None`, then this piece
/// was specified using `DW_OP_piece` and should start at the
/// next byte boundary.
bit_offset: Option<u64>,
},
/// The object has no location, but has a known constant value.
///
/// Represents `DW_OP_implicit_value`.
/// Completes the piece or expression.
ImplicitValue {
/// The implicit value to use.
data: R,
},
/// The object has no location, but its value is at the top of the stack.
///
/// Represents `DW_OP_stack_value`.
/// Completes the piece or expression.
StackValue,
/// The object is a pointer to a value which has no actual location,
/// such as an implicit value or a stack value.
///
/// Represents `DW_OP_implicit_pointer`.
/// Completes the piece or expression.
ImplicitPointer {
/// The `.debug_info` offset of the value that this is an implicit pointer into.
value: DebugInfoOffset<Offset>,
/// The byte offset into the value that the implicit pointer points to.
byte_offset: i64,
},
/// Evaluate an expression at the entry to the current subprogram, and push it on the stack.
///
/// Represents `DW_OP_entry_value`.
EntryValue {
/// The expression to be evaluated.
expression: R,
},
/// This represents a parameter that was optimized out.
///
/// The offset points to the definition of the parameter, and is
/// matched to the `DW_TAG_GNU_call_site_parameter` in the caller that also
/// points to the same definition of the parameter.
///
/// Represents `DW_OP_GNU_parameter_ref`.
ParameterRef {
/// The DIE to use.
offset: UnitOffset<Offset>,
},
/// Relocate the address if needed, and push it on the stack.
///
/// Represents `DW_OP_addr`.
Address {
/// The offset to add.
address: u64,
},
/// Read the address at the given index in `.debug_addr, relocate the address if needed,
/// and push it on the stack.
///
/// Represents `DW_OP_addrx`.
AddressIndex {
/// The index of the address in `.debug_addr`.
index: DebugAddrIndex<Offset>,
},
/// Read the address at the given index in `.debug_addr, and push it on the stack.
/// Do not relocate the address.
///
/// Represents `DW_OP_constx`.
ConstantIndex {
/// The index of the address in `.debug_addr`.
index: DebugAddrIndex<Offset>,
},
/// Interpret the value bytes as a constant of a given type, and push it on the stack.
///
/// Represents `DW_OP_const_type`.
TypedLiteral {
/// The DIE of the base type.
base_type: UnitOffset<Offset>,
/// The value bytes.
value: R,
},
/// Pop the top stack entry, convert it to a different type, and push it on the stack.
///
/// Represents `DW_OP_convert`.
Convert {
/// The DIE of the base type.
base_type: UnitOffset<Offset>,
},
/// Pop the top stack entry, reinterpret the bits in its value as a different type,
/// and push it on the stack.
///
/// Represents `DW_OP_reinterpret`.
Reinterpret {
/// The DIE of the base type.
base_type: UnitOffset<Offset>,
},
/// The index of a local in the currently executing function.
///
/// Represents `DW_OP_WASM_location 0x00`.
/// Completes the piece or expression.
WasmLocal {
/// The index of the local.
index: u32,
},
/// The index of a global.
///
/// Represents `DW_OP_WASM_location 0x01` or `DW_OP_WASM_location 0x03`.
/// Completes the piece or expression.
WasmGlobal {
/// The index of the global.
index: u32,
},
/// The index of an item on the operand stack.
///
/// Represents `DW_OP_WASM_location 0x02`.
/// Completes the piece or expression.
WasmStack {
/// The index of the stack item. 0 is the bottom of the operand stack.
index: u32,
},
}
#[derive(Debug)]
enum OperationEvaluationResult<R: Reader> {
Piece,
Incomplete,
Complete { location: Location<R> },
Waiting(EvaluationWaiting<R>, EvaluationResult<R>),
}
/// A single location of a piece of the result of a DWARF expression.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Location<R, Offset = <R as Reader>::Offset>
where
R: Reader<Offset = Offset>,
Offset: ReaderOffset,
{
/// The piece is empty. Ordinarily this means the piece has been
/// optimized away.
Empty,
/// The piece is found in a register.
Register {
/// The register number.
register: Register,
},
/// The piece is found in memory.
Address {
/// The address.
address: u64,
},
/// The piece has no location but its value is known.
Value {
/// The value.
value: Value,
},
/// The piece is represented by some constant bytes.
Bytes {
/// The value.
value: R,
},
/// The piece is a pointer to a value which has no actual location.
ImplicitPointer {
/// The `.debug_info` offset of the value that this is an implicit pointer into.
value: DebugInfoOffset<Offset>,
/// The byte offset into the value that the implicit pointer points to.
byte_offset: i64,
},
}
impl<R, Offset> Location<R, Offset>
where
R: Reader<Offset = Offset>,
Offset: ReaderOffset,
{
/// Return true if the piece is empty.
pub fn is_empty(&self) -> bool {
matches!(*self, Location::Empty)
}
}
/// The description of a single piece of the result of a DWARF
/// expression.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Piece<R, Offset = <R as Reader>::Offset>
where
R: Reader<Offset = Offset>,
Offset: ReaderOffset,
{
/// If given, the size of the piece in bits. If `None`, there
/// must be only one piece whose size is all of the object.
pub size_in_bits: Option<u64>,
/// If given, the bit offset of the piece within the location.
/// If the location is a `Location::Register` or `Location::Value`,
/// then this offset is from the least significant bit end of
/// the register or value.
/// If the location is a `Location::Address` then the offset uses
/// the bit numbering and direction conventions of the language
/// and target system.
///
/// If `None`, the piece starts at the location. If the
/// location is a register whose size is larger than the piece,
/// then placement within the register is defined by the ABI.
pub bit_offset: Option<u64>,
/// Where this piece is to be found.
pub location: Location<R, Offset>,
}
// A helper function to handle branch offsets.
fn compute_pc<R: Reader>(pc: &R, bytecode: &R, offset: i16) -> Result<R> {
let pc_offset = pc.offset_from(bytecode);
let new_pc_offset = pc_offset.wrapping_add(R::Offset::from_i16(offset));
if new_pc_offset > bytecode.len() {
Err(Error::BadBranchTarget(new_pc_offset.into_u64()))
} else {
let mut new_pc = bytecode.clone();
new_pc.skip(new_pc_offset)?;
Ok(new_pc)
}
}
fn generic_type<O: ReaderOffset>() -> UnitOffset<O> {
UnitOffset(O::from_u64(0).unwrap())
}
impl<R, Offset> Operation<R, Offset>
where
R: Reader<Offset = Offset>,
Offset: ReaderOffset,
{
/// Parse a single DWARF expression operation.
///
/// This is useful when examining a DWARF expression for reasons other
/// than direct evaluation.
///
/// `bytes` points to a the operation to decode. It should point into
/// the same array as `bytecode`, which should be the entire
/// expression.
pub fn parse(bytes: &mut R, encoding: Encoding) -> Result<Operation<R, Offset>> {
let opcode = bytes.read_u8()?;
let name = constants::DwOp(opcode);
match name {
constants::DW_OP_addr => {
let address = bytes.read_address(encoding.address_size)?;
Ok(Operation::Address { address })
}
constants::DW_OP_deref => Ok(Operation::Deref {
base_type: generic_type(),
size: encoding.address_size,
space: false,
}),
constants::DW_OP_const1u => {
let value = bytes.read_u8()?;
Ok(Operation::UnsignedConstant {
value: u64::from(value),
})
}
constants::DW_OP_const1s => {
let value = bytes.read_i8()?;
Ok(Operation::SignedConstant {
value: i64::from(value),
})
}
constants::DW_OP_const2u => {
let value = bytes.read_u16()?;
Ok(Operation::UnsignedConstant {
value: u64::from(value),
})
}
constants::DW_OP_const2s => {
let value = bytes.read_i16()?;
Ok(Operation::SignedConstant {
value: i64::from(value),
})
}
constants::DW_OP_const4u => {
let value = bytes.read_u32()?;
Ok(Operation::UnsignedConstant {
value: u64::from(value),
})
}
constants::DW_OP_const4s => {
let value = bytes.read_i32()?;
Ok(Operation::SignedConstant {
value: i64::from(value),
})
}
constants::DW_OP_const8u => {
let value = bytes.read_u64()?;
Ok(Operation::UnsignedConstant { value })
}
constants::DW_OP_const8s => {
let value = bytes.read_i64()?;
Ok(Operation::SignedConstant { value })
}
constants::DW_OP_constu => {
let value = bytes.read_uleb128()?;
Ok(Operation::UnsignedConstant { value })
}
constants::DW_OP_consts => {
let value = bytes.read_sleb128()?;
Ok(Operation::SignedConstant { value })
}
constants::DW_OP_dup => Ok(Operation::Pick { index: 0 }),
constants::DW_OP_drop => Ok(Operation::Drop),
constants::DW_OP_over => Ok(Operation::Pick { index: 1 }),
constants::DW_OP_pick => {
let value = bytes.read_u8()?;
Ok(Operation::Pick { index: value })
}
constants::DW_OP_swap => Ok(Operation::Swap),
constants::DW_OP_rot => Ok(Operation::Rot),
constants::DW_OP_xderef => Ok(Operation::Deref {
base_type: generic_type(),
size: encoding.address_size,
space: true,
}),
constants::DW_OP_abs => Ok(Operation::Abs),
constants::DW_OP_and => Ok(Operation::And),
constants::DW_OP_div => Ok(Operation::Div),
constants::DW_OP_minus => Ok(Operation::Minus),
constants::DW_OP_mod => Ok(Operation::Mod),
constants::DW_OP_mul => Ok(Operation::Mul),
constants::DW_OP_neg => Ok(Operation::Neg),
constants::DW_OP_not => Ok(Operation::Not),
constants::DW_OP_or => Ok(Operation::Or),
constants::DW_OP_plus => Ok(Operation::Plus),
constants::DW_OP_plus_uconst => {
let value = bytes.read_uleb128()?;
Ok(Operation::PlusConstant { value })
}
constants::DW_OP_shl => Ok(Operation::Shl),
constants::DW_OP_shr => Ok(Operation::Shr),
constants::DW_OP_shra => Ok(Operation::Shra),
constants::DW_OP_xor => Ok(Operation::Xor),
constants::DW_OP_bra => {
let target = bytes.read_i16()?;
Ok(Operation::Bra { target })
}
constants::DW_OP_eq => Ok(Operation::Eq),
constants::DW_OP_ge => Ok(Operation::Ge),
constants::DW_OP_gt => Ok(Operation::Gt),
constants::DW_OP_le => Ok(Operation::Le),
constants::DW_OP_lt => Ok(Operation::Lt),
constants::DW_OP_ne => Ok(Operation::Ne),
constants::DW_OP_skip => {
let target = bytes.read_i16()?;
Ok(Operation::Skip { target })
}
constants::DW_OP_lit0
| constants::DW_OP_lit1
| constants::DW_OP_lit2
| constants::DW_OP_lit3
| constants::DW_OP_lit4
| constants::DW_OP_lit5
| constants::DW_OP_lit6
| constants::DW_OP_lit7
| constants::DW_OP_lit8
| constants::DW_OP_lit9
| constants::DW_OP_lit10
| constants::DW_OP_lit11
| constants::DW_OP_lit12
| constants::DW_OP_lit13
| constants::DW_OP_lit14
| constants::DW_OP_lit15
| constants::DW_OP_lit16
| constants::DW_OP_lit17
| constants::DW_OP_lit18
| constants::DW_OP_lit19
| constants::DW_OP_lit20
| constants::DW_OP_lit21
| constants::DW_OP_lit22
| constants::DW_OP_lit23
| constants::DW_OP_lit24
| constants::DW_OP_lit25
| constants::DW_OP_lit26
| constants::DW_OP_lit27
| constants::DW_OP_lit28
| constants::DW_OP_lit29
| constants::DW_OP_lit30
| constants::DW_OP_lit31 => Ok(Operation::UnsignedConstant {
value: (opcode - constants::DW_OP_lit0.0).into(),
}),
constants::DW_OP_reg0
| constants::DW_OP_reg1
| constants::DW_OP_reg2
| constants::DW_OP_reg3
| constants::DW_OP_reg4
| constants::DW_OP_reg5
| constants::DW_OP_reg6
| constants::DW_OP_reg7
| constants::DW_OP_reg8
| constants::DW_OP_reg9
| constants::DW_OP_reg10
| constants::DW_OP_reg11
| constants::DW_OP_reg12
| constants::DW_OP_reg13
| constants::DW_OP_reg14
| constants::DW_OP_reg15
| constants::DW_OP_reg16
| constants::DW_OP_reg17
| constants::DW_OP_reg18
| constants::DW_OP_reg19
| constants::DW_OP_reg20
| constants::DW_OP_reg21
| constants::DW_OP_reg22
| constants::DW_OP_reg23
| constants::DW_OP_reg24
| constants::DW_OP_reg25
| constants::DW_OP_reg26
| constants::DW_OP_reg27
| constants::DW_OP_reg28
| constants::DW_OP_reg29
| constants::DW_OP_reg30
| constants::DW_OP_reg31 => Ok(Operation::Register {
register: Register((opcode - constants::DW_OP_reg0.0).into()),
}),
constants::DW_OP_breg0
| constants::DW_OP_breg1
| constants::DW_OP_breg2
| constants::DW_OP_breg3
| constants::DW_OP_breg4
| constants::DW_OP_breg5
| constants::DW_OP_breg6
| constants::DW_OP_breg7
| constants::DW_OP_breg8
| constants::DW_OP_breg9
| constants::DW_OP_breg10
| constants::DW_OP_breg11
| constants::DW_OP_breg12
| constants::DW_OP_breg13
| constants::DW_OP_breg14
| constants::DW_OP_breg15
| constants::DW_OP_breg16
| constants::DW_OP_breg17
| constants::DW_OP_breg18
| constants::DW_OP_breg19
| constants::DW_OP_breg20
| constants::DW_OP_breg21
| constants::DW_OP_breg22
| constants::DW_OP_breg23
| constants::DW_OP_breg24
| constants::DW_OP_breg25
| constants::DW_OP_breg26
| constants::DW_OP_breg27
| constants::DW_OP_breg28
| constants::DW_OP_breg29
| constants::DW_OP_breg30
| constants::DW_OP_breg31 => {
let value = bytes.read_sleb128()?;
Ok(Operation::RegisterOffset {
register: Register((opcode - constants::DW_OP_breg0.0).into()),
offset: value,
base_type: generic_type(),
})
}
constants::DW_OP_regx => {
let register = bytes.read_uleb128().and_then(Register::from_u64)?;
Ok(Operation::Register { register })
}
constants::DW_OP_fbreg => {
let value = bytes.read_sleb128()?;
Ok(Operation::FrameOffset { offset: value })
}
constants::DW_OP_bregx => {
let register = bytes.read_uleb128().and_then(Register::from_u64)?;
let offset = bytes.read_sleb128()?;
Ok(Operation::RegisterOffset {
register,
offset,
base_type: generic_type(),
})
}
constants::DW_OP_piece => {
let size = bytes.read_uleb128()?;
Ok(Operation::Piece {
size_in_bits: 8 * size,
bit_offset: None,
})
}
constants::DW_OP_deref_size => {
let size = bytes.read_u8()?;
Ok(Operation::Deref {
base_type: generic_type(),
size,
space: false,
})
}
constants::DW_OP_xderef_size => {
let size = bytes.read_u8()?;
Ok(Operation::Deref {
base_type: generic_type(),
size,
space: true,
})
}
constants::DW_OP_nop => Ok(Operation::Nop),
constants::DW_OP_push_object_address => Ok(Operation::PushObjectAddress),
constants::DW_OP_call2 => {
let value = bytes.read_u16().map(R::Offset::from_u16)?;
Ok(Operation::Call {
offset: DieReference::UnitRef(UnitOffset(value)),
})
}
constants::DW_OP_call4 => {
let value = bytes.read_u32().map(R::Offset::from_u32)?;
Ok(Operation::Call {
offset: DieReference::UnitRef(UnitOffset(value)),
})
}
constants::DW_OP_call_ref => {
let value = bytes.read_offset(encoding.format)?;
Ok(Operation::Call {
offset: DieReference::DebugInfoRef(DebugInfoOffset(value)),
})
}
constants::DW_OP_form_tls_address | constants::DW_OP_GNU_push_tls_address => {
Ok(Operation::TLS)
}
constants::DW_OP_call_frame_cfa => Ok(Operation::CallFrameCFA),
constants::DW_OP_bit_piece => {
let size = bytes.read_uleb128()?;
let offset = bytes.read_uleb128()?;
Ok(Operation::Piece {
size_in_bits: size,
bit_offset: Some(offset),
})
}
constants::DW_OP_implicit_value => {
let len = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
let data = bytes.split(len)?;
Ok(Operation::ImplicitValue { data })
}
constants::DW_OP_stack_value => Ok(Operation::StackValue),
constants::DW_OP_implicit_pointer | constants::DW_OP_GNU_implicit_pointer => {
let value = if encoding.version == 2 {
bytes
.read_address(encoding.address_size)
.and_then(Offset::from_u64)?
} else {
bytes.read_offset(encoding.format)?
};
let byte_offset = bytes.read_sleb128()?;
Ok(Operation::ImplicitPointer {
value: DebugInfoOffset(value),
byte_offset,
})
}
constants::DW_OP_addrx | constants::DW_OP_GNU_addr_index => {
let index = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::AddressIndex {
index: DebugAddrIndex(index),
})
}
constants::DW_OP_constx | constants::DW_OP_GNU_const_index => {
let index = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::ConstantIndex {
index: DebugAddrIndex(index),
})
}
constants::DW_OP_entry_value | constants::DW_OP_GNU_entry_value => {
let len = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
let expression = bytes.split(len)?;
Ok(Operation::EntryValue { expression })
}
constants::DW_OP_GNU_parameter_ref => {
let value = bytes.read_u32().map(R::Offset::from_u32)?;
Ok(Operation::ParameterRef {
offset: UnitOffset(value),
})
}
constants::DW_OP_const_type | constants::DW_OP_GNU_const_type => {
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
let len = bytes.read_u8()?;
let value = bytes.split(R::Offset::from_u8(len))?;
Ok(Operation::TypedLiteral {
base_type: UnitOffset(base_type),
value,
})
}
constants::DW_OP_regval_type | constants::DW_OP_GNU_regval_type => {
let register = bytes.read_uleb128().and_then(Register::from_u64)?;
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::RegisterOffset {
register,
offset: 0,
base_type: UnitOffset(base_type),
})
}
constants::DW_OP_deref_type | constants::DW_OP_GNU_deref_type => {
let size = bytes.read_u8()?;
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::Deref {
base_type: UnitOffset(base_type),
size,
space: false,
})
}
constants::DW_OP_xderef_type => {
let size = bytes.read_u8()?;
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::Deref {
base_type: UnitOffset(base_type),
size,
space: true,
})
}
constants::DW_OP_convert | constants::DW_OP_GNU_convert => {
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::Convert {
base_type: UnitOffset(base_type),
})
}
constants::DW_OP_reinterpret | constants::DW_OP_GNU_reinterpret => {
let base_type = bytes.read_uleb128().and_then(R::Offset::from_u64)?;
Ok(Operation::Reinterpret {
base_type: UnitOffset(base_type),
})
}
constants::DW_OP_WASM_location => match bytes.read_u8()? {
0x0 => {
let index = bytes.read_uleb128_u32()?;
Ok(Operation::WasmLocal { index })
}
0x1 => {
let index = bytes.read_uleb128_u32()?;
Ok(Operation::WasmGlobal { index })
}
0x2 => {
let index = bytes.read_uleb128_u32()?;
Ok(Operation::WasmStack { index })
}
0x3 => {
let index = bytes.read_u32()?;
Ok(Operation::WasmGlobal { index })
}
_ => Err(Error::InvalidExpression(name)),
},
_ => Err(Error::InvalidExpression(name)),
}
}
}
#[derive(Debug)]
enum EvaluationState<R: Reader> {
Start(Option<u64>),
Ready,
Error(Error),
Complete,
Waiting(EvaluationWaiting<R>),
}
#[derive(Debug)]
enum EvaluationWaiting<R: Reader> {
Memory,
Register { offset: i64 },
FrameBase { offset: i64 },
Tls,
Cfa,
AtLocation,
EntryValue,
ParameterRef,
RelocatedAddress,
IndexedAddress,
TypedLiteral { value: R },
Convert,
Reinterpret,
}
/// The state of an `Evaluation` after evaluating a DWARF expression.
/// The evaluation is either `Complete`, or it requires more data
/// to continue, as described by the variant.
#[derive(Debug, PartialEq)]
pub enum EvaluationResult<R: Reader> {
/// The `Evaluation` is complete, and `Evaluation::result()` can be called.
Complete,
/// The `Evaluation` needs a value from memory to proceed further. Once the
/// caller determines what value to provide it should resume the `Evaluation`
/// by calling `Evaluation::resume_with_memory`.
RequiresMemory {
/// The address of the value required.
address: u64,
/// The size of the value required. This is guaranteed to be at most the
/// word size of the target architecture.
size: u8,
/// If not `None`, a target-specific address space value.
space: Option<u64>,
/// The DIE of the base type or 0 to indicate the generic type
base_type: UnitOffset<R::Offset>,
},
/// The `Evaluation` needs a value from a register to proceed further. Once
/// the caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_register`.
RequiresRegister {
/// The register number.
register: Register,
/// The DIE of the base type or 0 to indicate the generic type
base_type: UnitOffset<R::Offset>,
},
/// The `Evaluation` needs the frame base address to proceed further. Once
/// the caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_frame_base`. The frame
/// base address is the address produced by the location description in the
/// `DW_AT_frame_base` attribute of the current function.
RequiresFrameBase,
/// The `Evaluation` needs a value from TLS to proceed further. Once the
/// caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_tls`.
RequiresTls(u64),
/// The `Evaluation` needs the CFA to proceed further. Once the caller
/// determines what value to provide it should resume the `Evaluation` by
/// calling `Evaluation::resume_with_call_frame_cfa`.
RequiresCallFrameCfa,
/// The `Evaluation` needs the DWARF expression at the given location to
/// proceed further. Once the caller determines what value to provide it
/// should resume the `Evaluation` by calling
/// `Evaluation::resume_with_at_location`.
RequiresAtLocation(DieReference<R::Offset>),
/// The `Evaluation` needs the value produced by evaluating a DWARF
/// expression at the entry point of the current subprogram. Once the
/// caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_entry_value`.
RequiresEntryValue(Expression<R>),
/// The `Evaluation` needs the value of the parameter at the given location
/// in the current function's caller. Once the caller determines what value
/// to provide it should resume the `Evaluation` by calling
/// `Evaluation::resume_with_parameter_ref`.
RequiresParameterRef(UnitOffset<R::Offset>),
/// The `Evaluation` needs an address to be relocated to proceed further.
/// Once the caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_relocated_address`.
RequiresRelocatedAddress(u64),
/// The `Evaluation` needs an address from the `.debug_addr` section.
/// This address may also need to be relocated.
/// Once the caller determines what value to provide it should resume the
/// `Evaluation` by calling `Evaluation::resume_with_indexed_address`.
RequiresIndexedAddress {
/// The index of the address in the `.debug_addr` section,
/// relative to the `DW_AT_addr_base` of the compilation unit.
index: DebugAddrIndex<R::Offset>,
/// Whether the address also needs to be relocated.
relocate: bool,
},
/// The `Evaluation` needs the `ValueType` for the base type DIE at
/// the give unit offset. Once the caller determines what value to provide it
/// should resume the `Evaluation` by calling
/// `Evaluation::resume_with_base_type`.
RequiresBaseType(UnitOffset<R::Offset>),
}
/// The bytecode for a DWARF expression or location description.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Expression<R: Reader>(pub R);
impl<R: Reader> Expression<R> {
/// Create an evaluation for this expression.
///
/// The `encoding` is determined by the
/// [`CompilationUnitHeader`](struct.CompilationUnitHeader.html) or
/// [`TypeUnitHeader`](struct.TypeUnitHeader.html) that this expression
/// relates to.
///
/// # Examples
/// ```rust,no_run
/// use gimli::Expression;
/// # let endian = gimli::LittleEndian;
/// # let debug_info = gimli::DebugInfo::from(gimli::EndianSlice::new(&[], endian));
/// # let unit = debug_info.units().next().unwrap().unwrap();
/// # let bytecode = gimli::EndianSlice::new(&[], endian);
/// let expression = gimli::Expression(bytecode);
/// let mut eval = expression.evaluation(unit.encoding());
/// let mut result = eval.evaluate().unwrap();
/// ```
#[cfg(feature = "read")]
#[inline]
pub fn evaluation(self, encoding: Encoding) -> Evaluation<R> {
Evaluation::new(self.0, encoding)
}
/// Return an iterator for the operations in the expression.
pub fn operations(self, encoding: Encoding) -> OperationIter<R> {
OperationIter {
input: self.0,
encoding,
}
}
}
/// An iterator for the operations in an expression.
#[derive(Debug, Clone, Copy)]
pub struct OperationIter<R: Reader> {
input: R,
encoding: Encoding,
}
impl<R: Reader> OperationIter<R> {
/// Read the next operation in an expression.
pub fn next(&mut self) -> Result<Option<Operation<R>>> {
if self.input.is_empty() {
return Ok(None);
}
match Operation::parse(&mut self.input, self.encoding) {
Ok(op) => Ok(Some(op)),
Err(e) => {
self.input.empty();
Err(e)
}
}
}
/// Return the current byte offset of the iterator.
pub fn offset_from(&self, expression: &Expression<R>) -> R::Offset {
self.input.offset_from(&expression.0)
}
}
#[cfg(feature = "fallible-iterator")]
impl<R: Reader> fallible_iterator::FallibleIterator for OperationIter<R> {
type Item = Operation<R>;
type Error = Error;
fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
OperationIter::next(self)
}
}
/// Specification of what storage should be used for [`Evaluation`].
///
#[cfg_attr(
feature = "read",
doc = "
Normally you would only need to use [`StoreOnHeap`], which places the stacks and the results
on the heap using [`Vec`]. This is the default storage type parameter for [`Evaluation`].
"
)]
///
/// If you need to avoid [`Evaluation`] from allocating memory, e.g. for signal safety,
/// you can provide you own storage specification:
/// ```rust,no_run
/// # use gimli::*;
/// # let bytecode = EndianSlice::new(&[], LittleEndian);
/// # let encoding = unimplemented!();
/// # let get_register_value = |_, _| Value::Generic(42);
/// # let get_frame_base = || 0xdeadbeef;
/// #
/// struct StoreOnStack;
///
/// impl<R: Reader> EvaluationStorage<R> for StoreOnStack {
/// type Stack = [Value; 64];
/// type ExpressionStack = [(R, R); 4];
/// type Result = [Piece<R>; 1];
/// }
///
/// let mut eval = Evaluation::<_, StoreOnStack>::new_in(bytecode, encoding);
/// let mut result = eval.evaluate().unwrap();
/// while result != EvaluationResult::Complete {
/// match result {
/// EvaluationResult::RequiresRegister { register, base_type } => {
/// let value = get_register_value(register, base_type);
/// result = eval.resume_with_register(value).unwrap();
/// },
/// EvaluationResult::RequiresFrameBase => {
/// let frame_base = get_frame_base();
/// result = eval.resume_with_frame_base(frame_base).unwrap();
/// },
/// _ => unimplemented!(),
/// };
/// }
///
/// let result = eval.as_result();
/// println!("{:?}", result);
/// ```
pub trait EvaluationStorage<R: Reader> {
/// The storage used for the evaluation stack.
type Stack: ArrayLike<Item = Value>;
/// The storage used for the expression stack.
type ExpressionStack: ArrayLike<Item = (R, R)>;
/// The storage used for the results.
type Result: ArrayLike<Item = Piece<R>>;
}
#[cfg(feature = "read")]
impl<R: Reader> EvaluationStorage<R> for StoreOnHeap {
type Stack = Vec<Value>;
type ExpressionStack = Vec<(R, R)>;
type Result = Vec<Piece<R>>;
}
/// A DWARF expression evaluator.
///
/// # Usage
/// A DWARF expression may require additional data to produce a final result,
/// such as the value of a register or a memory location. Once initial setup
/// is complete (i.e. `set_initial_value()`, `set_object_address()`) the
/// consumer calls the `evaluate()` method. That returns an `EvaluationResult`,
/// which is either `EvaluationResult::Complete` or a value indicating what
/// data is needed to resume the `Evaluation`. The consumer is responsible for
/// producing that data and resuming the computation with the correct method,
/// as documented for `EvaluationResult`. Only once an `EvaluationResult::Complete`
/// is returned can the consumer call `result()`.
///
/// This design allows the consumer of `Evaluation` to decide how and when to
/// produce the required data and resume the computation. The `Evaluation` can
/// be driven synchronously (as shown below) or by some asynchronous mechanism
/// such as futures.
///
/// # Examples
/// ```rust,no_run
/// use gimli::{Evaluation, EvaluationResult, Expression};
/// # let bytecode = gimli::EndianSlice::new(&[], gimli::LittleEndian);
/// # let encoding = unimplemented!();
/// # let get_register_value = |_, _| gimli::Value::Generic(42);
/// # let get_frame_base = || 0xdeadbeef;
///
/// let mut eval = Evaluation::new(bytecode, encoding);
/// let mut result = eval.evaluate().unwrap();
/// while result != EvaluationResult::Complete {
/// match result {
/// EvaluationResult::RequiresRegister { register, base_type } => {
/// let value = get_register_value(register, base_type);
/// result = eval.resume_with_register(value).unwrap();
/// },
/// EvaluationResult::RequiresFrameBase => {
/// let frame_base = get_frame_base();
/// result = eval.resume_with_frame_base(frame_base).unwrap();
/// },
/// _ => unimplemented!(),
/// };
/// }
///
/// let result = eval.result();
/// println!("{:?}", result);
/// ```
#[derive(Debug)]
pub struct Evaluation<R: Reader, S: EvaluationStorage<R> = StoreOnHeap> {
bytecode: R,
encoding: Encoding,
object_address: Option<u64>,
max_iterations: Option<u32>,
iteration: u32,
state: EvaluationState<R>,
// Stack operations are done on word-sized values. We do all
// operations on 64-bit values, and then mask the results
// appropriately when popping.
addr_mask: u64,
// The stack.
stack: ArrayVec<S::Stack>,
// The next operation to decode and evaluate.
pc: R,
// If we see a DW_OP_call* operation, the previous PC and bytecode
// is stored here while evaluating the subroutine.
expression_stack: ArrayVec<S::ExpressionStack>,
value_result: Option<Value>,
result: ArrayVec<S::Result>,
}
#[cfg(feature = "read")]
impl<R: Reader> Evaluation<R> {
/// Create a new DWARF expression evaluator.
///
/// The new evaluator is created without an initial value, without
/// an object address, and without a maximum number of iterations.
pub fn new(bytecode: R, encoding: Encoding) -> Self {
Self::new_in(bytecode, encoding)
}
/// Get the result of this `Evaluation`.
///
/// # Panics
/// Panics if this `Evaluation` has not been driven to completion.
pub fn result(self) -> Vec<Piece<R>> {
match self.state {
EvaluationState::Complete => self.result.into_vec(),
_ => {
panic!("Called `Evaluation::result` on an `Evaluation` that has not been completed")
}
}
}
}
impl<R: Reader, S: EvaluationStorage<R>> Evaluation<R, S> {
/// Create a new DWARF expression evaluator.
///
/// The new evaluator is created without an initial value, without
/// an object address, and without a maximum number of iterations.
pub fn new_in(bytecode: R, encoding: Encoding) -> Self {
let pc = bytecode.clone();
Evaluation {
bytecode,
encoding,
object_address: None,
max_iterations: None,
iteration: 0,
state: EvaluationState::Start(None),
addr_mask: if encoding.address_size == 8 {
!0u64
} else {
(1 << (8 * u64::from(encoding.address_size))) - 1
},
stack: Default::default(),
expression_stack: Default::default(),
pc,
value_result: None,
result: Default::default(),
}
}
/// Set an initial value to be pushed on the DWARF expression
/// evaluator's stack. This can be used in cases like
/// `DW_AT_vtable_elem_location`, which require a value on the
/// stack before evaluation commences. If no initial value is
/// set, and the expression uses an opcode requiring the initial
/// value, then evaluation will fail with an error.
///
/// # Panics
/// Panics if `set_initial_value()` has already been called, or if
/// `evaluate()` has already been called.
pub fn set_initial_value(&mut self, value: u64) {
match self.state {
EvaluationState::Start(None) => {
self.state = EvaluationState::Start(Some(value));
}
_ => panic!(
"`Evaluation::set_initial_value` was called twice, or after evaluation began."
),
};
}
/// Set the enclosing object's address, as used by
/// `DW_OP_push_object_address`. If no object address is set, and
/// the expression uses an opcode requiring the object address,
/// then evaluation will fail with an error.
pub fn set_object_address(&mut self, value: u64) {
self.object_address = Some(value);
}
/// Set the maximum number of iterations to be allowed by the
/// expression evaluator.
///
/// An iteration corresponds approximately to the evaluation of a
/// single operation in an expression ("approximately" because the
/// implementation may allow two such operations in some cases).
/// The default is not to have a maximum; once set, it's not
/// possible to go back to this default state. This value can be
/// set to avoid denial of service attacks by bad DWARF bytecode.
pub fn set_max_iterations(&mut self, value: u32) {
self.max_iterations = Some(value);
}
fn pop(&mut self) -> Result<Value> {
match self.stack.pop() {
Some(value) => Ok(value),
None => Err(Error::NotEnoughStackItems),
}
}
fn push(&mut self, value: Value) -> Result<()> {
self.stack.try_push(value).map_err(|_| Error::StackFull)
}
fn evaluate_one_operation(&mut self) -> Result<OperationEvaluationResult<R>> {
let operation = Operation::parse(&mut self.pc, self.encoding)?;
match operation {
Operation::Deref {
base_type,
size,
space,
} => {
let entry = self.pop()?;
let addr = entry.to_u64(self.addr_mask)?;
let addr_space = if space {
let entry = self.pop()?;
let value = entry.to_u64(self.addr_mask)?;
Some(value)
} else {
None
};
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Memory,
EvaluationResult::RequiresMemory {
address: addr,
size,
space: addr_space,
base_type,
},
));
}
Operation::Drop => {
self.pop()?;
}
Operation::Pick { index } => {
let len = self.stack.len();
let index = index as usize;
if index >= len {
return Err(Error::NotEnoughStackItems);
}
let value = self.stack[len - index - 1];
self.push(value)?;
}
Operation::Swap => {
let top = self.pop()?;
let next = self.pop()?;
self.push(top)?;
self.push(next)?;
}
Operation::Rot => {
let one = self.pop()?;
let two = self.pop()?;
let three = self.pop()?;
self.push(one)?;
self.push(three)?;
self.push(two)?;
}
Operation::Abs => {
let value = self.pop()?;
let result = value.abs(self.addr_mask)?;
self.push(result)?;
}
Operation::And => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.and(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Div => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.div(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Minus => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.sub(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Mod => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.rem(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Mul => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.mul(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Neg => {
let v = self.pop()?;
let result = v.neg(self.addr_mask)?;
self.push(result)?;
}
Operation::Not => {
let value = self.pop()?;
let result = value.not(self.addr_mask)?;
self.push(result)?;
}
Operation::Or => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.or(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Plus => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.add(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::PlusConstant { value } => {
let lhs = self.pop()?;
let rhs = Value::from_u64(lhs.value_type(), value)?;
let result = lhs.add(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Shl => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.shl(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Shr => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.shr(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Shra => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.shra(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Xor => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.xor(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Bra { target } => {
let entry = self.pop()?;
let v = entry.to_u64(self.addr_mask)?;
if v != 0 {
self.pc = compute_pc(&self.pc, &self.bytecode, target)?;
}
}
Operation::Eq => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.eq(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Ge => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.ge(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Gt => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.gt(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Le => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.le(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Lt => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.lt(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Ne => {
let rhs = self.pop()?;
let lhs = self.pop()?;
let result = lhs.ne(rhs, self.addr_mask)?;
self.push(result)?;
}
Operation::Skip { target } => {
self.pc = compute_pc(&self.pc, &self.bytecode, target)?;
}
Operation::UnsignedConstant { value } => {
self.push(Value::Generic(value))?;
}
Operation::SignedConstant { value } => {
self.push(Value::Generic(value as u64))?;
}
Operation::RegisterOffset {
register,
offset,
base_type,
} => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Register { offset },
EvaluationResult::RequiresRegister {
register,
base_type,
},
));
}
Operation::FrameOffset { offset } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::FrameBase { offset },
EvaluationResult::RequiresFrameBase,
));
}
Operation::Nop => {}
Operation::PushObjectAddress => {
if let Some(value) = self.object_address {
self.push(Value::Generic(value))?;
} else {
return Err(Error::InvalidPushObjectAddress);
}
}
Operation::Call { offset } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::AtLocation,
EvaluationResult::RequiresAtLocation(offset),
));
}
Operation::TLS => {
let entry = self.pop()?;
let index = entry.to_u64(self.addr_mask)?;
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Tls,
EvaluationResult::RequiresTls(index),
));
}
Operation::CallFrameCFA => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Cfa,
EvaluationResult::RequiresCallFrameCfa,
));
}
Operation::Register { register } => {
let location = Location::Register { register };
return Ok(OperationEvaluationResult::Complete { location });
}
Operation::ImplicitValue { ref data } => {
let location = Location::Bytes {
value: data.clone(),
};
return Ok(OperationEvaluationResult::Complete { location });
}
Operation::StackValue => {
let value = self.pop()?;
let location = Location::Value { value };
return Ok(OperationEvaluationResult::Complete { location });
}
Operation::ImplicitPointer { value, byte_offset } => {
let location = Location::ImplicitPointer { value, byte_offset };
return Ok(OperationEvaluationResult::Complete { location });
}
Operation::EntryValue { ref expression } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::EntryValue,
EvaluationResult::RequiresEntryValue(Expression(expression.clone())),
));
}
Operation::ParameterRef { offset } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::ParameterRef,
EvaluationResult::RequiresParameterRef(offset),
));
}
Operation::Address { address } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::RelocatedAddress,
EvaluationResult::RequiresRelocatedAddress(address),
));
}
Operation::AddressIndex { index } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::IndexedAddress,
EvaluationResult::RequiresIndexedAddress {
index,
relocate: true,
},
));
}
Operation::ConstantIndex { index } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::IndexedAddress,
EvaluationResult::RequiresIndexedAddress {
index,
relocate: false,
},
));
}
Operation::Piece {
size_in_bits,
bit_offset,
} => {
let location = if self.stack.is_empty() {
Location::Empty
} else {
let entry = self.pop()?;
let address = entry.to_u64(self.addr_mask)?;
Location::Address { address }
};
self.result
.try_push(Piece {
size_in_bits: Some(size_in_bits),
bit_offset,
location,
})
.map_err(|_| Error::StackFull)?;
return Ok(OperationEvaluationResult::Piece);
}
Operation::TypedLiteral { base_type, value } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::TypedLiteral { value },
EvaluationResult::RequiresBaseType(base_type),
));
}
Operation::Convert { base_type } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Convert,
EvaluationResult::RequiresBaseType(base_type),
));
}
Operation::Reinterpret { base_type } => {
return Ok(OperationEvaluationResult::Waiting(
EvaluationWaiting::Reinterpret,
EvaluationResult::RequiresBaseType(base_type),
));
}
Operation::WasmLocal { .. }
| Operation::WasmGlobal { .. }
| Operation::WasmStack { .. } => {
return Err(Error::UnsupportedEvaluation);
}
}
Ok(OperationEvaluationResult::Incomplete)
}
/// Get the result if this is an evaluation for a value.
///
/// Returns `None` if the evaluation contained operations that are only
/// valid for location descriptions.
///
/// # Panics
/// Panics if this `Evaluation` has not been driven to completion.
pub fn value_result(&self) -> Option<Value> {
match self.state {
EvaluationState::Complete => self.value_result,
_ => {
panic!("Called `Evaluation::value_result` on an `Evaluation` that has not been completed")
}
}
}
/// Get the result of this `Evaluation`.
///
/// # Panics
/// Panics if this `Evaluation` has not been driven to completion.
pub fn as_result(&self) -> &[Piece<R>] {
match self.state {
EvaluationState::Complete => &self.result,
_ => {
panic!(
"Called `Evaluation::as_result` on an `Evaluation` that has not been completed"
)
}
}
}
/// Evaluate a DWARF expression. This method should only ever be called
/// once. If the returned `EvaluationResult` is not
/// `EvaluationResult::Complete`, the caller should provide the required
/// value and resume the evaluation by calling the appropriate resume_with
/// method on `Evaluation`.
pub fn evaluate(&mut self) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Start(initial_value) => {
if let Some(value) = initial_value {
self.push(Value::Generic(value))?;
}
self.state = EvaluationState::Ready;
}
EvaluationState::Ready => {}
EvaluationState::Error(err) => return Err(err),
EvaluationState::Complete => return Ok(EvaluationResult::Complete),
EvaluationState::Waiting(_) => panic!(),
};
match self.evaluate_internal() {
Ok(r) => Ok(r),
Err(e) => {
self.state = EvaluationState::Error(e);
Err(e)
}
}
}
/// Resume the `Evaluation` with the provided memory `value`. This will apply
/// the provided memory value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresMemory`.
pub fn resume_with_memory(&mut self, value: Value) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::Memory) => {
self.push(value)?;
}
_ => panic!(
"Called `Evaluation::resume_with_memory` without a preceding `EvaluationResult::RequiresMemory`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `register` value. This will apply
/// the provided register value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresRegister`.
pub fn resume_with_register(&mut self, value: Value) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::Register { offset }) => {
let offset = Value::from_u64(value.value_type(), offset as u64)?;
let value = value.add(offset, self.addr_mask)?;
self.push(value)?;
}
_ => panic!(
"Called `Evaluation::resume_with_register` without a preceding `EvaluationResult::RequiresRegister`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `frame_base`. This will
/// apply the provided frame base value to the evaluation and continue
/// evaluating opcodes until the evaluation is completed, reaches an error,
/// or needs more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresFrameBase`.
pub fn resume_with_frame_base(&mut self, frame_base: u64) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::FrameBase { offset }) => {
self.push(Value::Generic(frame_base.wrapping_add(offset as u64)))?;
}
_ => panic!(
"Called `Evaluation::resume_with_frame_base` without a preceding `EvaluationResult::RequiresFrameBase`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `value`. This will apply
/// the provided TLS value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresTls`.
pub fn resume_with_tls(&mut self, value: u64) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::Tls) => {
self.push(Value::Generic(value))?;
}
_ => panic!(
"Called `Evaluation::resume_with_tls` without a preceding `EvaluationResult::RequiresTls`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `cfa`. This will
/// apply the provided CFA value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresCallFrameCfa`.
pub fn resume_with_call_frame_cfa(&mut self, cfa: u64) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::Cfa) => {
self.push(Value::Generic(cfa))?;
}
_ => panic!(
"Called `Evaluation::resume_with_call_frame_cfa` without a preceding `EvaluationResult::RequiresCallFrameCfa`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `bytes`. This will
/// continue processing the evaluation with the new expression provided
/// until the evaluation is completed, reaches an error, or needs more
/// information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresAtLocation`.
pub fn resume_with_at_location(&mut self, mut bytes: R) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::AtLocation) => {
if !bytes.is_empty() {
let mut pc = bytes.clone();
mem::swap(&mut pc, &mut self.pc);
mem::swap(&mut bytes, &mut self.bytecode);
self.expression_stack.try_push((pc, bytes)).map_err(|_| Error::StackFull)?;
}
}
_ => panic!(
"Called `Evaluation::resume_with_at_location` without a precedeing `EvaluationResult::RequiresAtLocation`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `entry_value`. This will
/// apply the provided entry value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresEntryValue`.
pub fn resume_with_entry_value(&mut self, entry_value: Value) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::EntryValue) => {
self.push(entry_value)?;
}
_ => panic!(
"Called `Evaluation::resume_with_entry_value` without a preceding `EvaluationResult::RequiresEntryValue`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `parameter_value`. This will
/// apply the provided parameter value to the evaluation and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresParameterRef`.
pub fn resume_with_parameter_ref(
&mut self,
parameter_value: u64,
) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::ParameterRef) => {
self.push(Value::Generic(parameter_value))?;
}
_ => panic!(
"Called `Evaluation::resume_with_parameter_ref` without a preceding `EvaluationResult::RequiresParameterRef`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided relocated `address`. This will use the
/// provided relocated address for the operation that required it, and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with
/// `EvaluationResult::RequiresRelocatedAddress`.
pub fn resume_with_relocated_address(&mut self, address: u64) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::RelocatedAddress) => {
self.push(Value::Generic(address))?;
}
_ => panic!(
"Called `Evaluation::resume_with_relocated_address` without a preceding `EvaluationResult::RequiresRelocatedAddress`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided indexed `address`. This will use the
/// provided indexed address for the operation that required it, and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with
/// `EvaluationResult::RequiresIndexedAddress`.
pub fn resume_with_indexed_address(&mut self, address: u64) -> Result<EvaluationResult<R>> {
match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::IndexedAddress) => {
self.push(Value::Generic(address))?;
}
_ => panic!(
"Called `Evaluation::resume_with_indexed_address` without a preceding `EvaluationResult::RequiresIndexedAddress`"
),
};
self.evaluate_internal()
}
/// Resume the `Evaluation` with the provided `base_type`. This will use the
/// provided base type for the operation that required it, and continue evaluating
/// opcodes until the evaluation is completed, reaches an error, or needs
/// more information again.
///
/// # Panics
/// Panics if this `Evaluation` did not previously stop with `EvaluationResult::RequiresBaseType`.
pub fn resume_with_base_type(&mut self, base_type: ValueType) -> Result<EvaluationResult<R>> {
let value = match self.state {
EvaluationState::Error(err) => return Err(err),
EvaluationState::Waiting(EvaluationWaiting::TypedLiteral { ref value }) => {
Value::parse(base_type, value.clone())?
}
EvaluationState::Waiting(EvaluationWaiting::Convert) => {
let entry = self.pop()?;
entry.convert(base_type, self.addr_mask)?
}
EvaluationState::Waiting(EvaluationWaiting::Reinterpret) => {
let entry = self.pop()?;
entry.reinterpret(base_type, self.addr_mask)?
}
_ => panic!(
"Called `Evaluation::resume_with_base_type` without a preceding `EvaluationResult::RequiresBaseType`"
),
};
self.push(value)?;
self.evaluate_internal()
}
fn end_of_expression(&mut self) -> bool {
while self.pc.is_empty() {
match self.expression_stack.pop() {
Some((newpc, newbytes)) => {
self.pc = newpc;
self.bytecode = newbytes;
}
None => return true,
}
}
false
}
fn evaluate_internal(&mut self) -> Result<EvaluationResult<R>> {
while !self.end_of_expression() {
self.iteration += 1;
if let Some(max_iterations) = self.max_iterations {
if self.iteration > max_iterations {
return Err(Error::TooManyIterations);
}
}
let op_result = self.evaluate_one_operation()?;
match op_result {
OperationEvaluationResult::Piece => {}
OperationEvaluationResult::Incomplete => {
if self.end_of_expression() && !self.result.is_empty() {
// We saw a piece earlier and then some
// unterminated piece. It's not clear this is
// well-defined.
return Err(Error::InvalidPiece);
}
}
OperationEvaluationResult::Complete { location } => {
if self.end_of_expression() {
if !self.result.is_empty() {
// We saw a piece earlier and then some
// unterminated piece. It's not clear this is
// well-defined.
return Err(Error::InvalidPiece);
}
self.result
.try_push(Piece {
size_in_bits: None,
bit_offset: None,
location,
})
.map_err(|_| Error::StackFull)?;
} else {
// If there are more operations, then the next operation must
// be a Piece.
match Operation::parse(&mut self.pc, self.encoding)? {
Operation::Piece {
size_in_bits,
bit_offset,
} => {
self.result
.try_push(Piece {
size_in_bits: Some(size_in_bits),
bit_offset,
location,
})
.map_err(|_| Error::StackFull)?;
}
_ => {
let value =
self.bytecode.len().into_u64() - self.pc.len().into_u64() - 1;
return Err(Error::InvalidExpressionTerminator(value));
}
}
}
}
OperationEvaluationResult::Waiting(waiting, result) => {
self.state = EvaluationState::Waiting(waiting);
return Ok(result);
}
}
}
// If no pieces have been seen, use the stack top as the
// result.
if self.result.is_empty() {
let entry = self.pop()?;
self.value_result = Some(entry);
let addr = entry.to_u64(self.addr_mask)?;
self.result
.try_push(Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Address { address: addr },
})
.map_err(|_| Error::StackFull)?;
}
self.state = EvaluationState::Complete;
Ok(EvaluationResult::Complete)
}
}
#[cfg(test)]
// Tests require leb128::write.
#[cfg(feature = "write")]
mod tests {
use super::*;
use crate::common::Format;
use crate::constants;
use crate::endianity::LittleEndian;
use crate::leb128;
use crate::read::{EndianSlice, Error, Result, UnitOffset};
use crate::test_util::GimliSectionMethods;
use core::usize;
use test_assembler::{Endian, Section};
fn encoding4() -> Encoding {
Encoding {
format: Format::Dwarf32,
version: 4,
address_size: 4,
}
}
fn encoding8() -> Encoding {
Encoding {
format: Format::Dwarf64,
version: 4,
address_size: 8,
}
}
#[test]
fn test_compute_pc() {
// Contents don't matter for this test, just length.
let bytes = [0, 1, 2, 3, 4];
let bytecode = &bytes[..];
let ebuf = &EndianSlice::new(bytecode, LittleEndian);
assert_eq!(compute_pc(ebuf, ebuf, 0), Ok(*ebuf));
assert_eq!(
compute_pc(ebuf, ebuf, -1),
Err(Error::BadBranchTarget(usize::MAX as u64))
);
assert_eq!(compute_pc(ebuf, ebuf, 5), Ok(ebuf.range_from(5..)));
assert_eq!(
compute_pc(&ebuf.range_from(3..), ebuf, -2),
Ok(ebuf.range_from(1..))
);
assert_eq!(
compute_pc(&ebuf.range_from(2..), ebuf, 2),
Ok(ebuf.range_from(4..))
);
}
fn check_op_parse_simple<'input>(
input: &'input [u8],
expect: &Operation<EndianSlice<'input, LittleEndian>>,
encoding: Encoding,
) {
let buf = EndianSlice::new(input, LittleEndian);
let mut pc = buf;
let value = Operation::parse(&mut pc, encoding);
match value {
Ok(val) => {
assert_eq!(val, *expect);
assert_eq!(pc.len(), 0);
}
_ => panic!("Unexpected result"),
}
}
fn check_op_parse_eof(input: &[u8], encoding: Encoding) {
let buf = EndianSlice::new(input, LittleEndian);
let mut pc = buf;
match Operation::parse(&mut pc, encoding) {
Err(Error::UnexpectedEof(id)) => {
assert!(buf.lookup_offset_id(id).is_some());
}
_ => panic!("Unexpected result"),
}
}
fn check_op_parse<F>(
input: F,
expect: &Operation<EndianSlice<LittleEndian>>,
encoding: Encoding,
) where
F: Fn(Section) -> Section,
{
let input = input(Section::with_endian(Endian::Little))
.get_contents()
.unwrap();
for i in 1..input.len() {
check_op_parse_eof(&input[..i], encoding);
}
check_op_parse_simple(&input, expect, encoding);
}
#[test]
fn test_op_parse_onebyte() {
// Doesn't matter for this test.
let encoding = encoding4();
// Test all single-byte opcodes.
#[rustfmt::skip]
let inputs = [
(
constants::DW_OP_deref,
Operation::Deref {
base_type: generic_type(),
size: encoding.address_size,
space: false,
},
),
(constants::DW_OP_dup, Operation::Pick { index: 0 }),
(constants::DW_OP_drop, Operation::Drop),
(constants::DW_OP_over, Operation::Pick { index: 1 }),
(constants::DW_OP_swap, Operation::Swap),
(constants::DW_OP_rot, Operation::Rot),
(
constants::DW_OP_xderef,
Operation::Deref {
base_type: generic_type(),
size: encoding.address_size,
space: true,
},
),
(constants::DW_OP_abs, Operation::Abs),
(constants::DW_OP_and, Operation::And),
(constants::DW_OP_div, Operation::Div),
(constants::DW_OP_minus, Operation::Minus),
(constants::DW_OP_mod, Operation::Mod),
(constants::DW_OP_mul, Operation::Mul),
(constants::DW_OP_neg, Operation::Neg),
(constants::DW_OP_not, Operation::Not),
(constants::DW_OP_or, Operation::Or),
(constants::DW_OP_plus, Operation::Plus),
(constants::DW_OP_shl, Operation::Shl),
(constants::DW_OP_shr, Operation::Shr),
(constants::DW_OP_shra, Operation::Shra),
(constants::DW_OP_xor, Operation::Xor),
(constants::DW_OP_eq, Operation::Eq),
(constants::DW_OP_ge, Operation::Ge),
(constants::DW_OP_gt, Operation::Gt),
(constants::DW_OP_le, Operation::Le),
(constants::DW_OP_lt, Operation::Lt),
(constants::DW_OP_ne, Operation::Ne),
(constants::DW_OP_lit0, Operation::UnsignedConstant { value: 0 }),
(constants::DW_OP_lit1, Operation::UnsignedConstant { value: 1 }),
(constants::DW_OP_lit2, Operation::UnsignedConstant { value: 2 }),
(constants::DW_OP_lit3, Operation::UnsignedConstant { value: 3 }),
(constants::DW_OP_lit4, Operation::UnsignedConstant { value: 4 }),
(constants::DW_OP_lit5, Operation::UnsignedConstant { value: 5 }),
(constants::DW_OP_lit6, Operation::UnsignedConstant { value: 6 }),
(constants::DW_OP_lit7, Operation::UnsignedConstant { value: 7 }),
(constants::DW_OP_lit8, Operation::UnsignedConstant { value: 8 }),
(constants::DW_OP_lit9, Operation::UnsignedConstant { value: 9 }),
(constants::DW_OP_lit10, Operation::UnsignedConstant { value: 10 }),
(constants::DW_OP_lit11, Operation::UnsignedConstant { value: 11 }),
(constants::DW_OP_lit12, Operation::UnsignedConstant { value: 12 }),
(constants::DW_OP_lit13, Operation::UnsignedConstant { value: 13 }),
(constants::DW_OP_lit14, Operation::UnsignedConstant { value: 14 }),
(constants::DW_OP_lit15, Operation::UnsignedConstant { value: 15 }),
(constants::DW_OP_lit16, Operation::UnsignedConstant { value: 16 }),
(constants::DW_OP_lit17, Operation::UnsignedConstant { value: 17 }),
(constants::DW_OP_lit18, Operation::UnsignedConstant { value: 18 }),
(constants::DW_OP_lit19, Operation::UnsignedConstant { value: 19 }),
(constants::DW_OP_lit20, Operation::UnsignedConstant { value: 20 }),
(constants::DW_OP_lit21, Operation::UnsignedConstant { value: 21 }),
(constants::DW_OP_lit22, Operation::UnsignedConstant { value: 22 }),
(constants::DW_OP_lit23, Operation::UnsignedConstant { value: 23 }),
(constants::DW_OP_lit24, Operation::UnsignedConstant { value: 24 }),
(constants::DW_OP_lit25, Operation::UnsignedConstant { value: 25 }),
(constants::DW_OP_lit26, Operation::UnsignedConstant { value: 26 }),
(constants::DW_OP_lit27, Operation::UnsignedConstant { value: 27 }),
(constants::DW_OP_lit28, Operation::UnsignedConstant { value: 28 }),
(constants::DW_OP_lit29, Operation::UnsignedConstant { value: 29 }),
(constants::DW_OP_lit30, Operation::UnsignedConstant { value: 30 }),
(constants::DW_OP_lit31, Operation::UnsignedConstant { value: 31 }),
(constants::DW_OP_reg0, Operation::Register { register: Register(0) }),
(constants::DW_OP_reg1, Operation::Register { register: Register(1) }),
(constants::DW_OP_reg2, Operation::Register { register: Register(2) }),
(constants::DW_OP_reg3, Operation::Register { register: Register(3) }),
(constants::DW_OP_reg4, Operation::Register { register: Register(4) }),
(constants::DW_OP_reg5, Operation::Register { register: Register(5) }),
(constants::DW_OP_reg6, Operation::Register { register: Register(6) }),
(constants::DW_OP_reg7, Operation::Register { register: Register(7) }),
(constants::DW_OP_reg8, Operation::Register { register: Register(8) }),
(constants::DW_OP_reg9, Operation::Register { register: Register(9) }),
(constants::DW_OP_reg10, Operation::Register { register: Register(10) }),
(constants::DW_OP_reg11, Operation::Register { register: Register(11) }),
(constants::DW_OP_reg12, Operation::Register { register: Register(12) }),
(constants::DW_OP_reg13, Operation::Register { register: Register(13) }),
(constants::DW_OP_reg14, Operation::Register { register: Register(14) }),
(constants::DW_OP_reg15, Operation::Register { register: Register(15) }),
(constants::DW_OP_reg16, Operation::Register { register: Register(16) }),
(constants::DW_OP_reg17, Operation::Register { register: Register(17) }),
(constants::DW_OP_reg18, Operation::Register { register: Register(18) }),
(constants::DW_OP_reg19, Operation::Register { register: Register(19) }),
(constants::DW_OP_reg20, Operation::Register { register: Register(20) }),
(constants::DW_OP_reg21, Operation::Register { register: Register(21) }),
(constants::DW_OP_reg22, Operation::Register { register: Register(22) }),
(constants::DW_OP_reg23, Operation::Register { register: Register(23) }),
(constants::DW_OP_reg24, Operation::Register { register: Register(24) }),
(constants::DW_OP_reg25, Operation::Register { register: Register(25) }),
(constants::DW_OP_reg26, Operation::Register { register: Register(26) }),
(constants::DW_OP_reg27, Operation::Register { register: Register(27) }),
(constants::DW_OP_reg28, Operation::Register { register: Register(28) }),
(constants::DW_OP_reg29, Operation::Register { register: Register(29) }),
(constants::DW_OP_reg30, Operation::Register { register: Register(30) }),
(constants::DW_OP_reg31, Operation::Register { register: Register(31) }),
(constants::DW_OP_nop, Operation::Nop),
(constants::DW_OP_push_object_address, Operation::PushObjectAddress),
(constants::DW_OP_form_tls_address, Operation::TLS),
(constants::DW_OP_GNU_push_tls_address, Operation::TLS),
(constants::DW_OP_call_frame_cfa, Operation::CallFrameCFA),
(constants::DW_OP_stack_value, Operation::StackValue),
];
let input = [];
check_op_parse_eof(&input[..], encoding);
for item in inputs.iter() {
let (opcode, ref result) = *item;
check_op_parse(|s| s.D8(opcode.0), result, encoding);
}
}
#[test]
fn test_op_parse_twobyte() {
// Doesn't matter for this test.
let encoding = encoding4();
let inputs = [
(
constants::DW_OP_const1u,
23,
Operation::UnsignedConstant { value: 23 },
),
(
constants::DW_OP_const1s,
(-23i8) as u8,
Operation::SignedConstant { value: -23 },
),
(constants::DW_OP_pick, 7, Operation::Pick { index: 7 }),
(
constants::DW_OP_deref_size,
19,
Operation::Deref {
base_type: generic_type(),
size: 19,
space: false,
},
),
(
constants::DW_OP_xderef_size,
19,
Operation::Deref {
base_type: generic_type(),
size: 19,
space: true,
},
),
];
for item in inputs.iter() {
let (opcode, arg, ref result) = *item;
check_op_parse(|s| s.D8(opcode.0).D8(arg), result, encoding);
}
}
#[test]
fn test_op_parse_threebyte() {
// Doesn't matter for this test.
let encoding = encoding4();
// While bra and skip are 3-byte opcodes, they aren't tested here,
// but rather specially in their own function.
let inputs = [
(
constants::DW_OP_const2u,
23,
Operation::UnsignedConstant { value: 23 },
),
(
constants::DW_OP_const2s,
(-23i16) as u16,
Operation::SignedConstant { value: -23 },
),
(
constants::DW_OP_call2,
1138,
Operation::Call {
offset: DieReference::UnitRef(UnitOffset(1138)),
},
),
(
constants::DW_OP_bra,
(-23i16) as u16,
Operation::Bra { target: -23 },
),
(
constants::DW_OP_skip,
(-23i16) as u16,
Operation::Skip { target: -23 },
),
];
for item in inputs.iter() {
let (opcode, arg, ref result) = *item;
check_op_parse(|s| s.D8(opcode.0).L16(arg), result, encoding);
}
}
#[test]
fn test_op_parse_fivebyte() {
// There are some tests here that depend on address size.
let encoding = encoding4();
let inputs = [
(
constants::DW_OP_addr,
0x1234_5678,
Operation::Address {
address: 0x1234_5678,
},
),
(
constants::DW_OP_const4u,
0x1234_5678,
Operation::UnsignedConstant { value: 0x1234_5678 },
),
(
constants::DW_OP_const4s,
(-23i32) as u32,
Operation::SignedConstant { value: -23 },
),
(
constants::DW_OP_call4,
0x1234_5678,
Operation::Call {
offset: DieReference::UnitRef(UnitOffset(0x1234_5678)),
},
),
(
constants::DW_OP_call_ref,
0x1234_5678,
Operation::Call {
offset: DieReference::DebugInfoRef(DebugInfoOffset(0x1234_5678)),
},
),
];
for item in inputs.iter() {
let (op, arg, ref expect) = *item;
check_op_parse(|s| s.D8(op.0).L32(arg), expect, encoding);
}
}
#[test]
#[cfg(target_pointer_width = "64")]
fn test_op_parse_ninebyte() {
// There are some tests here that depend on address size.
let encoding = encoding8();
let inputs = [
(
constants::DW_OP_addr,
0x1234_5678_1234_5678,
Operation::Address {
address: 0x1234_5678_1234_5678,
},
),
(
constants::DW_OP_const8u,
0x1234_5678_1234_5678,
Operation::UnsignedConstant {
value: 0x1234_5678_1234_5678,
},
),
(
constants::DW_OP_const8s,
(-23i64) as u64,
Operation::SignedConstant { value: -23 },
),
(
constants::DW_OP_call_ref,
0x1234_5678_1234_5678,
Operation::Call {
offset: DieReference::DebugInfoRef(DebugInfoOffset(0x1234_5678_1234_5678)),
},
),
];
for item in inputs.iter() {
let (op, arg, ref expect) = *item;
check_op_parse(|s| s.D8(op.0).L64(arg), expect, encoding);
}
}
#[test]
fn test_op_parse_sleb() {
// Doesn't matter for this test.
let encoding = encoding4();
let values = [
-1i64,
0,
1,
0x100,
0x1eee_eeee,
0x7fff_ffff_ffff_ffff,
-0x100,
-0x1eee_eeee,
-0x7fff_ffff_ffff_ffff,
];
for value in values.iter() {
let mut inputs = vec![
(
constants::DW_OP_consts.0,
Operation::SignedConstant { value: *value },
),
(
constants::DW_OP_fbreg.0,
Operation::FrameOffset { offset: *value },
),
];
for i in 0..32 {
inputs.push((
constants::DW_OP_breg0.0 + i,
Operation::RegisterOffset {
register: Register(i.into()),
offset: *value,
base_type: UnitOffset(0),
},
));
}
for item in inputs.iter() {
let (op, ref expect) = *item;
check_op_parse(|s| s.D8(op).sleb(*value), expect, encoding);
}
}
}
#[test]
fn test_op_parse_uleb() {
// Doesn't matter for this test.
let encoding = encoding4();
let values = [
0,
1,
0x100,
(!0u16).into(),
0x1eee_eeee,
0x7fff_ffff_ffff_ffff,
!0u64,
];
for value in values.iter() {
let mut inputs = vec![
(
constants::DW_OP_constu,
Operation::UnsignedConstant { value: *value },
),
(
constants::DW_OP_plus_uconst,
Operation::PlusConstant { value: *value },
),
];
if *value <= (!0u16).into() {
inputs.push((
constants::DW_OP_regx,
Operation::Register {
register: Register::from_u64(*value).unwrap(),
},
));
}
if *value <= (!0u32).into() {
inputs.extend(&[
(
constants::DW_OP_addrx,
Operation::AddressIndex {
index: DebugAddrIndex(*value as usize),
},
),
(
constants::DW_OP_constx,
Operation::ConstantIndex {
index: DebugAddrIndex(*value as usize),
},
),
]);
}
// FIXME
if *value < !0u64 / 8 {
inputs.push((
constants::DW_OP_piece,
Operation::Piece {
size_in_bits: 8 * value,
bit_offset: None,
},
));
}
for item in inputs.iter() {
let (op, ref expect) = *item;
let input = Section::with_endian(Endian::Little)
.D8(op.0)
.uleb(*value)
.get_contents()
.unwrap();
check_op_parse_simple(&input, expect, encoding);
}
}
}
#[test]
fn test_op_parse_bregx() {
// Doesn't matter for this test.
let encoding = encoding4();
let uvalues = [0, 1, 0x100, !0u16];
let svalues = [
-1i64,
0,
1,
0x100,
0x1eee_eeee,
0x7fff_ffff_ffff_ffff,
-0x100,
-0x1eee_eeee,
-0x7fff_ffff_ffff_ffff,
];
for v1 in uvalues.iter() {
for v2 in svalues.iter() {
check_op_parse(
|s| s.D8(constants::DW_OP_bregx.0).uleb((*v1).into()).sleb(*v2),
&Operation::RegisterOffset {
register: Register(*v1),
offset: *v2,
base_type: UnitOffset(0),
},
encoding,
);
}
}
}
#[test]
fn test_op_parse_bit_piece() {
// Doesn't matter for this test.
let encoding = encoding4();
let values = [0, 1, 0x100, 0x1eee_eeee, 0x7fff_ffff_ffff_ffff, !0u64];
for v1 in values.iter() {
for v2 in values.iter() {
let input = Section::with_endian(Endian::Little)
.D8(constants::DW_OP_bit_piece.0)
.uleb(*v1)
.uleb(*v2)
.get_contents()
.unwrap();
check_op_parse_simple(
&input,
&Operation::Piece {
size_in_bits: *v1,
bit_offset: Some(*v2),
},
encoding,
);
}
}
}
#[test]
fn test_op_parse_implicit_value() {
// Doesn't matter for this test.
let encoding = encoding4();
let data = b"hello";
check_op_parse(
|s| {
s.D8(constants::DW_OP_implicit_value.0)
.uleb(data.len() as u64)
.append_bytes(&data[..])
},
&Operation::ImplicitValue {
data: EndianSlice::new(&data[..], LittleEndian),
},
encoding,
);
}
#[test]
fn test_op_parse_const_type() {
// Doesn't matter for this test.
let encoding = encoding4();
let data = b"hello";
check_op_parse(
|s| {
s.D8(constants::DW_OP_const_type.0)
.uleb(100)
.D8(data.len() as u8)
.append_bytes(&data[..])
},
&Operation::TypedLiteral {
base_type: UnitOffset(100),
value: EndianSlice::new(&data[..], LittleEndian),
},
encoding,
);
check_op_parse(
|s| {
s.D8(constants::DW_OP_GNU_const_type.0)
.uleb(100)
.D8(data.len() as u8)
.append_bytes(&data[..])
},
&Operation::TypedLiteral {
base_type: UnitOffset(100),
value: EndianSlice::new(&data[..], LittleEndian),
},
encoding,
);
}
#[test]
fn test_op_parse_regval_type() {
// Doesn't matter for this test.
let encoding = encoding4();
check_op_parse(
|s| s.D8(constants::DW_OP_regval_type.0).uleb(1).uleb(100),
&Operation::RegisterOffset {
register: Register(1),
offset: 0,
base_type: UnitOffset(100),
},
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_GNU_regval_type.0).uleb(1).uleb(100),
&Operation::RegisterOffset {
register: Register(1),
offset: 0,
base_type: UnitOffset(100),
},
encoding,
);
}
#[test]
fn test_op_parse_deref_type() {
// Doesn't matter for this test.
let encoding = encoding4();
check_op_parse(
|s| s.D8(constants::DW_OP_deref_type.0).D8(8).uleb(100),
&Operation::Deref {
base_type: UnitOffset(100),
size: 8,
space: false,
},
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_GNU_deref_type.0).D8(8).uleb(100),
&Operation::Deref {
base_type: UnitOffset(100),
size: 8,
space: false,
},
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_xderef_type.0).D8(8).uleb(100),
&Operation::Deref {
base_type: UnitOffset(100),
size: 8,
space: true,
},
encoding,
);
}
#[test]
fn test_op_convert() {
// Doesn't matter for this test.
let encoding = encoding4();
check_op_parse(
|s| s.D8(constants::DW_OP_convert.0).uleb(100),
&Operation::Convert {
base_type: UnitOffset(100),
},
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_GNU_convert.0).uleb(100),
&Operation::Convert {
base_type: UnitOffset(100),
},
encoding,
);
}
#[test]
fn test_op_reinterpret() {
// Doesn't matter for this test.
let encoding = encoding4();
check_op_parse(
|s| s.D8(constants::DW_OP_reinterpret.0).uleb(100),
&Operation::Reinterpret {
base_type: UnitOffset(100),
},
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_GNU_reinterpret.0).uleb(100),
&Operation::Reinterpret {
base_type: UnitOffset(100),
},
encoding,
);
}
#[test]
fn test_op_parse_implicit_pointer() {
for op in &[
constants::DW_OP_implicit_pointer,
constants::DW_OP_GNU_implicit_pointer,
] {
check_op_parse(
|s| s.D8(op.0).D32(0x1234_5678).sleb(0x123),
&Operation::ImplicitPointer {
value: DebugInfoOffset(0x1234_5678),
byte_offset: 0x123,
},
encoding4(),
);
check_op_parse(
|s| s.D8(op.0).D64(0x1234_5678).sleb(0x123),
&Operation::ImplicitPointer {
value: DebugInfoOffset(0x1234_5678),
byte_offset: 0x123,
},
encoding8(),
);
check_op_parse(
|s| s.D8(op.0).D64(0x1234_5678).sleb(0x123),
&Operation::ImplicitPointer {
value: DebugInfoOffset(0x1234_5678),
byte_offset: 0x123,
},
Encoding {
format: Format::Dwarf32,
version: 2,
address_size: 8,
},
)
}
}
#[test]
fn test_op_parse_entry_value() {
for op in &[
constants::DW_OP_entry_value,
constants::DW_OP_GNU_entry_value,
] {
let data = b"hello";
check_op_parse(
|s| s.D8(op.0).uleb(data.len() as u64).append_bytes(&data[..]),
&Operation::EntryValue {
expression: EndianSlice::new(&data[..], LittleEndian),
},
encoding4(),
);
}
}
#[test]
fn test_op_parse_gnu_parameter_ref() {
check_op_parse(
|s| s.D8(constants::DW_OP_GNU_parameter_ref.0).D32(0x1234_5678),
&Operation::ParameterRef {
offset: UnitOffset(0x1234_5678),
},
encoding4(),
)
}
#[test]
fn test_op_wasm() {
// Doesn't matter for this test.
let encoding = encoding4();
check_op_parse(
|s| s.D8(constants::DW_OP_WASM_location.0).D8(0).uleb(1000),
&Operation::WasmLocal { index: 1000 },
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_WASM_location.0).D8(1).uleb(1000),
&Operation::WasmGlobal { index: 1000 },
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_WASM_location.0).D8(2).uleb(1000),
&Operation::WasmStack { index: 1000 },
encoding,
);
check_op_parse(
|s| s.D8(constants::DW_OP_WASM_location.0).D8(3).D32(1000),
&Operation::WasmGlobal { index: 1000 },
encoding,
);
}
enum AssemblerEntry {
Op(constants::DwOp),
Mark(u8),
Branch(u8),
U8(u8),
U16(u16),
U32(u32),
U64(u64),
Uleb(u64),
Sleb(u64),
}
fn assemble(entries: &[AssemblerEntry]) -> Vec<u8> {
let mut result = Vec::new();
struct Marker(Option<usize>, Vec<usize>);
let mut markers = Vec::new();
for _ in 0..256 {
markers.push(Marker(None, Vec::new()));
}
fn write(stack: &mut Vec<u8>, index: usize, mut num: u64, nbytes: u8) {
for i in 0..nbytes as usize {
stack[index + i] = (num & 0xff) as u8;
num >>= 8;
}
}
fn push(stack: &mut Vec<u8>, num: u64, nbytes: u8) {
let index = stack.len();
for _ in 0..nbytes {
stack.push(0);
}
write(stack, index, num, nbytes);
}
for item in entries {
match *item {
AssemblerEntry::Op(op) => result.push(op.0),
AssemblerEntry::Mark(num) => {
assert!(markers[num as usize].0.is_none());
markers[num as usize].0 = Some(result.len());
}
AssemblerEntry::Branch(num) => {
markers[num as usize].1.push(result.len());
push(&mut result, 0, 2);
}
AssemblerEntry::U8(num) => result.push(num),
AssemblerEntry::U16(num) => push(&mut result, u64::from(num), 2),
AssemblerEntry::U32(num) => push(&mut result, u64::from(num), 4),
AssemblerEntry::U64(num) => push(&mut result, num, 8),
AssemblerEntry::Uleb(num) => {
leb128::write::unsigned(&mut result, num).unwrap();
}
AssemblerEntry::Sleb(num) => {
leb128::write::signed(&mut result, num as i64).unwrap();
}
}
}
// Update all the branches.
for marker in markers {
if let Some(offset) = marker.0 {
for branch_offset in marker.1 {
let delta = offset.wrapping_sub(branch_offset + 2) as u64;
write(&mut result, branch_offset, delta, 2);
}
}
}
result
}
fn check_eval_with_args<F>(
program: &[AssemblerEntry],
expect: Result<&[Piece<EndianSlice<LittleEndian>>]>,
encoding: Encoding,
object_address: Option<u64>,
initial_value: Option<u64>,
max_iterations: Option<u32>,
f: F,
) where
for<'a> F: Fn(
&mut Evaluation<EndianSlice<'a, LittleEndian>>,
EvaluationResult<EndianSlice<'a, LittleEndian>>,
) -> Result<EvaluationResult<EndianSlice<'a, LittleEndian>>>,
{
let bytes = assemble(program);
let bytes = EndianSlice::new(&bytes, LittleEndian);
let mut eval = Evaluation::new(bytes, encoding);
if let Some(val) = object_address {
eval.set_object_address(val);
}
if let Some(val) = initial_value {
eval.set_initial_value(val);
}
if let Some(val) = max_iterations {
eval.set_max_iterations(val);
}
let result = match eval.evaluate() {
Err(e) => Err(e),
Ok(r) => f(&mut eval, r),
};
match (result, expect) {
(Ok(EvaluationResult::Complete), Ok(pieces)) => {
let vec = eval.result();
assert_eq!(vec.len(), pieces.len());
for i in 0..pieces.len() {
assert_eq!(vec[i], pieces[i]);
}
}
(Err(f1), Err(f2)) => {
assert_eq!(f1, f2);
}
otherwise => panic!("Unexpected result: {:?}", otherwise),
}
}
fn check_eval(
program: &[AssemblerEntry],
expect: Result<&[Piece<EndianSlice<LittleEndian>>]>,
encoding: Encoding,
) {
check_eval_with_args(program, expect, encoding, None, None, None, |_, result| {
Ok(result)
});
}
#[test]
fn test_eval_arith() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Indices of marks in the assembly.
let done = 0;
let fail = 1;
#[rustfmt::skip]
let program = [
Op(DW_OP_const1u), U8(23),
Op(DW_OP_const1s), U8((-23i8) as u8),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const2u), U16(23),
Op(DW_OP_const2s), U16((-23i16) as u16),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4u), U32(0x1111_2222),
Op(DW_OP_const4s), U32((-0x1111_2222i32) as u32),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
// Plus should overflow.
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1u), U8(1),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_plus_uconst), Uleb(1),
Op(DW_OP_bra), Branch(fail),
// Minus should underflow.
Op(DW_OP_const1s), U8(0),
Op(DW_OP_const1u), U8(1),
Op(DW_OP_minus),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_abs),
Op(DW_OP_const1u), U8(1),
Op(DW_OP_minus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4u), U32(0xf078_fffe),
Op(DW_OP_const4u), U32(0x0f87_0001),
Op(DW_OP_and),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4u), U32(0xf078_fffe),
Op(DW_OP_const4u), U32(0xf000_00fe),
Op(DW_OP_and),
Op(DW_OP_const4u), U32(0xf000_00fe),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
// Division is signed.
Op(DW_OP_const1s), U8(0xfe),
Op(DW_OP_const1s), U8(2),
Op(DW_OP_div),
Op(DW_OP_plus_uconst), Uleb(1),
Op(DW_OP_bra), Branch(fail),
// Mod is unsigned.
Op(DW_OP_const1s), U8(0xfd),
Op(DW_OP_const1s), U8(2),
Op(DW_OP_mod),
Op(DW_OP_neg),
Op(DW_OP_plus_uconst), Uleb(1),
Op(DW_OP_bra), Branch(fail),
// Overflow is defined for multiplication.
Op(DW_OP_const4u), U32(0x8000_0001),
Op(DW_OP_lit2),
Op(DW_OP_mul),
Op(DW_OP_lit2),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4u), U32(0xf0f0_f0f0),
Op(DW_OP_const4u), U32(0xf0f0_f0f0),
Op(DW_OP_xor),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4u), U32(0xf0f0_f0f0),
Op(DW_OP_const4u), U32(0x0f0f_0f0f),
Op(DW_OP_or),
Op(DW_OP_not),
Op(DW_OP_bra), Branch(fail),
// In 32 bit mode, values are truncated.
Op(DW_OP_const8u), U64(0xffff_ffff_0000_0000),
Op(DW_OP_lit2),
Op(DW_OP_div),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1u), U8(0xff),
Op(DW_OP_lit1),
Op(DW_OP_shl),
Op(DW_OP_const2u), U16(0x1fe),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1u), U8(0xff),
Op(DW_OP_const1u), U8(50),
Op(DW_OP_shl),
Op(DW_OP_bra), Branch(fail),
// Absurd shift.
Op(DW_OP_const1u), U8(0xff),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_shl),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_lit1),
Op(DW_OP_shr),
Op(DW_OP_const4u), U32(0x7fff_ffff),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1u), U8(0xff),
Op(DW_OP_shr),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_lit1),
Op(DW_OP_shra),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1u), U8(0xff),
Op(DW_OP_shra),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
// Success.
Op(DW_OP_lit0),
Op(DW_OP_nop),
Op(DW_OP_skip), Branch(done),
Mark(fail),
Op(DW_OP_lit1),
Mark(done),
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0),
},
}];
check_eval(&program, Ok(&result), encoding4());
}
#[test]
fn test_eval_arith64() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Indices of marks in the assembly.
let done = 0;
let fail = 1;
#[rustfmt::skip]
let program = [
Op(DW_OP_const8u), U64(0x1111_2222_3333_4444),
Op(DW_OP_const8s), U64((-0x1111_2222_3333_4444i64) as u64),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_constu), Uleb(0x1111_2222_3333_4444),
Op(DW_OP_consts), Sleb((-0x1111_2222_3333_4444i64) as u64),
Op(DW_OP_plus),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit1),
Op(DW_OP_plus_uconst), Uleb(!0u64),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit1),
Op(DW_OP_neg),
Op(DW_OP_not),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
Op(DW_OP_const1u), U8(63),
Op(DW_OP_shr),
Op(DW_OP_lit1),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
Op(DW_OP_const1u), U8(62),
Op(DW_OP_shra),
Op(DW_OP_plus_uconst), Uleb(2),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit1),
Op(DW_OP_const1u), U8(63),
Op(DW_OP_shl),
Op(DW_OP_const8u), U64(0x8000_0000_0000_0000),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
// Success.
Op(DW_OP_lit0),
Op(DW_OP_nop),
Op(DW_OP_skip), Branch(done),
Mark(fail),
Op(DW_OP_lit1),
Mark(done),
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0),
},
}];
check_eval(&program, Ok(&result), encoding8());
}
#[test]
fn test_eval_compare() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Indices of marks in the assembly.
let done = 0;
let fail = 1;
#[rustfmt::skip]
let program = [
// Comparisons are signed.
Op(DW_OP_const1s), U8(1),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_lt),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1s), U8(1),
Op(DW_OP_gt),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(1),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_le),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1s), U8(1),
Op(DW_OP_ge),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const1s), U8(0xff),
Op(DW_OP_const1s), U8(1),
Op(DW_OP_eq),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_const4s), U32(1),
Op(DW_OP_const1s), U8(1),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
// Success.
Op(DW_OP_lit0),
Op(DW_OP_nop),
Op(DW_OP_skip), Branch(done),
Mark(fail),
Op(DW_OP_lit1),
Mark(done),
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0),
},
}];
check_eval(&program, Ok(&result), encoding4());
}
#[test]
fn test_eval_stack() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
#[rustfmt::skip]
let program = [
Op(DW_OP_lit17), // -- 17
Op(DW_OP_dup), // -- 17 17
Op(DW_OP_over), // -- 17 17 17
Op(DW_OP_minus), // -- 17 0
Op(DW_OP_swap), // -- 0 17
Op(DW_OP_dup), // -- 0 17 17
Op(DW_OP_plus_uconst), Uleb(1), // -- 0 17 18
Op(DW_OP_rot), // -- 18 0 17
Op(DW_OP_pick), U8(2), // -- 18 0 17 18
Op(DW_OP_pick), U8(3), // -- 18 0 17 18 18
Op(DW_OP_minus), // -- 18 0 17 0
Op(DW_OP_drop), // -- 18 0 17
Op(DW_OP_swap), // -- 18 17 0
Op(DW_OP_drop), // -- 18 17
Op(DW_OP_minus), // -- 1
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(1),
},
}];
check_eval(&program, Ok(&result), encoding4());
}
#[test]
fn test_eval_lit_and_reg() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
let mut program = Vec::new();
program.push(Op(DW_OP_lit0));
for i in 0..32 {
program.push(Op(DwOp(DW_OP_lit0.0 + i)));
program.push(Op(DwOp(DW_OP_breg0.0 + i)));
program.push(Sleb(u64::from(i)));
program.push(Op(DW_OP_plus));
program.push(Op(DW_OP_plus));
}
program.push(Op(DW_OP_bregx));
program.push(Uleb(0x1234));
program.push(Sleb(0x1234));
program.push(Op(DW_OP_plus));
program.push(Op(DW_OP_stack_value));
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(496),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, mut result| {
while result != EvaluationResult::Complete {
result = eval.resume_with_register(match result {
EvaluationResult::RequiresRegister {
register,
base_type,
} => {
assert_eq!(base_type, UnitOffset(0));
Value::Generic(u64::from(register.0).wrapping_neg())
}
_ => panic!(),
})?;
}
Ok(result)
},
);
}
#[test]
fn test_eval_memory() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Indices of marks in the assembly.
let done = 0;
let fail = 1;
#[rustfmt::skip]
let program = [
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_deref),
Op(DW_OP_const4u), U32(0xffff_fffc),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_deref_size), U8(2),
Op(DW_OP_const4u), U32(0xfffc),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit1),
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_xderef),
Op(DW_OP_const4u), U32(0xffff_fffd),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit1),
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_xderef_size), U8(2),
Op(DW_OP_const4u), U32(0xfffd),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit17),
Op(DW_OP_form_tls_address),
Op(DW_OP_constu), Uleb(!17),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_lit17),
Op(DW_OP_GNU_push_tls_address),
Op(DW_OP_constu), Uleb(!17),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_addrx), Uleb(0x10),
Op(DW_OP_deref),
Op(DW_OP_const4u), U32(0x4040),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
Op(DW_OP_constx), Uleb(17),
Op(DW_OP_form_tls_address),
Op(DW_OP_constu), Uleb(!27),
Op(DW_OP_ne),
Op(DW_OP_bra), Branch(fail),
// Success.
Op(DW_OP_lit0),
Op(DW_OP_nop),
Op(DW_OP_skip), Branch(done),
Mark(fail),
Op(DW_OP_lit1),
Mark(done),
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, mut result| {
while result != EvaluationResult::Complete {
result = match result {
EvaluationResult::RequiresMemory {
address,
size,
space,
base_type,
} => {
assert_eq!(base_type, UnitOffset(0));
let mut v = address << 2;
if let Some(value) = space {
v += value;
}
v &= (1u64 << (8 * size)) - 1;
eval.resume_with_memory(Value::Generic(v))?
}
EvaluationResult::RequiresTls(slot) => eval.resume_with_tls(!slot)?,
EvaluationResult::RequiresRelocatedAddress(address) => {
eval.resume_with_relocated_address(address)?
}
EvaluationResult::RequiresIndexedAddress { index, relocate } => {
if relocate {
eval.resume_with_indexed_address(0x1000 + index.0 as u64)?
} else {
eval.resume_with_indexed_address(10 + index.0 as u64)?
}
}
_ => panic!(),
};
}
Ok(result)
},
);
}
#[test]
fn test_eval_register() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
for i in 0..32 {
#[rustfmt::skip]
let program = [
Op(DwOp(DW_OP_reg0.0 + i)),
// Included only in the "bad" run.
Op(DW_OP_lit23),
];
let ok_result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Register {
register: Register(i.into()),
},
}];
check_eval(&program[..1], Ok(&ok_result), encoding4());
check_eval(
&program,
Err(Error::InvalidExpressionTerminator(1)),
encoding4(),
);
}
#[rustfmt::skip]
let program = [
Op(DW_OP_regx), Uleb(0x1234)
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Register {
register: Register(0x1234),
},
}];
check_eval(&program, Ok(&result), encoding4());
}
#[test]
fn test_eval_context() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Test `frame_base` and `call_frame_cfa` callbacks.
#[rustfmt::skip]
let program = [
Op(DW_OP_fbreg), Sleb((-8i8) as u64),
Op(DW_OP_call_frame_cfa),
Op(DW_OP_plus),
Op(DW_OP_neg),
Op(DW_OP_stack_value)
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(9),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding8(),
None,
None,
None,
|eval, result| {
match result {
EvaluationResult::RequiresFrameBase => {}
_ => panic!(),
};
match eval.resume_with_frame_base(0x0123_4567_89ab_cdef)? {
EvaluationResult::RequiresCallFrameCfa => {}
_ => panic!(),
};
eval.resume_with_call_frame_cfa(0xfedc_ba98_7654_3210)
},
);
// Test `evaluate_entry_value` callback.
#[rustfmt::skip]
let program = [
Op(DW_OP_entry_value), Uleb(8), U64(0x1234_5678),
Op(DW_OP_stack_value)
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0x1234_5678),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding8(),
None,
None,
None,
|eval, result| {
let entry_value = match result {
EvaluationResult::RequiresEntryValue(mut expression) => {
expression.0.read_u64()?
}
_ => panic!(),
};
eval.resume_with_entry_value(Value::Generic(entry_value))
},
);
// Test missing `object_address` field.
#[rustfmt::skip]
let program = [
Op(DW_OP_push_object_address),
];
check_eval_with_args(
&program,
Err(Error::InvalidPushObjectAddress),
encoding4(),
None,
None,
None,
|_, _| panic!(),
);
// Test `object_address` field.
#[rustfmt::skip]
let program = [
Op(DW_OP_push_object_address),
Op(DW_OP_stack_value),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(0xff),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding8(),
Some(0xff),
None,
None,
|_, result| Ok(result),
);
// Test `initial_value` field.
#[rustfmt::skip]
let program = [
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Address {
address: 0x1234_5678,
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding8(),
None,
Some(0x1234_5678),
None,
|_, result| Ok(result),
);
}
#[test]
fn test_eval_empty_stack() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
#[rustfmt::skip]
let program = [
Op(DW_OP_stack_value)
];
check_eval(&program, Err(Error::NotEnoughStackItems), encoding4());
}
#[test]
fn test_eval_call() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
#[rustfmt::skip]
let program = [
Op(DW_OP_lit23),
Op(DW_OP_call2), U16(0x7755),
Op(DW_OP_call4), U32(0x7755_aaee),
Op(DW_OP_call_ref), U32(0x7755_aaee),
Op(DW_OP_stack_value)
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(23),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, result| {
let buf = EndianSlice::new(&[], LittleEndian);
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)?;
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)?;
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)
},
);
// DW_OP_lit2 DW_OP_mul
const SUBR: &[u8] = &[0x32, 0x1e];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value {
value: Value::Generic(184),
},
}];
check_eval_with_args(
&program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, result| {
let buf = EndianSlice::new(SUBR, LittleEndian);
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)?;
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)?;
match result {
EvaluationResult::RequiresAtLocation(_) => {}
_ => panic!(),
};
eval.resume_with_at_location(buf)
},
);
}
#[test]
fn test_eval_pieces() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
// Example from DWARF 2.6.1.3.
#[rustfmt::skip]
let program = [
Op(DW_OP_reg3),
Op(DW_OP_piece), Uleb(4),
Op(DW_OP_reg4),
Op(DW_OP_piece), Uleb(2),
];
let result = [
Piece {
size_in_bits: Some(32),
bit_offset: None,
location: Location::Register {
register: Register(3),
},
},
Piece {
size_in_bits: Some(16),
bit_offset: None,
location: Location::Register {
register: Register(4),
},
},
];
check_eval(&program, Ok(&result), encoding4());
// Example from DWARF 2.6.1.3 (but hacked since dealing with fbreg
// in the tests is a pain).
#[rustfmt::skip]
let program = [
Op(DW_OP_reg0),
Op(DW_OP_piece), Uleb(4),
Op(DW_OP_piece), Uleb(4),
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_piece), Uleb(4),
];
let result = [
Piece {
size_in_bits: Some(32),
bit_offset: None,
location: Location::Register {
register: Register(0),
},
},
Piece {
size_in_bits: Some(32),
bit_offset: None,
location: Location::Empty,
},
Piece {
size_in_bits: Some(32),
bit_offset: None,
location: Location::Address {
address: 0x7fff_ffff,
},
},
];
check_eval_with_args(
&program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, mut result| {
while result != EvaluationResult::Complete {
result = match result {
EvaluationResult::RequiresRelocatedAddress(address) => {
eval.resume_with_relocated_address(address)?
}
_ => panic!(),
};
}
Ok(result)
},
);
#[rustfmt::skip]
let program = [
Op(DW_OP_implicit_value), Uleb(5),
U8(23), U8(24), U8(25), U8(26), U8(0),
];
const BYTES: &[u8] = &[23, 24, 25, 26, 0];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Bytes {
value: EndianSlice::new(BYTES, LittleEndian),
},
}];
check_eval(&program, Ok(&result), encoding4());
#[rustfmt::skip]
let program = [
Op(DW_OP_lit7),
Op(DW_OP_stack_value),
Op(DW_OP_bit_piece), Uleb(5), Uleb(0),
Op(DW_OP_bit_piece), Uleb(3), Uleb(0),
];
let result = [
Piece {
size_in_bits: Some(5),
bit_offset: Some(0),
location: Location::Value {
value: Value::Generic(7),
},
},
Piece {
size_in_bits: Some(3),
bit_offset: Some(0),
location: Location::Empty,
},
];
check_eval(&program, Ok(&result), encoding4());
#[rustfmt::skip]
let program = [
Op(DW_OP_lit7),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Address { address: 7 },
}];
check_eval(&program, Ok(&result), encoding4());
#[rustfmt::skip]
let program = [
Op(DW_OP_implicit_pointer), U32(0x1234_5678), Sleb(0x123),
];
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::ImplicitPointer {
value: DebugInfoOffset(0x1234_5678),
byte_offset: 0x123,
},
}];
check_eval(&program, Ok(&result), encoding4());
#[rustfmt::skip]
let program = [
Op(DW_OP_reg3),
Op(DW_OP_piece), Uleb(4),
Op(DW_OP_reg4),
];
check_eval(&program, Err(Error::InvalidPiece), encoding4());
#[rustfmt::skip]
let program = [
Op(DW_OP_reg3),
Op(DW_OP_piece), Uleb(4),
Op(DW_OP_lit0),
];
check_eval(&program, Err(Error::InvalidPiece), encoding4());
}
#[test]
fn test_eval_max_iterations() {
// It's nice if an operation and its arguments can fit on a single
// line in the test program.
use self::AssemblerEntry::*;
use crate::constants::*;
#[rustfmt::skip]
let program = [
Mark(1),
Op(DW_OP_skip), Branch(1),
];
check_eval_with_args(
&program,
Err(Error::TooManyIterations),
encoding4(),
None,
None,
Some(150),
|_, _| panic!(),
);
}
#[test]
fn test_eval_typed_stack() {
use self::AssemblerEntry::*;
use crate::constants::*;
let base_types = [
ValueType::Generic,
ValueType::U16,
ValueType::U32,
ValueType::F32,
];
// TODO: convert, reinterpret
#[rustfmt::skip]
let tests = [
(
&[
Op(DW_OP_const_type), Uleb(1), U8(2), U16(0x1234),
Op(DW_OP_stack_value),
][..],
Value::U16(0x1234),
),
(
&[
Op(DW_OP_regval_type), Uleb(0x1234), Uleb(1),
Op(DW_OP_stack_value),
][..],
Value::U16(0x2340),
),
(
&[
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_deref_type), U8(2), Uleb(1),
Op(DW_OP_stack_value),
][..],
Value::U16(0xfff0),
),
(
&[
Op(DW_OP_lit1),
Op(DW_OP_addr), U32(0x7fff_ffff),
Op(DW_OP_xderef_type), U8(2), Uleb(1),
Op(DW_OP_stack_value),
][..],
Value::U16(0xfff1),
),
(
&[
Op(DW_OP_const_type), Uleb(1), U8(2), U16(0x1234),
Op(DW_OP_convert), Uleb(2),
Op(DW_OP_stack_value),
][..],
Value::U32(0x1234),
),
(
&[
Op(DW_OP_const_type), Uleb(2), U8(4), U32(0x3f80_0000),
Op(DW_OP_reinterpret), Uleb(3),
Op(DW_OP_stack_value),
][..],
Value::F32(1.0),
),
];
for &(program, value) in &tests {
let result = [Piece {
size_in_bits: None,
bit_offset: None,
location: Location::Value { value },
}];
check_eval_with_args(
program,
Ok(&result),
encoding4(),
None,
None,
None,
|eval, mut result| {
while result != EvaluationResult::Complete {
result = match result {
EvaluationResult::RequiresMemory {
address,
size,
space,
base_type,
} => {
let mut v = address << 4;
if let Some(value) = space {
v += value;
}
v &= (1u64 << (8 * size)) - 1;
let v = Value::from_u64(base_types[base_type.0], v)?;
eval.resume_with_memory(v)?
}
EvaluationResult::RequiresRegister {
register,
base_type,
} => {
let v = Value::from_u64(
base_types[base_type.0],
u64::from(register.0) << 4,
)?;
eval.resume_with_register(v)?
}
EvaluationResult::RequiresBaseType(offset) => {
eval.resume_with_base_type(base_types[offset.0])?
}
EvaluationResult::RequiresRelocatedAddress(address) => {
eval.resume_with_relocated_address(address)?
}
_ => panic!("Unexpected result {:?}", result),
}
}
Ok(result)
},
);
}
}
}
Reference in a new issue View git blame Copy permalink