Source code
Revision control
Copy as Markdown
Other Tools
/// A CPU architecture.
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Architecture {
Unknown,
Aarch64,
#[allow(non_camel_case_types)]
Aarch64_Ilp32,
Arm,
Avr,
Bpf,
Csky,
I386,
X86_64,
#[allow(non_camel_case_types)]
X86_64_X32,
Hexagon,
LoongArch64,
Mips,
Mips64,
Msp430,
PowerPc,
PowerPc64,
Riscv32,
Riscv64,
S390x,
Sbf,
Sharc,
Sparc,
Sparc32Plus,
Sparc64,
Wasm32,
Wasm64,
Xtensa,
}
/// A CPU sub-architecture.
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SubArchitecture {
Arm64E,
Arm64EC,
}
impl Architecture {
/// The size of an address value for this architecture.
///
/// Returns `None` for unknown architectures.
pub fn address_size(self) -> Option<AddressSize> {
match self {
Architecture::Unknown => None,
Architecture::Aarch64 => Some(AddressSize::U64),
Architecture::Aarch64_Ilp32 => Some(AddressSize::U32),
Architecture::Arm => Some(AddressSize::U32),
Architecture::Avr => Some(AddressSize::U8),
Architecture::Bpf => Some(AddressSize::U64),
Architecture::Csky => Some(AddressSize::U32),
Architecture::I386 => Some(AddressSize::U32),
Architecture::X86_64 => Some(AddressSize::U64),
Architecture::X86_64_X32 => Some(AddressSize::U32),
Architecture::Hexagon => Some(AddressSize::U32),
Architecture::LoongArch64 => Some(AddressSize::U64),
Architecture::Mips => Some(AddressSize::U32),
Architecture::Mips64 => Some(AddressSize::U64),
Architecture::Msp430 => Some(AddressSize::U16),
Architecture::PowerPc => Some(AddressSize::U32),
Architecture::PowerPc64 => Some(AddressSize::U64),
Architecture::Riscv32 => Some(AddressSize::U32),
Architecture::Riscv64 => Some(AddressSize::U64),
Architecture::S390x => Some(AddressSize::U64),
Architecture::Sbf => Some(AddressSize::U64),
Architecture::Sharc => Some(AddressSize::U32),
Architecture::Sparc => Some(AddressSize::U32),
Architecture::Sparc32Plus => Some(AddressSize::U32),
Architecture::Sparc64 => Some(AddressSize::U64),
Architecture::Wasm32 => Some(AddressSize::U32),
Architecture::Wasm64 => Some(AddressSize::U64),
Architecture::Xtensa => Some(AddressSize::U32),
}
}
}
/// The size of an address value for an architecture.
///
/// This may differ from the address size supported by the file format (such as for COFF).
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
#[repr(u8)]
pub enum AddressSize {
U8 = 1,
U16 = 2,
U32 = 4,
U64 = 8,
}
impl AddressSize {
/// The size in bytes of an address value.
#[inline]
pub fn bytes(self) -> u8 {
self as u8
}
}
/// A binary file format.
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum BinaryFormat {
Coff,
Elf,
MachO,
Pe,
Wasm,
Xcoff,
}
impl BinaryFormat {
/// The target's native binary format for relocatable object files.
///
/// Defaults to `Elf` for unknown platforms.
pub fn native_object() -> BinaryFormat {
if cfg!(target_os = "windows") {
BinaryFormat::Coff
} else if cfg!(target_os = "macos") {
BinaryFormat::MachO
} else {
BinaryFormat::Elf
}
}
}
/// The kind of a section.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SectionKind {
/// The section kind is unknown.
Unknown,
/// An executable code section.
///
/// Example ELF sections: `.text`
///
/// Example Mach-O sections: `__TEXT/__text`
Text,
/// A data section.
///
/// Example ELF sections: `.data`
///
/// Example Mach-O sections: `__DATA/__data`
Data,
/// A read only data section.
///
/// Example ELF sections: `.rodata`
///
/// Example Mach-O sections: `__TEXT/__const`, `__DATA/__const`, `__TEXT/__literal4`
ReadOnlyData,
/// A read only data section with relocations.
///
/// This is the same as either `Data` or `ReadOnlyData`, depending on the file format.
/// This value is only used in the API for writing files. It is never returned when reading files.
ReadOnlyDataWithRel,
/// A loadable string section.
///
/// Example ELF sections: `.rodata.str`
///
/// Example Mach-O sections: `__TEXT/__cstring`
ReadOnlyString,
/// An uninitialized data section.
///
/// Example ELF sections: `.bss`
///
/// Example Mach-O sections: `__DATA/__bss`
UninitializedData,
/// An uninitialized common data section.
///
/// Example Mach-O sections: `__DATA/__common`
Common,
/// A TLS data section.
///
/// Example ELF sections: `.tdata`
///
/// Example Mach-O sections: `__DATA/__thread_data`
Tls,
/// An uninitialized TLS data section.
///
/// Example ELF sections: `.tbss`
///
/// Example Mach-O sections: `__DATA/__thread_bss`
UninitializedTls,
/// A TLS variables section.
///
/// This contains TLS variable structures, rather than the variable initializers.
///
/// Example Mach-O sections: `__DATA/__thread_vars`
TlsVariables,
/// A non-loadable string section.
///
/// Example ELF sections: `.comment`, `.debug_str`
OtherString,
/// Some other non-loadable section.
///
/// Example ELF sections: `.debug_info`
Other,
/// Debug information.
///
/// Example Mach-O sections: `__DWARF/__debug_info`
Debug,
/// Debug strings.
///
/// This is the same as either `Debug` or `OtherString`, depending on the file format.
/// This value is only used in the API for writing files. It is never returned when reading files.
DebugString,
/// Information for the linker.
///
/// Example COFF sections: `.drectve`
Linker,
/// ELF note section.
Note,
/// Metadata such as symbols or relocations.
///
/// Example ELF sections: `.symtab`, `.strtab`, `.group`
Metadata,
/// Some other ELF section type.
///
/// This is the `sh_type` field in the section header.
/// The meaning may be dependent on the architecture.
Elf(u32),
}
impl SectionKind {
/// Return true if this section contains zerofill data.
pub fn is_bss(self) -> bool {
self == SectionKind::UninitializedData
|| self == SectionKind::UninitializedTls
|| self == SectionKind::Common
}
}
/// The selection kind for a COMDAT section group.
///
/// This determines the way in which the linker resolves multiple definitions of the COMDAT
/// sections.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ComdatKind {
/// The selection kind is unknown.
Unknown,
/// Multiple definitions are allowed.
///
/// An arbitrary definition is selected, and the rest are removed.
///
/// This is the only supported selection kind for ELF.
Any,
/// Multiple definitions are not allowed.
///
/// This is used to group sections without allowing duplicates.
NoDuplicates,
/// Multiple definitions must have the same size.
///
/// An arbitrary definition is selected, and the rest are removed.
SameSize,
/// Multiple definitions must match exactly.
///
/// An arbitrary definition is selected, and the rest are removed.
ExactMatch,
/// Multiple definitions are allowed, and the largest is selected.
///
/// An arbitrary definition with the largest size is selected, and the rest are removed.
Largest,
/// Multiple definitions are allowed, and the newest is selected.
Newest,
}
/// The kind of a symbol.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SymbolKind {
/// The symbol kind is unknown.
Unknown,
/// The symbol is for executable code.
Text,
/// The symbol is for a data object.
Data,
/// The symbol is for a section.
Section,
/// The symbol is the name of a file. It precedes symbols within that file.
File,
/// The symbol is for a code label.
Label,
/// The symbol is for a thread local storage entity.
Tls,
}
/// A symbol scope.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SymbolScope {
/// Unknown scope.
Unknown,
/// Symbol is visible to the compilation unit.
Compilation,
/// Symbol is visible to the static linkage unit.
Linkage,
/// Symbol is visible to dynamically linked objects.
Dynamic,
}
/// The operation used to calculate the result of the relocation.
///
/// The relocation descriptions use the following definitions. Note that
/// these definitions probably don't match any ELF ABI.
///
/// * A - The value of the addend.
/// * G - The address of the symbol's entry within the global offset table.
/// * L - The address of the symbol's entry within the procedure linkage table.
/// * P - The address of the place of the relocation.
/// * S - The address of the symbol.
/// * GotBase - The address of the global offset table.
/// * Image - The base address of the image.
/// * Section - The address of the section containing the symbol.
///
/// 'XxxRelative' means 'Xxx + A - P'. 'XxxOffset' means 'S + A - Xxx'.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RelocationKind {
/// The operation is unknown.
Unknown,
/// S + A
Absolute,
/// S + A - P
Relative,
/// G + A - GotBase
Got,
/// G + A - P
GotRelative,
/// GotBase + A - P
GotBaseRelative,
/// S + A - GotBase
GotBaseOffset,
/// L + A - P
PltRelative,
/// S + A - Image
ImageOffset,
/// S + A - Section
SectionOffset,
/// The index of the section containing the symbol.
SectionIndex,
}
/// Information about how the result of the relocation operation is encoded in the place.
///
/// This is usually architecture specific, such as specifying an addressing mode or
/// a specific instruction.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RelocationEncoding {
/// The relocation encoding is unknown.
Unknown,
/// Generic encoding.
Generic,
/// x86 sign extension at runtime.
///
/// Used with `RelocationKind::Absolute`.
X86Signed,
/// x86 rip-relative addressing.
///
/// The `RelocationKind` must be PC relative.
X86RipRelative,
/// x86 rip-relative addressing in movq instruction.
///
/// The `RelocationKind` must be PC relative.
X86RipRelativeMovq,
/// x86 branch instruction.
///
/// The `RelocationKind` must be PC relative.
X86Branch,
/// s390x PC-relative offset shifted right by one bit.
///
/// The `RelocationKind` must be PC relative.
S390xDbl,
/// AArch64 call target.
///
/// The `RelocationKind` must be PC relative.
AArch64Call,
/// LoongArch branch offset with two trailing zeros.
///
/// The `RelocationKind` must be PC relative.
LoongArchBranch,
/// SHARC+ 48-bit Type A instruction
///
/// Represents these possible variants, each with a corresponding
/// `R_SHARC_*` constant:
///
/// * 24-bit absolute address
/// * 32-bit absolute address
/// * 6-bit relative address
/// * 24-bit relative address
/// * 6-bit absolute address in the immediate value field
/// * 16-bit absolute address in the immediate value field
SharcTypeA,
/// SHARC+ 32-bit Type B instruction
///
/// Represents these possible variants, each with a corresponding
/// `R_SHARC_*` constant:
///
/// * 6-bit absolute address in the immediate value field
/// * 7-bit absolute address in the immediate value field
/// * 16-bit absolute address
/// * 6-bit relative address
SharcTypeB,
}
/// File flags that are specific to each file format.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum FileFlags {
/// No file flags.
None,
/// ELF file flags.
Elf {
/// `os_abi` field in the ELF file header.
os_abi: u8,
/// `abi_version` field in the ELF file header.
abi_version: u8,
/// `e_flags` field in the ELF file header.
e_flags: u32,
},
/// Mach-O file flags.
MachO {
/// `flags` field in the Mach-O file header.
flags: u32,
},
/// COFF file flags.
Coff {
/// `Characteristics` field in the COFF file header.
characteristics: u16,
},
/// XCOFF file flags.
Xcoff {
/// `f_flags` field in the XCOFF file header.
f_flags: u16,
},
}
/// Segment flags that are specific to each file format.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SegmentFlags {
/// No segment flags.
None,
/// ELF segment flags.
Elf {
/// `p_flags` field in the segment header.
p_flags: u32,
},
/// Mach-O segment flags.
MachO {
/// `flags` field in the segment header.
flags: u32,
/// `maxprot` field in the segment header.
maxprot: u32,
/// `initprot` field in the segment header.
initprot: u32,
},
/// COFF segment flags.
Coff {
/// `Characteristics` field in the segment header.
characteristics: u32,
},
}
/// Section flags that are specific to each file format.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SectionFlags {
/// No section flags.
None,
/// ELF section flags.
Elf {
/// `sh_flags` field in the section header.
sh_flags: u64,
},
/// Mach-O section flags.
MachO {
/// `flags` field in the section header.
flags: u32,
},
/// COFF section flags.
Coff {
/// `Characteristics` field in the section header.
characteristics: u32,
},
/// XCOFF section flags.
Xcoff {
/// `s_flags` field in the section header.
s_flags: u32,
},
}
/// Symbol flags that are specific to each file format.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SymbolFlags<Section, Symbol> {
/// No symbol flags.
None,
/// ELF symbol flags.
Elf {
/// `st_info` field in the ELF symbol.
st_info: u8,
/// `st_other` field in the ELF symbol.
st_other: u8,
},
/// Mach-O symbol flags.
MachO {
/// `n_desc` field in the Mach-O symbol.
n_desc: u16,
},
/// COFF flags for a section symbol.
CoffSection {
/// `Selection` field in the auxiliary symbol for the section.
selection: u8,
/// `Number` field in the auxiliary symbol for the section.
associative_section: Option<Section>,
},
/// XCOFF symbol flags.
Xcoff {
/// `n_sclass` field in the XCOFF symbol.
n_sclass: u8,
/// `x_smtyp` field in the CSECT auxiliary symbol.
///
/// Only valid if `n_sclass` is `C_EXT`, `C_WEAKEXT`, or `C_HIDEXT`.
x_smtyp: u8,
/// `x_smclas` field in the CSECT auxiliary symbol.
///
/// Only valid if `n_sclass` is `C_EXT`, `C_WEAKEXT`, or `C_HIDEXT`.
x_smclas: u8,
/// The containing csect for the symbol.
///
/// Only valid if `x_smtyp` is `XTY_LD`.
containing_csect: Option<Symbol>,
},
}
/// Relocation fields that are specific to each file format and architecture.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum RelocationFlags {
/// Format independent representation.
Generic {
/// The operation used to calculate the result of the relocation.
kind: RelocationKind,
/// Information about how the result of the relocation operation is encoded in the place.
encoding: RelocationEncoding,
/// The size in bits of the place of relocation.
size: u8,
},
/// ELF relocation fields.
Elf {
/// `r_type` field in the ELF relocation.
r_type: u32,
},
/// Mach-O relocation fields.
MachO {
/// `r_type` field in the Mach-O relocation.
r_type: u8,
/// `r_pcrel` field in the Mach-O relocation.
r_pcrel: bool,
/// `r_length` field in the Mach-O relocation.
r_length: u8,
},
/// COFF relocation fields.
Coff {
/// `typ` field in the COFF relocation.
typ: u16,
},
/// XCOFF relocation fields.
Xcoff {
/// `r_rtype` field in the XCOFF relocation.
r_rtype: u8,
/// `r_rsize` field in the XCOFF relocation.
r_rsize: u8,
},
}