vendor/gimli/src/common.rs

   1 /// Whether the format of a compilation unit is 32- or 64-bit.
   2 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
   3 pub enum Format {
   4     /// 64-bit DWARF
   5     Dwarf64 = 8,
   6     /// 32-bit DWARF
   7     Dwarf32 = 4,
   8 }
   9
  10 impl Format {
  11     /// Return the serialized size of an initial length field for the format.
  12     #[inline]
  13     pub fn initial_length_size(self) -> u8 {
  14         match self {
  15             Format::Dwarf32 => 4,
  16             Format::Dwarf64 => 12,
  17         }
  18     }
  19
  20     /// Return the natural word size for the format
  21     #[inline]
  22     pub fn word_size(self) -> u8 {
  23         match self {
  24             Format::Dwarf32 => 4,
  25             Format::Dwarf64 => 8,
  26         }
  27     }
  28 }
  29
  30 /// Encoding parameters that are commonly used for multiple DWARF sections.
  31 ///
  32 /// This is intended to be small enough to pass by value.
  33 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  34 // `address_size` and `format` are used more often than `version`, so keep
  35 // them first.
  36 #[repr(C)]
  37 pub struct Encoding {
  38     /// The size of an address.
  39     pub address_size: u8,
  40
  41     // The size of a segment selector.
  42     // TODO: pub segment_size: u8,
  43     /// Whether the DWARF format is 32- or 64-bit.
  44     pub format: Format,
  45
  46     /// The DWARF version of the header.
  47     pub version: u16,
  48 }
  49
  50 /// Encoding parameters for a line number program.
  51 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  52 pub struct LineEncoding {
  53     /// The size in bytes of the smallest target machine instruction.
  54     pub minimum_instruction_length: u8,
  55
  56     /// The maximum number of individual operations that may be encoded in an
  57     /// instruction.
  58     pub maximum_operations_per_instruction: u8,
  59
  60     /// The initial value of the `is_stmt` register.
  61     pub default_is_stmt: bool,
  62
  63     /// The minimum value which a special opcode can add to the line register.
  64     pub line_base: i8,
  65
  66     /// The range of values which a special opcode can add to the line register.
  67     pub line_range: u8,
  68 }
  69
  70 impl Default for LineEncoding {
  71     fn default() -> Self {
  72         // Values from LLVM.
  73         LineEncoding {
  74             minimum_instruction_length: 1,
  75             maximum_operations_per_instruction: 1,
  76             default_is_stmt: true,
  77             line_base: -5,
  78             line_range: 14,
  79         }
  80     }
  81 }
  82
  83 /// A DWARF register number.
  84 ///
  85 /// The meaning of this value is ABI dependent. This is generally encoded as
  86 /// a ULEB128, but supported architectures need 16 bits at most.
  87 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
  88 pub struct Register(pub u16);
  89
  90 /// An offset into the `.debug_abbrev` section.
  91 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  92 pub struct DebugAbbrevOffset<T = usize>(pub T);
  93
  94 /// An offset to a set of entries in the `.debug_addr` section.
  95 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  96 pub struct DebugAddrBase<T = usize>(pub T);
  97
  98 /// An index into a set of addresses in the `.debug_addr` section.
  99 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 100 pub struct DebugAddrIndex<T = usize>(pub T);
 101
 102 /// An offset into the `.debug_aranges` section.
 103 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 104 pub struct DebugArangesOffset<T = usize>(pub T);
 105
 106 /// An offset into the `.debug_info` section.
 107 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
 108 pub struct DebugInfoOffset<T = usize>(pub T);
 109
 110 /// An offset into the `.debug_line` section.
 111 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 112 pub struct DebugLineOffset<T = usize>(pub T);
 113
 114 /// An offset into the `.debug_line_str` section.
 115 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 116 pub struct DebugLineStrOffset<T = usize>(pub T);
 117
 118 /// An offset into either the `.debug_loc` section or the `.debug_loclists` section,
 119 /// depending on the version of the unit the offset was contained in.
 120 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 121 pub struct LocationListsOffset<T = usize>(pub T);
 122
 123 /// An offset to a set of location list offsets in the `.debug_loclists` section.
 124 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 125 pub struct DebugLocListsBase<T = usize>(pub T);
 126
 127 /// An index into a set of location list offsets in the `.debug_loclists` section.
 128 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 129 pub struct DebugLocListsIndex<T = usize>(pub T);
 130
 131 /// An offset into the `.debug_macinfo` section.
 132 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 133 pub struct DebugMacinfoOffset<T = usize>(pub T);
 134
 135 /// An offset into the `.debug_macro` section.
 136 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 137 pub struct DebugMacroOffset<T = usize>(pub T);
 138
 139 /// An offset into either the `.debug_ranges` section or the `.debug_rnglists` section,
 140 /// depending on the version of the unit the offset was contained in.
 141 ///
 142 /// If this is from a DWARF 4 DWO file, then it must additionally be offset by the
 143 /// value of `DW_AT_GNU_ranges_base`. You can use `Dwarf::ranges_offset_from_raw` to do this.
 144 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 145 pub struct RawRangeListsOffset<T = usize>(pub T);
 146
 147 /// An offset into either the `.debug_ranges` section or the `.debug_rnglists` section,
 148 /// depending on the version of the unit the offset was contained in.
 149 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 150 pub struct RangeListsOffset<T = usize>(pub T);
 151
 152 /// An offset to a set of range list offsets in the `.debug_rnglists` section.
 153 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 154 pub struct DebugRngListsBase<T = usize>(pub T);
 155
 156 /// An index into a set of range list offsets in the `.debug_rnglists` section.
 157 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 158 pub struct DebugRngListsIndex<T = usize>(pub T);
 159
 160 /// An offset into the `.debug_str` section.
 161 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 162 pub struct DebugStrOffset<T = usize>(pub T);
 163
 164 /// An offset to a set of entries in the `.debug_str_offsets` section.
 165 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 166 pub struct DebugStrOffsetsBase<T = usize>(pub T);
 167
 168 /// An index into a set of entries in the `.debug_str_offsets` section.
 169 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 170 pub struct DebugStrOffsetsIndex<T = usize>(pub T);
 171
 172 /// An offset into the `.debug_types` section.
 173 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
 174 pub struct DebugTypesOffset<T = usize>(pub T);
 175
 176 /// A type signature as used in the `.debug_types` section.
 177 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 178 pub struct DebugTypeSignature(pub u64);
 179
 180 /// An offset into the `.debug_frame` section.
 181 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 182 pub struct DebugFrameOffset<T = usize>(pub T);
 183
 184 impl<T> From<T> for DebugFrameOffset<T> {
 185     #[inline]
 186     fn from(o: T) -> Self {
 187         DebugFrameOffset(o)
 188     }
 189 }
 190
 191 /// An offset into the `.eh_frame` section.
 192 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 193 pub struct EhFrameOffset<T = usize>(pub T);
 194
 195 impl<T> From<T> for EhFrameOffset<T> {
 196     #[inline]
 197     fn from(o: T) -> Self {
 198         EhFrameOffset(o)
 199     }
 200 }
 201
 202 /// An offset into the `.debug_info` or `.debug_types` sections.
 203 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
 204 pub enum UnitSectionOffset<T = usize> {
 205     /// An offset into the `.debug_info` section.
 206     DebugInfoOffset(DebugInfoOffset<T>),
 207     /// An offset into the `.debug_types` section.
 208     DebugTypesOffset(DebugTypesOffset<T>),
 209 }
 210
 211 impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T> {
 212     fn from(offset: DebugInfoOffset<T>) -> Self {
 213         UnitSectionOffset::DebugInfoOffset(offset)
 214     }
 215 }
 216
 217 impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T> {
 218     fn from(offset: DebugTypesOffset<T>) -> Self {
 219         UnitSectionOffset::DebugTypesOffset(offset)
 220     }
 221 }
 222
 223 impl<T> UnitSectionOffset<T>
 224 where
 225     T: Clone,
 226 {
 227     /// Returns the `DebugInfoOffset` inside, or `None` otherwise.
 228     pub fn as_debug_info_offset(&self) -> Option<DebugInfoOffset<T>> {
 229         match self {
 230             UnitSectionOffset::DebugInfoOffset(offset) => Some(offset.clone()),
 231             UnitSectionOffset::DebugTypesOffset(_) => None,
 232         }
 233     }
 234     /// Returns the `DebugTypesOffset` inside, or `None` otherwise.
 235     pub fn as_debug_types_offset(&self) -> Option<DebugTypesOffset<T>> {
 236         match self {
 237             UnitSectionOffset::DebugInfoOffset(_) => None,
 238             UnitSectionOffset::DebugTypesOffset(offset) => Some(offset.clone()),
 239         }
 240     }
 241 }
 242
 243 /// An identifier for a DWARF section.
 244 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
 245 pub enum SectionId {
 246     /// The `.debug_abbrev` section.
 247     DebugAbbrev,
 248     /// The `.debug_addr` section.
 249     DebugAddr,
 250     /// The `.debug_aranges` section.
 251     DebugAranges,
 252     /// The `.debug_cu_index` section.
 253     DebugCuIndex,
 254     /// The `.debug_frame` section.
 255     DebugFrame,
 256     /// The `.eh_frame` section.
 257     EhFrame,
 258     /// The `.eh_frame_hdr` section.
 259     EhFrameHdr,
 260     /// The `.debug_info` section.
 261     DebugInfo,
 262     /// The `.debug_line` section.
 263     DebugLine,
 264     /// The `.debug_line_str` section.
 265     DebugLineStr,
 266     /// The `.debug_loc` section.
 267     DebugLoc,
 268     /// The `.debug_loclists` section.
 269     DebugLocLists,
 270     /// The `.debug_macinfo` section.
 271     DebugMacinfo,
 272     /// The `.debug_macro` section.
 273     DebugMacro,
 274     /// The `.debug_pubnames` section.
 275     DebugPubNames,
 276     /// The `.debug_pubtypes` section.
 277     DebugPubTypes,
 278     /// The `.debug_ranges` section.
 279     DebugRanges,
 280     /// The `.debug_rnglists` section.
 281     DebugRngLists,
 282     /// The `.debug_str` section.
 283     DebugStr,
 284     /// The `.debug_str_offsets` section.
 285     DebugStrOffsets,
 286     /// The `.debug_tu_index` section.
 287     DebugTuIndex,
 288     /// The `.debug_types` section.
 289     DebugTypes,
 290 }
 291
 292 impl SectionId {
 293     /// Returns the ELF section name for this kind.
 294     pub fn name(self) -> &'static str {
 295         match self {
 296             SectionId::DebugAbbrev => ".debug_abbrev",
 297             SectionId::DebugAddr => ".debug_addr",
 298             SectionId::DebugAranges => ".debug_aranges",
 299             SectionId::DebugCuIndex => ".debug_cu_index",
 300             SectionId::DebugFrame => ".debug_frame",
 301             SectionId::EhFrame => ".eh_frame",
 302             SectionId::EhFrameHdr => ".eh_frame_hdr",
 303             SectionId::DebugInfo => ".debug_info",
 304             SectionId::DebugLine => ".debug_line",
 305             SectionId::DebugLineStr => ".debug_line_str",
 306             SectionId::DebugLoc => ".debug_loc",
 307             SectionId::DebugLocLists => ".debug_loclists",
 308             SectionId::DebugMacinfo => ".debug_macinfo",
 309             SectionId::DebugMacro => ".debug_macro",
 310             SectionId::DebugPubNames => ".debug_pubnames",
 311             SectionId::DebugPubTypes => ".debug_pubtypes",
 312             SectionId::DebugRanges => ".debug_ranges",
 313             SectionId::DebugRngLists => ".debug_rnglists",
 314             SectionId::DebugStr => ".debug_str",
 315             SectionId::DebugStrOffsets => ".debug_str_offsets",
 316             SectionId::DebugTuIndex => ".debug_tu_index",
 317             SectionId::DebugTypes => ".debug_types",
 318         }
 319     }
 320
 321     /// Returns the ELF section name for this kind, when found in a .dwo or .dwp file.
 322     pub fn dwo_name(self) -> Option<&'static str> {
 323         Some(match self {
 324             SectionId::DebugAbbrev => ".debug_abbrev.dwo",
 325             SectionId::DebugCuIndex => ".debug_cu_index",
 326             SectionId::DebugInfo => ".debug_info.dwo",
 327             SectionId::DebugLine => ".debug_line.dwo",
 328             // The debug_loc section can be present in the dwo when using the
 329             // GNU split-dwarf extension to DWARF4.
 330             SectionId::DebugLoc => ".debug_loc.dwo",
 331             SectionId::DebugLocLists => ".debug_loclists.dwo",
 332             SectionId::DebugMacro => ".debug_macro.dwo",
 333             SectionId::DebugRngLists => ".debug_rnglists.dwo",
 334             SectionId::DebugStr => ".debug_str.dwo",
 335             SectionId::DebugStrOffsets => ".debug_str_offsets.dwo",
 336             SectionId::DebugTuIndex => ".debug_tu_index",
 337             SectionId::DebugTypes => ".debug_types.dwo",
 338             _ => return None,
 339         })
 340     }
 341 }
 342
 343 /// An optionally-provided implementation-defined compilation unit ID to enable
 344 /// split DWARF and linking a split compilation unit back together.
 345 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 346 pub struct DwoId(pub u64);
 347
 348 /// The "type" of file with DWARF debugging information. This determines, among other things,
 349 /// which files DWARF sections should be loaded from.
 350 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 351 pub enum DwarfFileType {
 352     /// A normal executable or object file.
 353     Main,
 354     /// A .dwo split DWARF file.
 355     Dwo,
 356     // TODO: Supplementary files, .dwps?
 357 }
 358
 359 impl Default for DwarfFileType {
 360     fn default() -> Self {
 361         DwarfFileType::Main
 362     }
 363 }