1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
use alloc::borrow::Cow;
use alloc::vec::Vec;

use crate::read::{
    self, Architecture, CodeView, ComdatKind, CompressedData, CompressedFileRange, Export,
    FileFlags, Import, ObjectMap, Relocation, Result, SectionFlags, SectionIndex, SectionKind,
    SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
};
use crate::Endianness;

/// An object file.
pub trait Object<'data: 'file, 'file>: read::private::Sealed {
    /// A segment in the object file.
    type Segment: ObjectSegment<'data>;

    /// An iterator over the segments in the object file.
    type SegmentIterator: Iterator<Item = Self::Segment>;

    /// A section in the object file.
    type Section: ObjectSection<'data>;

    /// An iterator over the sections in the object file.
    type SectionIterator: Iterator<Item = Self::Section>;

    /// A COMDAT section group in the object file.
    type Comdat: ObjectComdat<'data>;

    /// An iterator over the COMDAT section groups in the object file.
    type ComdatIterator: Iterator<Item = Self::Comdat>;

    /// A symbol in the object file.
    type Symbol: ObjectSymbol<'data>;

    /// An iterator over symbols in the object file.
    type SymbolIterator: Iterator<Item = Self::Symbol>;

    /// A symbol table in the object file.
    type SymbolTable: ObjectSymbolTable<
        'data,
        Symbol = Self::Symbol,
        SymbolIterator = Self::SymbolIterator,
    >;

    /// An iterator over dynamic relocations in the file.
    ///
    /// The first field in the item tuple is the address
    /// that the relocation applies to.
    type DynamicRelocationIterator: Iterator<Item = (u64, Relocation)>;

    /// Get the architecture type of the file.
    fn architecture(&self) -> Architecture;

    /// Get the endianness of the file.
    #[inline]
    fn endianness(&self) -> Endianness {
        if self.is_little_endian() {
            Endianness::Little
        } else {
            Endianness::Big
        }
    }

    /// Return true if the file is little endian, false if it is big endian.
    fn is_little_endian(&self) -> bool;

    /// Return true if the file can contain 64-bit addresses.
    fn is_64(&self) -> bool;

    /// Get an iterator over the segments in the file.
    fn segments(&'file self) -> Self::SegmentIterator;

    /// Get the section named `section_name`, if such a section exists.
    ///
    /// If `section_name` starts with a '.' then it is treated as a system section name,
    /// and is compared using the conventions specific to the object file format. This
    /// includes:
    /// - if ".debug_str_offsets" is requested for a Mach-O object file, then the actual
    /// section name that is searched for is "__debug_str_offs".
    /// - if ".debug_info" is requested for an ELF object file, then
    /// ".zdebug_info" may be returned (and similarly for other debug sections).
    ///
    /// For some object files, multiple segments may contain sections with the same
    /// name. In this case, the first matching section will be used.
    ///
    /// This method skips over sections with invalid names.
    fn section_by_name(&'file self, section_name: &str) -> Option<Self::Section>;

    /// Get the section at the given index.
    ///
    /// The meaning of the index depends on the object file.
    ///
    /// For some object files, this requires iterating through all sections.
    ///
    /// Returns an error if the index is invalid.
    fn section_by_index(&'file self, index: SectionIndex) -> Result<Self::Section>;

    /// Get an iterator over the sections in the file.
    fn sections(&'file self) -> Self::SectionIterator;

    /// Get an iterator over the COMDAT section groups in the file.
    fn comdats(&'file self) -> Self::ComdatIterator;

    /// Get the symbol table, if any.
    fn symbol_table(&'file self) -> Option<Self::SymbolTable>;

    /// Get the debugging symbol at the given index.
    ///
    /// The meaning of the index depends on the object file.
    ///
    /// Returns an error if the index is invalid.
    fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<Self::Symbol>;

    /// Get an iterator over the debugging symbols in the file.
    ///
    /// This may skip over symbols that are malformed or unsupported.
    ///
    /// For Mach-O files, this does not include STAB entries.
    fn symbols(&'file self) -> Self::SymbolIterator;

    /// Get the dynamic linking symbol table, if any.
    ///
    /// Only ELF has a separate dynamic linking symbol table.
    fn dynamic_symbol_table(&'file self) -> Option<Self::SymbolTable>;

    /// Get an iterator over the dynamic linking symbols in the file.
    ///
    /// This may skip over symbols that are malformed or unsupported.
    ///
    /// Only ELF has separate dynamic linking symbols.
    /// Other file formats will return an empty iterator.
    fn dynamic_symbols(&'file self) -> Self::SymbolIterator;

    /// Get the dynamic relocations for this file.
    ///
    /// Symbol indices in these relocations refer to the dynamic symbol table.
    ///
    /// Only ELF has dynamic relocations.
    fn dynamic_relocations(&'file self) -> Option<Self::DynamicRelocationIterator>;

    /// Construct a map from addresses to symbol names.
    ///
    /// The map will only contain defined text and data symbols.
    /// The dynamic symbol table will only be used if there are no debugging symbols.
    fn symbol_map(&'file self) -> SymbolMap<SymbolMapName<'data>> {
        let mut symbols = Vec::new();
        if let Some(table) = self.symbol_table().or_else(|| self.dynamic_symbol_table()) {
            for symbol in table.symbols() {
                if !symbol.is_definition() {
                    continue;
                }
                if let Ok(name) = symbol.name() {
                    symbols.push(SymbolMapName::new(symbol.address(), name));
                }
            }
        }
        SymbolMap::new(symbols)
    }

    /// Construct a map from addresses to symbol names and object file names.
    ///
    /// This is derived from Mach-O STAB entries.
    fn object_map(&'file self) -> ObjectMap<'data> {
        ObjectMap::default()
    }

    /// Get the imported symbols.
    fn imports(&self) -> Result<Vec<Import<'data>>>;

    /// Get the exported symbols.
    fn exports(&self) -> Result<Vec<Export<'data>>>;

    /// Return true if the file contains debug information sections, false if not.
    fn has_debug_symbols(&self) -> bool;

    /// The UUID from a Mach-O `LC_UUID` load command.
    #[inline]
    fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
        Ok(None)
    }

    /// The build ID from an ELF `NT_GNU_BUILD_ID` note.
    #[inline]
    fn build_id(&self) -> Result<Option<&'data [u8]>> {
        Ok(None)
    }

    /// The filename and CRC from a `.gnu_debuglink` section.
    #[inline]
    fn gnu_debuglink(&self) -> Result<Option<(&'data [u8], u32)>> {
        Ok(None)
    }

    /// The filename and build ID from a `.gnu_debugaltlink` section.
    #[inline]
    fn gnu_debugaltlink(&self) -> Result<Option<(&'data [u8], &'data [u8])>> {
        Ok(None)
    }

    /// The filename and GUID from the PE CodeView section
    #[inline]
    fn pdb_info(&self) -> Result<Option<CodeView>> {
        Ok(None)
    }

    /// Get the base address used for relative virtual addresses.
    ///
    /// Currently this is only non-zero for PE.
    fn relative_address_base(&'file self) -> u64;

    /// Get the virtual address of the entry point of the binary
    fn entry(&'file self) -> u64;

    /// File flags that are specific to each file format.
    fn flags(&self) -> FileFlags;
}

/// A loadable segment defined in an object file.
///
/// For ELF, this is a program header with type `PT_LOAD`.
/// For Mach-O, this is a load command with type `LC_SEGMENT` or `LC_SEGMENT_64`.
pub trait ObjectSegment<'data>: read::private::Sealed {
    /// Returns the virtual address of the segment.
    fn address(&self) -> u64;

    /// Returns the size of the segment in memory.
    fn size(&self) -> u64;

    /// Returns the alignment of the segment in memory.
    fn align(&self) -> u64;

    /// Returns the offset and size of the segment in the file.
    fn file_range(&self) -> (u64, u64);

    /// Returns a reference to the file contents of the segment.
    ///
    /// The length of this data may be different from the size of the
    /// segment in memory.
    fn data(&self) -> Result<&'data [u8]>;

    /// Return the segment data in the given range.
    ///
    /// Returns `Ok(None)` if the segment does not contain the given range.
    fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;

    /// Returns the name of the segment.
    fn name(&self) -> Result<Option<&str>>;
}

/// A section defined in an object file.
pub trait ObjectSection<'data>: read::private::Sealed {
    /// An iterator over the relocations for a section.
    ///
    /// The first field in the item tuple is the section offset
    /// that the relocation applies to.
    type RelocationIterator: Iterator<Item = (u64, Relocation)>;

    /// Returns the section index.
    fn index(&self) -> SectionIndex;

    /// Returns the address of the section.
    fn address(&self) -> u64;

    /// Returns the size of the section in memory.
    fn size(&self) -> u64;

    /// Returns the alignment of the section in memory.
    fn align(&self) -> u64;

    /// Returns offset and size of on-disk segment (if any).
    fn file_range(&self) -> Option<(u64, u64)>;

    /// Returns the raw contents of the section.
    ///
    /// The length of this data may be different from the size of the
    /// section in memory.
    ///
    /// This does not do any decompression.
    fn data(&self) -> Result<&'data [u8]>;

    /// Return the raw contents of the section data in the given range.
    ///
    /// This does not do any decompression.
    ///
    /// Returns `Ok(None)` if the section does not contain the given range.
    fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;

    /// Returns the potentially compressed file range of the section,
    /// along with information about the compression.
    fn compressed_file_range(&self) -> Result<CompressedFileRange>;

    /// Returns the potentially compressed contents of the section,
    /// along with information about the compression.
    fn compressed_data(&self) -> Result<CompressedData<'data>>;

    /// Returns the uncompressed contents of the section.
    ///
    /// The length of this data may be different from the size of the
    /// section in memory.
    ///
    /// If no compression is detected, then returns the data unchanged.
    /// Returns `Err` if decompression fails.
    fn uncompressed_data(&self) -> Result<Cow<'data, [u8]>> {
        self.compressed_data()?.decompress()
    }

    /// Returns the name of the section.
    fn name(&self) -> Result<&str>;

    /// Returns the name of the segment for this section.
    fn segment_name(&self) -> Result<Option<&str>>;

    /// Return the kind of this section.
    fn kind(&self) -> SectionKind;

    /// Get the relocations for this section.
    fn relocations(&self) -> Self::RelocationIterator;

    /// Section flags that are specific to each file format.
    fn flags(&self) -> SectionFlags;
}

/// A COMDAT section group defined in an object file.
pub trait ObjectComdat<'data>: read::private::Sealed {
    /// An iterator over the sections in the object file.
    type SectionIterator: Iterator<Item = SectionIndex>;

    /// Returns the COMDAT selection kind.
    fn kind(&self) -> ComdatKind;

    /// Returns the index of the symbol used for the name of COMDAT section group.
    fn symbol(&self) -> SymbolIndex;

    /// Returns the name of the COMDAT section group.
    fn name(&self) -> Result<&str>;

    /// Get the sections in this section group.
    fn sections(&self) -> Self::SectionIterator;
}

/// A symbol table.
pub trait ObjectSymbolTable<'data>: read::private::Sealed {
    /// A symbol table entry.
    type Symbol: ObjectSymbol<'data>;

    /// An iterator over the symbols in a symbol table.
    type SymbolIterator: Iterator<Item = Self::Symbol>;

    /// Get an iterator over the symbols in the table.
    ///
    /// This may skip over symbols that are malformed or unsupported.
    fn symbols(&self) -> Self::SymbolIterator;

    /// Get the symbol at the given index.
    ///
    /// The meaning of the index depends on the object file.
    ///
    /// Returns an error if the index is invalid.
    fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol>;
}

/// A symbol table entry.
pub trait ObjectSymbol<'data>: read::private::Sealed {
    /// The index of the symbol.
    fn index(&self) -> SymbolIndex;

    /// The name of the symbol.
    fn name(&self) -> Result<&'data str>;

    /// The address of the symbol. May be zero if the address is unknown.
    fn address(&self) -> u64;

    /// The size of the symbol. May be zero if the size is unknown.
    fn size(&self) -> u64;

    /// Return the kind of this symbol.
    fn kind(&self) -> SymbolKind;

    /// Returns the section where the symbol is defined.
    fn section(&self) -> SymbolSection;

    /// Returns the section index for the section containing this symbol.
    ///
    /// May return `None` if the symbol is not defined in a section.
    fn section_index(&self) -> Option<SectionIndex> {
        self.section().index()
    }

    /// Return true if the symbol is undefined.
    fn is_undefined(&self) -> bool;

    /// Return true if the symbol is a definition of a function or data object
    /// that has a known address.
    fn is_definition(&self) -> bool;

    /// Return true if the symbol is common data.
    ///
    /// Note: does not check for `SymbolSection::Section` with `SectionKind::Common`.
    fn is_common(&self) -> bool;

    /// Return true if the symbol is weak.
    fn is_weak(&self) -> bool;

    /// Returns the symbol scope.
    fn scope(&self) -> SymbolScope;

    /// Return true if the symbol visible outside of the compilation unit.
    ///
    /// This treats `SymbolScope::Unknown` as global.
    fn is_global(&self) -> bool;

    /// Return true if the symbol is only visible within the compilation unit.
    fn is_local(&self) -> bool;

    /// Symbol flags that are specific to each file format.
    fn flags(&self) -> SymbolFlags<SectionIndex>;
}

/// An iterator for files that don't have dynamic relocations.
#[derive(Debug)]
pub struct NoDynamicRelocationIterator;

impl Iterator for NoDynamicRelocationIterator {
    type Item = (u64, Relocation);

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        None
    }
}