summaryrefslogtreecommitdiffstats
path: root/vendor/gimli-0.27.3/src/write/line.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/gimli-0.27.3/src/write/line.rs')
-rw-r--r--vendor/gimli-0.27.3/src/write/line.rs1957
1 files changed, 0 insertions, 1957 deletions
diff --git a/vendor/gimli-0.27.3/src/write/line.rs b/vendor/gimli-0.27.3/src/write/line.rs
deleted file mode 100644
index c88b735bc..000000000
--- a/vendor/gimli-0.27.3/src/write/line.rs
+++ /dev/null
@@ -1,1957 +0,0 @@
-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 &(ref inst, ref 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)),
- )
- .unwrap();
- let read_header = read_program.header();
- let mut read_insts = read_header.instructions();
- assert_eq!(
- *expect_inst,
- read_insts.next_instruction(read_header).unwrap().unwrap()
- );
- assert_eq!(None, read_insts.next_instruction(read_header).unwrap());
- }
- }
- }
- }
- }
-
- // Test that the address/line advance is correct. We don't test for optimality.
- #[test]
- fn test_advance() {
- let encoding = Encoding {
- format: Format::Dwarf32,
- version: 4,
- address_size: 8,
- };
-
- let dir1 = &b"dir1"[..];
- let file1 = &b"file1"[..];
-
- let addresses = 0..50;
- let lines = -10..25i64;
-
- let debug_line_str_offsets = DebugLineStrOffsets::none();
- let debug_str_offsets = DebugStrOffsets::none();
-
- for minimum_instruction_length in vec![1, 4] {
- for maximum_operations_per_instruction in vec![1, 3] {
- for line_base in vec![-5, 0] {
- for line_range in vec![10, 20] {
- let line_encoding = LineEncoding {
- minimum_instruction_length,
- maximum_operations_per_instruction,
- line_base,
- line_range,
- default_is_stmt: true,
- };
- let mut program = LineProgram::new(
- encoding,
- line_encoding,
- LineString::String(dir1.to_vec()),
- LineString::String(file1.to_vec()),
- None,
- );
- for address_advance in addresses.clone() {
- program.begin_sequence(Some(Address::Constant(0x1000)));
- program.row().line = 0x10000;
- program.generate_row();
- for line_advance in lines.clone() {
- {
- let row = program.row();
- row.address_offset +=
- address_advance * u64::from(minimum_instruction_length);
- row.line = row.line.wrapping_add(line_advance as u64);
- }
- program.generate_row();
- }
- let address_offset = program.row().address_offset
- + u64::from(minimum_instruction_length);
- program.end_sequence(address_offset);
- }
-
- 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,
- 8,
- Some(read::EndianSlice::new(dir1, LittleEndian)),
- Some(read::EndianSlice::new(file1, LittleEndian)),
- )
- .unwrap();
-
- let mut rows = read_program.rows();
- for address_advance in addresses.clone() {
- let mut address;
- let mut line;
- {
- let row = rows.next_row().unwrap().unwrap().1;
- address = row.address();
- line = row.line().unwrap().get();
- }
- assert_eq!(address, 0x1000);
- assert_eq!(line, 0x10000);
- for line_advance in lines.clone() {
- let row = rows.next_row().unwrap().unwrap().1;
- assert_eq!(
- row.address() - address,
- address_advance * u64::from(minimum_instruction_length)
- );
- assert_eq!(
- (row.line().unwrap().get() as i64) - (line as i64),
- line_advance
- );
- address = row.address();
- line = row.line().unwrap().get();
- }
- let row = rows.next_row().unwrap().unwrap().1;
- assert!(row.end_sequence());
- }
- }
- }
- }
- }
- }
-
- #[test]
- fn test_line_string() {
- let version = 5;
-
- let file = b"file1";
-
- let mut strings = StringTable::default();
- let string_id = strings.add("file2");
- let mut debug_str = DebugStr::from(EndianVec::new(LittleEndian));
- let debug_str_offsets = strings.write(&mut debug_str).unwrap();
-
- let mut line_strings = LineStringTable::default();
- let line_string_id = line_strings.add("file3");
- let mut debug_line_str = DebugLineStr::from(EndianVec::new(LittleEndian));
- let debug_line_str_offsets = line_strings.write(&mut debug_line_str).unwrap();
-
- for &address_size in &[4, 8] {
- for &format in &[Format::Dwarf32, Format::Dwarf64] {
- let encoding = Encoding {
- format,
- version,
- address_size,
- };
-
- for (file, expect_file) in vec![
- (
- LineString::String(file.to_vec()),
- read::AttributeValue::String(read::EndianSlice::new(file, LittleEndian)),
- ),
- (
- LineString::StringRef(string_id),
- read::AttributeValue::DebugStrRef(debug_str_offsets.get(string_id)),
- ),
- (
- LineString::LineStringRef(line_string_id),
- read::AttributeValue::DebugLineStrRef(
- debug_line_str_offsets.get(line_string_id),
- ),
- ),
- ] {
- let program = LineProgram::new(
- encoding,
- LineEncoding::default(),
- LineString::String(b"dir".to_vec()),
- file,
- None,
- );
-
- 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, None, None)
- .unwrap();
- let read_header = read_program.header();
- assert_eq!(read_header.file(0).unwrap().path_name(), expect_file);
- }
- }
- }
- }
-
- #[test]
- fn test_missing_comp_dir() {
- 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 program = LineProgram::new(
- encoding,
- LineEncoding::default(),
- LineString::String(Vec::new()),
- LineString::String(Vec::new()),
- None,
- );
-
- 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,
- // Testing missing comp_dir/comp_name.
- None,
- None,
- )
- .unwrap();
-
- let dwarf = read::Dwarf::default();
- let mut convert_line_strings = LineStringTable::default();
- let mut convert_strings = StringTable::default();
- let convert_address = &|address| Some(Address::Constant(address));
- LineProgram::from(
- read_program,
- &dwarf,
- &mut convert_line_strings,
- &mut convert_strings,
- convert_address,
- )
- .unwrap();
- }
- }
- }
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-17 06:58:37 +0000