Quelle line.rs
Sprache: unbekannt
|
|
use alloc::vec::Vec;
use indexmap::{IndexMap, IndexSet};
use std::ops::{Deref, DerefMut};
use crate::common::{DebugLineOffset, Encoding, Format, LineEncoding, SectionId};
use crate::constants;
use crate::leb128;
use crate::write::{
Address, DebugLineStrOffsets, DebugStrOffsets, Error, LineStringId, LineStringTable, Result,
Section, StringId, Writer,
};
/// The number assigned to the first special opcode.
//
// We output all instructions for all DWARF versions, since readers
// should be able to ignore instructions they don't support.
const OPCODE_BASE: u8 = 13;
/// A line number program.
#[derive(Debug, Clone)]
pub struct LineProgram {
/// True if this line program was created with `LineProgram::none()`.
none: bool,
encoding: Encoding,
line_encoding: LineEncoding,
/// A list of source directory path names.
///
/// If a path is relative, then the directory is located relative to the working
/// directory of the compilation unit.
///
/// The first entry is for the working directory of the compilation unit.
directories: IndexSet<LineString>,
/// A list of source file entries.
///
/// Each entry has a path name and a directory.
///
/// If a path is a relative, then the file is located relative to the
/// directory. Otherwise the directory is meaningless.
///
/// Does not include comp_file, even for version >= 5.
files: IndexMap<(LineString, DirectoryId), FileInfo>,
/// The primary source file of the compilation unit.
/// This is required for version >= 5, but we never reference it elsewhere
/// because DWARF defines DW_AT_decl_file=0 to mean not specified.
comp_file: (LineString, FileInfo),
/// True if the file entries may have valid timestamps.
///
/// Entries may still have a timestamp of 0 even if this is set.
/// For version <= 4, this is ignored.
/// For version 5, this controls whether to emit `DW_LNCT_timestamp`.
pub file_has_timestamp: bool,
/// True if the file entries may have valid sizes.
///
/// Entries may still have a size of 0 even if this is set.
/// For version <= 4, this is ignored.
/// For version 5, this controls whether to emit `DW_LNCT_size`.
pub file_has_size: bool,
/// True if the file entries have valid MD5 checksums.
///
/// For version <= 4, this is ignored.
/// For version 5, this controls whether to emit `DW_LNCT_MD5`.
pub file_has_md5: bool,
prev_row: LineRow,
row: LineRow,
// TODO: this probably should be either rows or sequences instead
instructions: Vec<LineInstruction>,
in_sequence: bool,
}
impl LineProgram {
/// Create a new `LineProgram`.
///
/// `comp_dir` defines the working directory of the compilation unit,
/// and must be the same as the `DW_AT_comp_dir` attribute
/// of the compilation unit DIE.
///
/// `comp_file` and `comp_file_info` define the primary source file
/// of the compilation unit and must be the same as the `DW_AT_name`
/// attribute of the compilation unit DIE.
///
/// # Panics
///
/// Panics if `line_encoding.line_base` > 0.
///
/// Panics if `line_encoding.line_base` + `line_encoding.line_range` <= 0.
///
/// Panics if `comp_dir` is empty or contains a null byte.
///
/// Panics if `comp_file` is empty or contains a null byte.
pub fn new(
encoding: Encoding,
line_encoding: LineEncoding,
comp_dir: LineString,
comp_file: LineString,
comp_file_info: Option<FileInfo>,
) -> LineProgram {
// We require a special opcode for a line advance of 0.
// See the debug_asserts in generate_row().
assert!(line_encoding.line_base <= 0);
assert!(line_encoding.line_base + line_encoding.line_range as i8 > 0);
let mut program = LineProgram {
none: false,
encoding,
line_encoding,
directories: IndexSet::new(),
files: IndexMap::new(),
comp_file: (comp_file, comp_file_info.unwrap_or_default()),
prev_row: LineRow::initial_state(line_encoding),
row: LineRow::initial_state(line_encoding),
instructions: Vec::new(),
in_sequence: false,
file_has_timestamp: false,
file_has_size: false,
file_has_md5: false,
};
// For all DWARF versions, directory index 0 is comp_dir.
// For version <= 4, the entry is implicit. We still add
// it here so that we use it, but we don't emit it.
program.add_directory(comp_dir);
program
}
/// Create a new `LineProgram` with no fields set.
///
/// This can be used when the `LineProgram` will not be used.
///
/// You should not attempt to add files or line instructions to
/// this line program, or write it to the `.debug_line` section.
pub fn none() -> Self {
let line_encoding = LineEncoding::default();
LineProgram {
none: true,
encoding: Encoding {
format: Format::Dwarf32,
version: 2,
address_size: 0,
},
line_encoding,
directories: IndexSet::new(),
files: IndexMap::new(),
comp_file: (LineString::String(Vec::new()), FileInfo::default()),
prev_row: LineRow::initial_state(line_encoding),
row: LineRow::initial_state(line_encoding),
instructions: Vec::new(),
in_sequence: false,
file_has_timestamp: false,
file_has_size: false,
file_has_md5: false,
}
}
/// Return true if this line program was created with `LineProgram::none()`.
#[inline]
pub fn is_none(&self) -> bool {
self.none
}
/// Return the encoding parameters for this line program.
#[inline]
pub fn encoding(&self) -> Encoding {
self.encoding
}
/// Return the DWARF version for this line program.
#[inline]
pub fn version(&self) -> u16 {
self.encoding.version
}
/// Return the address size in bytes for this line program.
#[inline]
pub fn address_size(&self) -> u8 {
self.encoding.address_size
}
/// Return the DWARF format for this line program.
#[inline]
pub fn format(&self) -> Format {
self.encoding.format
}
/// Return the id for the working directory of the compilation unit.
#[inline]
pub fn default_directory(&self) -> DirectoryId {
DirectoryId(0)
}
/// Add a directory entry and return its id.
///
/// If the directory already exists, then return the id of the existing entry.
///
/// If the path is relative, then the directory is located relative to the working
/// directory of the compilation unit.
///
/// # Panics
///
/// Panics if `directory` is empty or contains a null byte.
pub fn add_directory(&mut self, directory: LineString) -> DirectoryId {
if let LineString::String(ref val) = directory {
// For DWARF version <= 4, directories must not be empty.
// The first directory isn't emitted so skip the check for it.
if self.encoding.version <= 4 && !self.directories.is_empty() {
assert!(!val.is_empty());
}
assert!(!val.contains(&0));
}
let (index, _) = self.directories.insert_full(directory);
DirectoryId(index)
}
/// Get a reference to a directory entry.
///
/// # Panics
///
/// Panics if `id` is invalid.
pub fn get_directory(&self, id: DirectoryId) -> &LineString {
self.directories.get_index(id.0).unwrap()
}
/// Add a file entry and return its id.
///
/// If the file already exists, then return the id of the existing entry.
///
/// If the file path is relative, then the file is located relative
/// to the directory. Otherwise the directory is meaningless, but it
/// is still used as a key for file entries.
///
/// If `info` is `None`, then new entries are assigned
/// default information, and existing entries are unmodified.
///
/// If `info` is not `None`, then it is always assigned to the
/// entry, even if the entry already exists.
///
/// # Panics
///
/// Panics if 'file' is empty or contains a null byte.
pub fn add_file(
&mut self,
file: LineString,
directory: DirectoryId,
info: Option<FileInfo>,
) -> FileId {
if let LineString::String(ref val) = file {
assert!(!val.is_empty());
assert!(!val.contains(&0));
}
let key = (file, directory);
let index = if let Some(info) = info {
let (index, _) = self.files.insert_full(key, info);
index
} else {
let entry = self.files.entry(key);
let index = entry.index();
entry.or_default();
index
};
FileId::new(index)
}
/// Get a reference to a file entry.
///
/// # Panics
///
/// Panics if `id` is invalid.
pub fn get_file(&self, id: FileId) -> (&LineString, DirectoryId) {
match id.index() {
None => (&self.comp_file.0, DirectoryId(0)),
Some(index) => self
.files
.get_index(index)
.map(|entry| (&(entry.0).0, (entry.0).1))
.unwrap(),
}
}
/// Get a reference to the info for a file entry.
///
/// # Panics
///
/// Panics if `id` is invalid.
pub fn get_file_info(&self, id: FileId) -> &FileInfo {
match id.index() {
None => &self.comp_file.1,
Some(index) => self.files.get_index(index).map(|entry| entry.1).unwrap(),
}
}
/// Get a mutable reference to the info for a file entry.
///
/// # Panics
///
/// Panics if `id` is invalid.
pub fn get_file_info_mut(&mut self, id: FileId) -> &mut FileInfo {
match id.index() {
None => &mut self.comp_file.1,
Some(index) => self
.files
.get_index_mut(index)
.map(|entry| entry.1)
.unwrap(),
}
}
/// Begin a new sequence and set its base address.
///
/// # Panics
///
/// Panics if a sequence has already begun.
pub fn begin_sequence(&mut self, address: Option<Address>) {
assert!(!self.in_sequence);
self.in_sequence = true;
if let Some(address) = address {
self.instructions.push(LineInstruction::SetAddress(address));
}
}
/// End the sequence, and reset the row to its default values.
///
/// Only the `address_offset` and op_index` fields of the current row are used.
///
/// # Panics
///
/// Panics if a sequence has not begun.
pub fn end_sequence(&mut self, address_offset: u64) {
assert!(self.in_sequence);
self.in_sequence = false;
self.row.address_offset = address_offset;
let op_advance = self.op_advance();
if op_advance != 0 {
self.instructions
.push(LineInstruction::AdvancePc(op_advance));
}
self.instructions.push(LineInstruction::EndSequence);
self.prev_row = LineRow::initial_state(self.line_encoding);
self.row = LineRow::initial_state(self.line_encoding);
}
/// Return true if a sequence has begun.
#[inline]
pub fn in_sequence(&self) -> bool {
self.in_sequence
}
/// Returns a reference to the data for the current row.
#[inline]
pub fn row(&mut self) -> &mut LineRow {
&mut self.row
}
/// Generates the line number information instructions for the current row.
///
/// After the instructions are generated, it sets `discriminator` to 0, and sets
/// `basic_block`, `prologue_end`, and `epilogue_begin` to false.
///
/// # Panics
///
/// Panics if a sequence has not begun.
/// Panics if the address_offset decreases.
pub fn generate_row(&mut self) {
assert!(self.in_sequence);
// Output fields that are reset on every row.
if self.row.discriminator != 0 {
self.instructions
.push(LineInstruction::SetDiscriminator(self.row.discriminator));
self.row.discriminator = 0;
}
if self.row.basic_block {
self.instructions.push(LineInstruction::SetBasicBlock);
self.row.basic_block = false;
}
if self.row.prologue_end {
self.instructions.push(LineInstruction::SetPrologueEnd);
self.row.prologue_end = false;
}
if self.row.epilogue_begin {
self.instructions.push(LineInstruction::SetEpilogueBegin);
self.row.epilogue_begin = false;
}
// Output fields that are not reset on every row.
if self.row.is_statement != self.prev_row.is_statement {
self.instructions.push(LineInstruction::NegateStatement);
}
if self.row.file != self.prev_row.file {
self.instructions
.push(LineInstruction::SetFile(self.row.file));
}
if self.row.column != self.prev_row.column {
self.instructions
.push(LineInstruction::SetColumn(self.row.column));
}
if self.row.isa != self.prev_row.isa {
self.instructions
.push(LineInstruction::SetIsa(self.row.isa));
}
// Advance the line, address, and operation index.
let line_base = i64::from(self.line_encoding.line_base) as u64;
let line_range = u64::from(self.line_encoding.line_range);
let line_advance = self.row.line as i64 - self.prev_row.line as i64;
let op_advance = self.op_advance();
// Default to special advances of 0.
let special_base = u64::from(OPCODE_BASE);
// TODO: handle lack of special opcodes for 0 line advance
debug_assert!(self.line_encoding.line_base <= 0);
debug_assert!(self.line_encoding.line_base + self.line_encoding.line_range as i8 >= 0);
let special_default = special_base.wrapping_sub(line_base);
let mut special = special_default;
let mut use_special = false;
if line_advance != 0 {
let special_line = (line_advance as u64).wrapping_sub(line_base);
if special_line < line_range {
special = special_base + special_line;
use_special = true;
} else {
self.instructions
.push(LineInstruction::AdvanceLine(line_advance));
}
}
if op_advance != 0 {
// Using ConstAddPc can save a byte.
let (special_op_advance, const_add_pc) = if special + op_advance * line_range <= 255 {
(op_advance, false)
} else {
let op_range = (255 - special_base) / line_range;
(op_advance - op_range, true)
};
let special_op = special_op_advance * line_range;
if special + special_op <= 255 {
special += special_op;
use_special = true;
if const_add_pc {
self.instructions.push(LineInstruction::ConstAddPc);
}
} else {
self.instructions
.push(LineInstruction::AdvancePc(op_advance));
}
}
if use_special && special != special_default {
debug_assert!(special >= special_base);
debug_assert!(special <= 255);
self.instructions
.push(LineInstruction::Special(special as u8));
} else {
self.instructions.push(LineInstruction::Copy);
}
self.prev_row = self.row;
}
fn op_advance(&self) -> u64 {
debug_assert!(self.row.address_offset >= self.prev_row.address_offset);
let mut address_advance = self.row.address_offset - self.prev_row.address_offset;
if self.line_encoding.minimum_instruction_length != 1 {
debug_assert_eq!(
self.row.address_offset % u64::from(self.line_encoding.minimum_instruction_length),
0
);
address_advance /= u64::from(self.line_encoding.minimum_instruction_length);
}
address_advance * u64::from(self.line_encoding.maximum_operations_per_instruction)
+ self.row.op_index
- self.prev_row.op_index
}
/// Returns true if the line number program has no instructions.
///
/// Does not check the file or directory entries.
#[inline]
pub fn is_empty(&self) -> bool {
self.instructions.is_empty()
}
/// Write the line number program to the given section.
///
/// # Panics
///
/// Panics if `self.is_none()`.
pub fn write<W: Writer>(
&self,
w: &mut DebugLine<W>,
encoding: Encoding,
debug_line_str_offsets: &DebugLineStrOffsets,
debug_str_offsets: &DebugStrOffsets,
) -> Result<DebugLineOffset> {
assert!(!self.is_none());
if encoding.version < self.version()
|| encoding.format != self.format()
|| encoding.address_size != self.address_size()
{
return Err(Error::IncompatibleLineProgramEncoding);
}
let offset = w.offset();
let length_offset = w.write_initial_length(self.format())?;
let length_base = w.len();
if self.version() < 2 || self.version() > 5 {
return Err(Error::UnsupportedVersion(self.version()));
}
w.write_u16(self.version())?;
if self.version() >= 5 {
w.write_u8(self.address_size())?;
// Segment selector size.
w.write_u8(0)?;
}
let header_length_offset = w.len();
w.write_udata(0, self.format().word_size())?;
let header_length_base = w.len();
w.write_u8(self.line_encoding.minimum_instruction_length)?;
if self.version() >= 4 {
w.write_u8(self.line_encoding.maximum_operations_per_instruction)?;
} else if self.line_encoding.maximum_operations_per_instruction != 1 {
return Err(Error::NeedVersion(4));
};
w.write_u8(if self.line_encoding.default_is_stmt {
1
} else {
0
})?;
w.write_u8(self.line_encoding.line_base as u8)?;
w.write_u8(self.line_encoding.line_range)?;
w.write_u8(OPCODE_BASE)?;
w.write(&[0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1])?;
if self.version() <= 4 {
// The first directory is stored as DW_AT_comp_dir.
for dir in self.directories.iter().skip(1) {
dir.write(
w,
constants::DW_FORM_string,
self.encoding,
debug_line_str_offsets,
debug_str_offsets,
)?;
}
w.write_u8(0)?;
for ((file, dir), info) in self.files.iter() {
file.write(
w,
constants::DW_FORM_string,
self.encoding,
debug_line_str_offsets,
debug_str_offsets,
)?;
w.write_uleb128(dir.0 as u64)?;
w.write_uleb128(info.timestamp)?;
w.write_uleb128(info.size)?;
}
w.write_u8(0)?;
} else {
// Directory entry formats (only ever 1).
w.write_u8(1)?;
w.write_uleb128(u64::from(constants::DW_LNCT_path.0))?;
let dir_form = self.directories.get_index(0).unwrap().form();
w.write_uleb128(dir_form.0.into())?;
// Directory entries.
w.write_uleb128(self.directories.len() as u64)?;
for dir in self.directories.iter() {
dir.write(
w,
dir_form,
self.encoding,
debug_line_str_offsets,
debug_str_offsets,
)?;
}
// File name entry formats.
let count = 2
+ if self.file_has_timestamp { 1 } else { 0 }
+ if self.file_has_size { 1 } else { 0 }
+ if self.file_has_md5 { 1 } else { 0 };
w.write_u8(count)?;
w.write_uleb128(u64::from(constants::DW_LNCT_path.0))?;
let file_form = self.comp_file.0.form();
w.write_uleb128(file_form.0.into())?;
w.write_uleb128(u64::from(constants::DW_LNCT_directory_index.0))?;
w.write_uleb128(constants::DW_FORM_udata.0.into())?;
if self.file_has_timestamp {
w.write_uleb128(u64::from(constants::DW_LNCT_timestamp.0))?;
w.write_uleb128(constants::DW_FORM_udata.0.into())?;
}
if self.file_has_size {
w.write_uleb128(u64::from(constants::DW_LNCT_size.0))?;
w.write_uleb128(constants::DW_FORM_udata.0.into())?;
}
if self.file_has_md5 {
w.write_uleb128(u64::from(constants::DW_LNCT_MD5.0))?;
w.write_uleb128(constants::DW_FORM_data16.0.into())?;
}
// File name entries.
w.write_uleb128(self.files.len() as u64 + 1)?;
let mut write_file = |file: &LineString, dir: DirectoryId, info: &FileInfo| {
file.write(
w,
file_form,
self.encoding,
debug_line_str_offsets,
debug_str_offsets,
)?;
w.write_uleb128(dir.0 as u64)?;
if self.file_has_timestamp {
w.write_uleb128(info.timestamp)?;
}
if self.file_has_size {
w.write_uleb128(info.size)?;
}
if self.file_has_md5 {
w.write(&info.md5)?;
}
Ok(())
};
write_file(&self.comp_file.0, DirectoryId(0), &self.comp_file.1)?;
for ((file, dir), info) in self.files.iter() {
write_file(file, *dir, info)?;
}
}
let header_length = (w.len() - header_length_base) as u64;
w.write_udata_at(
header_length_offset,
header_length,
self.format().word_size(),
)?;
for instruction in &self.instructions {
instruction.write(w, self.address_size())?;
}
let length = (w.len() - length_base) as u64;
w.write_initial_length_at(length_offset, length, self.format())?;
Ok(offset)
}
}
/// A row in the line number table that corresponds to a machine instruction.
#[derive(Debug, Clone, Copy)]
pub struct LineRow {
/// The offset of the instruction from the start address of the sequence.
pub address_offset: u64,
/// The index of an operation within a VLIW instruction.
///
/// The index of the first operation is 0.
/// Set to 0 for non-VLIW instructions.
pub op_index: u64,
/// The source file corresponding to the instruction.
pub file: FileId,
/// The line number within the source file.
///
/// Lines are numbered beginning at 1. Set to 0 if there is no source line.
pub line: u64,
/// The column number within the source line.
///
/// Columns are numbered beginning at 1. Set to 0 for the "left edge" of the line.
pub column: u64,
/// An additional discriminator used to distinguish between source locations.
/// This value is assigned arbitrarily by the DWARF producer.
pub discriminator: u64,
/// Set to true if the instruction is a recommended breakpoint for a statement.
pub is_statement: bool,
/// Set to true if the instruction is the beginning of a basic block.
pub basic_block: bool,
/// Set to true if the instruction is a recommended breakpoint at the entry of a
/// function.
pub prologue_end: bool,
/// Set to true if the instruction is a recommended breakpoint prior to the exit of
/// a function.
pub epilogue_begin: bool,
/// The instruction set architecture of the instruction.
///
/// Set to 0 for the default ISA. Other values are defined by the architecture ABI.
pub isa: u64,
}
impl LineRow {
/// Return the initial state as specified in the DWARF standard.
fn initial_state(line_encoding: LineEncoding) -> Self {
LineRow {
address_offset: 0,
op_index: 0,
file: FileId::initial_state(),
line: 1,
column: 0,
discriminator: 0,
is_statement: line_encoding.default_is_stmt,
basic_block: false,
prologue_end: false,
epilogue_begin: false,
isa: 0,
}
}
}
/// An instruction in a line number program.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LineInstruction {
// Special opcodes
Special(u8),
// Standard opcodes
Copy,
AdvancePc(u64),
AdvanceLine(i64),
SetFile(FileId),
SetColumn(u64),
NegateStatement,
SetBasicBlock,
ConstAddPc,
// DW_LNS_fixed_advance_pc is not supported.
SetPrologueEnd,
SetEpilogueBegin,
SetIsa(u64),
// Extended opcodes
EndSequence,
// TODO: this doubles the size of this enum.
SetAddress(Address),
// DW_LNE_define_file is not supported.
SetDiscriminator(u64),
}
impl LineInstruction {
/// Write the line number instruction to the given section.
fn write<W: Writer>(self, w: &mut DebugLine<W>, address_size: u8) -> Result<()> {
use self::LineInstruction::*;
match self {
Special(val) => w.write_u8(val)?,
Copy => w.write_u8(constants::DW_LNS_copy.0)?,
AdvancePc(val) => {
w.write_u8(constants::DW_LNS_advance_pc.0)?;
w.write_uleb128(val)?;
}
AdvanceLine(val) => {
w.write_u8(constants::DW_LNS_advance_line.0)?;
w.write_sleb128(val)?;
}
SetFile(val) => {
w.write_u8(constants::DW_LNS_set_file.0)?;
w.write_uleb128(val.raw())?;
}
SetColumn(val) => {
w.write_u8(constants::DW_LNS_set_column.0)?;
w.write_uleb128(val)?;
}
NegateStatement => w.write_u8(constants::DW_LNS_negate_stmt.0)?,
SetBasicBlock => w.write_u8(constants::DW_LNS_set_basic_block.0)?,
ConstAddPc => w.write_u8(constants::DW_LNS_const_add_pc.0)?,
SetPrologueEnd => w.write_u8(constants::DW_LNS_set_prologue_end.0)?,
SetEpilogueBegin => w.write_u8(constants::DW_LNS_set_epilogue_begin.0)?,
SetIsa(val) => {
w.write_u8(constants::DW_LNS_set_isa.0)?;
w.write_uleb128(val)?;
}
EndSequence => {
w.write_u8(0)?;
w.write_uleb128(1)?;
w.write_u8(constants::DW_LNE_end_sequence.0)?;
}
SetAddress(address) => {
w.write_u8(0)?;
w.write_uleb128(1 + u64::from(address_size))?;
w.write_u8(constants::DW_LNE_set_address.0)?;
w.write_address(address, address_size)?;
}
SetDiscriminator(val) => {
let mut bytes = [0u8; 10];
// bytes is long enough so this will never fail.
let len = leb128::write::unsigned(&mut { &mut bytes[..] }, val).unwrap();
w.write_u8(0)?;
w.write_uleb128(1 + len as u64)?;
w.write_u8(constants::DW_LNE_set_discriminator.0)?;
w.write(&bytes[..len])?;
}
}
Ok(())
}
}
/// A string value for use in defining paths in line number programs.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum LineString {
/// A slice of bytes representing a string. Must not include null bytes.
/// Not guaranteed to be UTF-8 or anything like that.
String(Vec<u8>),
/// A reference to a string in the `.debug_str` section.
StringRef(StringId),
/// A reference to a string in the `.debug_line_str` section.
LineStringRef(LineStringId),
}
impl LineString {
/// Create a `LineString` using the normal form for the given encoding.
pub fn new<T>(val: T, encoding: Encoding, line_strings: &mut LineStringTable) -> Self
where
T: Into<Vec<u8>>,
{
let val = val.into();
if encoding.version <= 4 {
LineString::String(val)
} else {
LineString::LineStringRef(line_strings.add(val))
}
}
fn form(&self) -> constants::DwForm {
match *self {
LineString::String(..) => constants::DW_FORM_string,
LineString::StringRef(..) => constants::DW_FORM_strp,
LineString::LineStringRef(..) => constants::DW_FORM_line_strp,
}
}
fn write<W: Writer>(
&self,
w: &mut DebugLine<W>,
form: constants::DwForm,
encoding: Encoding,
debug_line_str_offsets: &DebugLineStrOffsets,
debug_str_offsets: &DebugStrOffsets,
) -> Result<()> {
if form != self.form() {
return Err(Error::LineStringFormMismatch);
}
match *self {
LineString::String(ref val) => {
if encoding.version <= 4 {
debug_assert!(!val.is_empty());
}
w.write(val)?;
w.write_u8(0)?;
}
LineString::StringRef(val) => {
if encoding.version < 5 {
return Err(Error::NeedVersion(5));
}
w.write_offset(
debug_str_offsets.get(val).0,
SectionId::DebugStr,
encoding.format.word_size(),
)?;
}
LineString::LineStringRef(val) => {
if encoding.version < 5 {
return Err(Error::NeedVersion(5));
}
w.write_offset(
debug_line_str_offsets.get(val).0,
SectionId::DebugLineStr,
encoding.format.word_size(),
)?;
}
}
Ok(())
}
}
/// An identifier for a directory in a `LineProgram`.
///
/// Defaults to the working directory of the compilation unit.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DirectoryId(usize);
// Force FileId access via the methods.
mod id {
/// An identifier for a file in a `LineProgram`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FileId(usize);
impl FileId {
/// Create a FileId given an index into `LineProgram::files`.
pub(crate) fn new(index: usize) -> Self {
FileId(index + 1)
}
/// The index of the file in `LineProgram::files`.
pub(super) fn index(self) -> Option<usize> {
if self.0 == 0 {
None
} else {
Some(self.0 - 1)
}
}
/// The initial state of the file register.
pub(super) fn initial_state() -> Self {
FileId(1)
}
/// The raw value used when writing.
pub(crate) fn raw(self) -> u64 {
self.0 as u64
}
/// The id for file index 0 in DWARF version 5.
/// Only used when converting.
// Used for tests only.
#[allow(unused)]
pub(super) fn zero() -> Self {
FileId(0)
}
}
}
pub use self::id::*;
/// Extra information for file in a `LineProgram`.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct FileInfo {
/// The implementation defined timestamp of the last modification of the file,
/// or 0 if not available.
pub timestamp: u64,
/// The size of the file in bytes, or 0 if not available.
pub size: u64,
/// A 16-byte MD5 digest of the file contents.
///
/// Only used if version >= 5 and `LineProgram::file_has_md5` is `true`.
pub md5: [u8; 16],
}
define_section!(
DebugLine,
DebugLineOffset,
"A writable `.debug_line` section."
);
#[cfg(feature = "read")]
mod convert {
use super::*;
use crate::read::{self, Reader};
use crate::write::{self, ConvertError, ConvertResult};
impl LineProgram {
/// Create a line number program by reading the data from the given program.
///
/// Return the program and a mapping from file index to `FileId`.
pub fn from<R: Reader<Offset = usize>>(
mut from_program: read::IncompleteLineProgram<R>,
dwarf: &read::Dwarf<R>,
line_strings: &mut write::LineStringTable,
strings: &mut write::StringTable,
convert_address: &dyn Fn(u64) -> Option<Address>,
) -> ConvertResult<(LineProgram, Vec<FileId>)> {
// Create mappings in case the source has duplicate files or directories.
let mut dirs = Vec::new();
let mut files = Vec::new();
let mut program = {
let from_header = from_program.header();
let encoding = from_header.encoding();
let comp_dir = match from_header.directory(0) {
Some(comp_dir) => LineString::from(comp_dir, dwarf, line_strings, strings)?,
None => LineString::new(&[][..], encoding, line_strings),
};
let (comp_name, comp_file_info) = match from_header.file(0) {
Some(comp_file) => {
if comp_file.directory_index() != 0 {
return Err(ConvertError::InvalidDirectoryIndex);
}
(
LineString::from(comp_file.path_name(), dwarf, line_strings, strings)?,
Some(FileInfo {
timestamp: comp_file.timestamp(),
size: comp_file.size(),
md5: *comp_file.md5(),
}),
)
}
None => (LineString::new(&[][..], encoding, line_strings), None),
};
if from_header.line_base() > 0 {
return Err(ConvertError::InvalidLineBase);
}
let mut program = LineProgram::new(
encoding,
from_header.line_encoding(),
comp_dir,
comp_name,
comp_file_info,
);
let file_skip;
if from_header.version() <= 4 {
// The first directory is implicit.
dirs.push(DirectoryId(0));
// A file index of 0 is invalid for version <= 4, but putting
// something there makes the indexing easier.
file_skip = 0;
files.push(FileId::zero());
} else {
// We don't add the first file to `files`, but still allow
// it to be referenced from converted instructions.
file_skip = 1;
files.push(FileId::zero());
}
for from_dir in from_header.include_directories() {
let from_dir =
LineString::from(from_dir.clone(), dwarf, line_strings, strings)?;
dirs.push(program.add_directory(from_dir));
}
program.file_has_timestamp = from_header.file_has_timestamp();
program.file_has_size = from_header.file_has_size();
program.file_has_md5 = from_header.file_has_md5();
for from_file in from_header.file_names().iter().skip(file_skip) {
let from_name =
LineString::from(from_file.path_name(), dwarf, line_strings, strings)?;
let from_dir = from_file.directory_index();
if from_dir >= dirs.len() as u64 {
return Err(ConvertError::InvalidDirectoryIndex);
}
let from_dir = dirs[from_dir as usize];
let from_info = Some(FileInfo {
timestamp: from_file.timestamp(),
size: from_file.size(),
md5: *from_file.md5(),
});
files.push(program.add_file(from_name, from_dir, from_info));
}
program
};
// We can't use the `from_program.rows()` because that wouldn't let
// us preserve address relocations.
let mut from_row = read::LineRow::new(from_program.header());
let mut instructions = from_program.header().instructions();
let mut address = None;
while let Some(instruction) = instructions.next_instruction(from_program.header())? {
match instruction {
read::LineInstruction::SetAddress(val) => {
if program.in_sequence() {
return Err(ConvertError::UnsupportedLineInstruction);
}
match convert_address(val) {
Some(val) => address = Some(val),
None => return Err(ConvertError::InvalidAddress),
}
from_row.execute(read::LineInstruction::SetAddress(0), &mut from_program);
}
read::LineInstruction::DefineFile(_) => {
return Err(ConvertError::UnsupportedLineInstruction);
}
_ => {
if from_row.execute(instruction, &mut from_program) {
if !program.in_sequence() {
program.begin_sequence(address);
address = None;
}
if from_row.end_sequence() {
program.end_sequence(from_row.address());
} else {
program.row().address_offset = from_row.address();
program.row().op_index = from_row.op_index();
program.row().file = {
let file = from_row.file_index();
if file >= files.len() as u64 {
return Err(ConvertError::InvalidFileIndex);
}
if file == 0 && program.version() <= 4 {
return Err(ConvertError::InvalidFileIndex);
}
files[file as usize]
};
program.row().line = match from_row.line() {
Some(line) => line.get(),
None => 0,
};
program.row().column = match from_row.column() {
read::ColumnType::LeftEdge => 0,
read::ColumnType::Column(val) => val.get(),
};
program.row().discriminator = from_row.discriminator();
program.row().is_statement = from_row.is_stmt();
program.row().basic_block = from_row.basic_block();
program.row().prologue_end = from_row.prologue_end();
program.row().epilogue_begin = from_row.epilogue_begin();
program.row().isa = from_row.isa();
program.generate_row();
}
from_row.reset(from_program.header());
}
}
};
}
Ok((program, files))
}
}
impl LineString {
fn from<R: Reader<Offset = usize>>(
from_attr: read::AttributeValue<R>,
dwarf: &read::Dwarf<R>,
line_strings: &mut write::LineStringTable,
strings: &mut write::StringTable,
) -> ConvertResult<LineString> {
Ok(match from_attr {
read::AttributeValue::String(r) => LineString::String(r.to_slice()?.to_vec()),
read::AttributeValue::DebugStrRef(offset) => {
let r = dwarf.debug_str.get_str(offset)?;
let id = strings.add(r.to_slice()?);
LineString::StringRef(id)
}
read::AttributeValue::DebugLineStrRef(offset) => {
let r = dwarf.debug_line_str.get_str(offset)?;
let id = line_strings.add(r.to_slice()?);
LineString::LineStringRef(id)
}
_ => return Err(ConvertError::UnsupportedLineStringForm),
})
}
}
}
#[cfg(test)]
#[cfg(feature = "read")]
mod tests {
use super::*;
use crate::read;
use crate::write::{DebugLineStr, DebugStr, EndianVec, StringTable};
use crate::LittleEndian;
#[test]
fn test_line_program_table() {
let dir1 = LineString::String(b"dir1".to_vec());
let file1 = LineString::String(b"file1".to_vec());
let dir2 = LineString::String(b"dir2".to_vec());
let file2 = LineString::String(b"file2".to_vec());
let mut programs = Vec::new();
for &version in &[2, 3, 4, 5] {
for &address_size in &[4, 8] {
for &format in &[Format::Dwarf32, Format::Dwarf64] {
let encoding = Encoding {
format,
version,
address_size,
};
let mut program = LineProgram::new(
encoding,
LineEncoding::default(),
dir1.clone(),
file1.clone(),
None,
);
{
assert_eq!(&dir1, program.get_directory(program.default_directory()));
program.file_has_timestamp = true;
program.file_has_size = true;
if encoding.version >= 5 {
program.file_has_md5 = true;
}
let dir_id = program.add_directory(dir2.clone());
assert_eq!(&dir2, program.get_directory(dir_id));
assert_eq!(dir_id, program.add_directory(dir2.clone()));
let file_info = FileInfo {
timestamp: 1,
size: 2,
md5: if encoding.version >= 5 {
[3; 16]
} else {
[0; 16]
},
};
let file_id = program.add_file(file2.clone(), dir_id, Some(file_info));
assert_eq!((&file2, dir_id), program.get_file(file_id));
assert_eq!(file_info, *program.get_file_info(file_id));
program.get_file_info_mut(file_id).size = 3;
assert_ne!(file_info, *program.get_file_info(file_id));
assert_eq!(file_id, program.add_file(file2.clone(), dir_id, None));
assert_ne!(file_info, *program.get_file_info(file_id));
assert_eq!(
file_id,
program.add_file(file2.clone(), dir_id, Some(file_info))
);
assert_eq!(file_info, *program.get_file_info(file_id));
programs.push((program, file_id, encoding));
}
}
}
}
let debug_line_str_offsets = DebugLineStrOffsets::none();
let debug_str_offsets = DebugStrOffsets::none();
let mut debug_line = DebugLine::from(EndianVec::new(LittleEndian));
let mut debug_line_offsets = Vec::new();
for (program, _, encoding) in &programs {
debug_line_offsets.push(
program
.write(
&mut debug_line,
*encoding,
&debug_line_str_offsets,
&debug_str_offsets,
)
.unwrap(),
);
}
let read_debug_line = read::DebugLine::new(debug_line.slice(), LittleEndian);
let convert_address = &|address| Some(Address::Constant(address));
for ((program, file_id, encoding), offset) in programs.iter().zip(debug_line_offsets.iter())
{
let read_program = read_debug_line
.program(
*offset,
encoding.address_size,
Some(read::EndianSlice::new(b"dir1", LittleEndian)),
Some(read::EndianSlice::new(b"file1", LittleEndian)),
)
.unwrap();
let dwarf = read::Dwarf::default();
let mut convert_line_strings = LineStringTable::default();
let mut convert_strings = StringTable::default();
let (convert_program, convert_files) = LineProgram::from(
read_program,
&dwarf,
&mut convert_line_strings,
&mut convert_strings,
convert_address,
)
.unwrap();
assert_eq!(convert_program.version(), program.version());
assert_eq!(convert_program.address_size(), program.address_size());
assert_eq!(convert_program.format(), program.format());
let convert_file_id = convert_files[file_id.raw() as usize];
let (file, dir) = program.get_file(*file_id);
let (convert_file, convert_dir) = convert_program.get_file(convert_file_id);
assert_eq!(file, convert_file);
assert_eq!(
program.get_directory(dir),
convert_program.get_directory(convert_dir)
);
assert_eq!(
program.get_file_info(*file_id),
convert_program.get_file_info(convert_file_id)
);
}
}
#[test]
fn test_line_row() {
let dir1 = &b"dir1"[..];
let file1 = &b"file1"[..];
let file2 = &b"file2"[..];
let convert_address = &|address| Some(Address::Constant(address));
let debug_line_str_offsets = DebugLineStrOffsets::none();
let debug_str_offsets = DebugStrOffsets::none();
for &version in &[2, 3, 4, 5] {
for &address_size in &[4, 8] {
for &format in &[Format::Dwarf32, Format::Dwarf64] {
let encoding = Encoding {
format,
version,
address_size,
};
let line_base = -5;
let line_range = 14;
let neg_line_base = (-line_base) as u8;
let mut program = LineProgram::new(
encoding,
LineEncoding {
line_base,
line_range,
..Default::default()
},
LineString::String(dir1.to_vec()),
LineString::String(file1.to_vec()),
None,
);
let dir_id = program.default_directory();
program.add_file(LineString::String(file1.to_vec()), dir_id, None);
let file_id =
program.add_file(LineString::String(file2.to_vec()), dir_id, None);
// Test sequences.
{
let mut program = program.clone();
let address = Address::Constant(0x12);
program.begin_sequence(Some(address));
assert_eq!(
program.instructions,
vec![LineInstruction::SetAddress(address)]
);
}
{
let mut program = program.clone();
program.begin_sequence(None);
assert_eq!(program.instructions, Vec::new());
}
{
let mut program = program.clone();
program.begin_sequence(None);
program.end_sequence(0x1234);
assert_eq!(
program.instructions,
vec![
LineInstruction::AdvancePc(0x1234),
LineInstruction::EndSequence
]
);
}
// Create a base program.
program.begin_sequence(None);
program.row.line = 0x1000;
program.generate_row();
let base_row = program.row;
let base_instructions = program.instructions.clone();
// Create test cases.
let mut tests = Vec::new();
let row = base_row;
tests.push((row, vec![LineInstruction::Copy]));
let mut row = base_row;
row.line -= u64::from(neg_line_base);
tests.push((row, vec![LineInstruction::Special(OPCODE_BASE)]));
let mut row = base_row;
row.line += u64::from(line_range) - 1;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![LineInstruction::Special(OPCODE_BASE + line_range - 1)],
));
let mut row = base_row;
row.line += u64::from(line_range);
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![
LineInstruction::AdvanceLine(i64::from(line_range - neg_line_base)),
LineInstruction::Copy,
],
));
let mut row = base_row;
row.address_offset = 1;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![LineInstruction::Special(OPCODE_BASE + line_range)],
));
let op_range = (255 - OPCODE_BASE) / line_range;
let mut row = base_row;
row.address_offset = u64::from(op_range);
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![LineInstruction::Special(
OPCODE_BASE + op_range * line_range,
)],
));
let mut row = base_row;
row.address_offset = u64::from(op_range);
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range);
row.line -= u64::from(neg_line_base);
tests.push((row, vec![LineInstruction::Special(255)]));
let mut row = base_row;
row.address_offset = u64::from(op_range);
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range) + 1;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![LineInstruction::ConstAddPc, LineInstruction::Copy],
));
let mut row = base_row;
row.address_offset = u64::from(op_range);
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range) + 2;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![
LineInstruction::ConstAddPc,
LineInstruction::Special(OPCODE_BASE + 6),
],
));
let mut row = base_row;
row.address_offset = u64::from(op_range) * 2;
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range);
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![LineInstruction::ConstAddPc, LineInstruction::Special(255)],
));
let mut row = base_row;
row.address_offset = u64::from(op_range) * 2;
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range) + 1;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![
LineInstruction::AdvancePc(row.address_offset),
LineInstruction::Copy,
],
));
let mut row = base_row;
row.address_offset = u64::from(op_range) * 2;
row.line += u64::from(255 - OPCODE_BASE - op_range * line_range) + 2;
row.line -= u64::from(neg_line_base);
tests.push((
row,
vec![
LineInstruction::AdvancePc(row.address_offset),
LineInstruction::Special(OPCODE_BASE + 6),
],
));
let mut row = base_row;
row.address_offset = 0x1234;
tests.push((
row,
vec![LineInstruction::AdvancePc(0x1234), LineInstruction::Copy],
));
let mut row = base_row;
row.line += 0x1234;
tests.push((
row,
vec![LineInstruction::AdvanceLine(0x1234), LineInstruction::Copy],
));
let mut row = base_row;
row.file = file_id;
tests.push((
row,
vec![LineInstruction::SetFile(file_id), LineInstruction::Copy],
));
let mut row = base_row;
row.column = 0x1234;
tests.push((
row,
vec![LineInstruction::SetColumn(0x1234), LineInstruction::Copy],
));
let mut row = base_row;
row.discriminator = 0x1234;
tests.push((
row,
vec![
LineInstruction::SetDiscriminator(0x1234),
LineInstruction::Copy,
],
));
let mut row = base_row;
row.is_statement = !row.is_statement;
tests.push((
row,
vec![LineInstruction::NegateStatement, LineInstruction::Copy],
));
let mut row = base_row;
row.basic_block = true;
tests.push((
row,
vec![LineInstruction::SetBasicBlock, LineInstruction::Copy],
));
let mut row = base_row;
row.prologue_end = true;
tests.push((
row,
vec![LineInstruction::SetPrologueEnd, LineInstruction::Copy],
));
let mut row = base_row;
row.epilogue_begin = true;
tests.push((
row,
vec![LineInstruction::SetEpilogueBegin, LineInstruction::Copy],
));
let mut row = base_row;
row.isa = 0x1234;
tests.push((
row,
vec![LineInstruction::SetIsa(0x1234), LineInstruction::Copy],
));
for test in tests {
// Test generate_row().
let mut program = program.clone();
program.row = test.0;
program.generate_row();
assert_eq!(
&program.instructions[base_instructions.len()..],
&test.1[..]
);
// Test LineProgram::from().
let mut debug_line = DebugLine::from(EndianVec::new(LittleEndian));
let debug_line_offset = program
.write(
&mut debug_line,
encoding,
&debug_line_str_offsets,
&debug_str_offsets,
)
.unwrap();
let read_debug_line =
read::DebugLine::new(debug_line.slice(), LittleEndian);
let read_program = read_debug_line
.program(
debug_line_offset,
address_size,
Some(read::EndianSlice::new(dir1, LittleEndian)),
Some(read::EndianSlice::new(file1, LittleEndian)),
)
.unwrap();
let dwarf = read::Dwarf::default();
let mut convert_line_strings = LineStringTable::default();
let mut convert_strings = StringTable::default();
let (convert_program, _convert_files) = LineProgram::from(
read_program,
&dwarf,
&mut convert_line_strings,
&mut convert_strings,
convert_address,
)
.unwrap();
assert_eq!(
&convert_program.instructions[base_instructions.len()..],
&test.1[..]
);
}
}
}
}
}
#[test]
fn test_line_instruction() {
let dir1 = &b"dir1"[..];
let file1 = &b"file1"[..];
let debug_line_str_offsets = DebugLineStrOffsets::none();
let debug_str_offsets = DebugStrOffsets::none();
for &version in &[2, 3, 4, 5] {
for &address_size in &[4, 8] {
for &format in &[Format::Dwarf32, Format::Dwarf64] {
let encoding = Encoding {
format,
version,
address_size,
};
let mut program = LineProgram::new(
encoding,
LineEncoding::default(),
LineString::String(dir1.to_vec()),
LineString::String(file1.to_vec()),
None,
);
let dir_id = program.default_directory();
let file_id =
program.add_file(LineString::String(file1.to_vec()), dir_id, None);
for (inst, expect_inst) in &[
(
LineInstruction::Special(OPCODE_BASE),
read::LineInstruction::Special(OPCODE_BASE),
),
(
LineInstruction::Special(255),
read::LineInstruction::Special(255),
),
(LineInstruction::Copy, read::LineInstruction::Copy),
(
LineInstruction::AdvancePc(0x12),
read::LineInstruction::AdvancePc(0x12),
),
(
LineInstruction::AdvanceLine(0x12),
read::LineInstruction::AdvanceLine(0x12),
),
(
LineInstruction::SetFile(file_id),
read::LineInstruction::SetFile(file_id.raw()),
),
(
LineInstruction::SetColumn(0x12),
read::LineInstruction::SetColumn(0x12),
),
(
LineInstruction::NegateStatement,
read::LineInstruction::NegateStatement,
),
(
LineInstruction::SetBasicBlock,
read::LineInstruction::SetBasicBlock,
),
(
LineInstruction::ConstAddPc,
read::LineInstruction::ConstAddPc,
),
(
LineInstruction::SetPrologueEnd,
read::LineInstruction::SetPrologueEnd,
),
(
LineInstruction::SetEpilogueBegin,
read::LineInstruction::SetEpilogueBegin,
),
(
LineInstruction::SetIsa(0x12),
read::LineInstruction::SetIsa(0x12),
),
(
LineInstruction::EndSequence,
read::LineInstruction::EndSequence,
),
(
LineInstruction::SetAddress(Address::Constant(0x12)),
read::LineInstruction::SetAddress(0x12),
),
(
LineInstruction::SetDiscriminator(0x12),
read::LineInstruction::SetDiscriminator(0x12),
),
][..]
{
let mut program = program.clone();
program.instructions.push(*inst);
let mut debug_line = DebugLine::from(EndianVec::new(LittleEndian));
let debug_line_offset = program
.write(
&mut debug_line,
encoding,
&debug_line_str_offsets,
&debug_str_offsets,
)
.unwrap();
let read_debug_line =
read::DebugLine::new(debug_line.slice(), LittleEndian);
let read_program = read_debug_line
.program(
debug_line_offset,
address_size,
Some(read::EndianSlice::new(dir1, LittleEndian)),
Some(read::EndianSlice::new(file1, LittleEndian)),
--> --------------------
--> maximum size reached
--> --------------------
[ zur Elbe Produktseite wechseln0.62Quellennavigators
Analyse erneut starten
]
|
2026-04-04
|
