elfldltl

Namespaces

Enumerations

enum ElfClass

Name	Value
k32	1
k64	2
kNative	[]() { if constexpr (sizeof(uintptr_t) == sizeof(uint64_t)) { return k64; } else if constexpr (sizeof(uintptr_t) == sizeof(uint32_t)) { return k32; } }()

The bit width (32-bit vs 64-bit) is called the "ELF class".

Defined at line 18 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ResolverPolicy

Name	Value
kStrictLinkOrder	0
kStrongOverWeak	1

Defined at line 22 of file ../../src/lib/elfldltl/include/lib/elfldltl/resolve.h

enum RDebugState

Name	Value
kConsistent	0
kAdd	1
kDelete	2

Recognized values for RDebug::state field. See below.

Defined at line 22 of file ../../src/lib/elfldltl/include/lib/elfldltl/svr4-abi.h

enum ElfData

Name	Value
k2Lsb	1
k2Msb	2
kNative	[]() { if constexpr (std::endian::native == std::endian::little) { return k2Lsb; } else if constexpr (std::endian::native == std::endian::big) { return k2Msb; } }()

The byte order (Least Significant Byte first, aka little-endian, vs

Most Significant Byte first, aka big-endian) used in ELF metadata.

All fields are stored as two's complement integers, hence the names.

Defined at line 34 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfVersion

Name	Value
kCurrent	1

This is just a fixed constant that cannot vary.

Defined at line 58 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfType

Name	Value
kNone	0
kRel	1
kExec	2
kDyn	3
kCore	4

This indicates the type of ELF file, found in Elf::Ehdr::type(). Only

ET_DYN is handled at runtime but the others are provided for the convenience

of other tools.

Defined at line 63 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum RelocateTls

Name	Value
kNone	0
kDynamic	1
kStatic	2
kDesc	3

Symbolic relocation for STT_TLS symbols requires the symbolic resolution

engine meet different invariants depending on the specific relocation type.

Defined at line 65 of file ../../src/lib/elfldltl/include/lib/elfldltl/link.h

enum ElfPhdrType

Name	Value
kNull	0
kLoad	1
kDynamic	2
kInterp	3
kNote	4
kPhdr	6
kTls	7
kEhFrameHdr	0x6474e550
kStack	0x6474e551
kRelro	0x6474e552

These are the types of program headers, found in Elf::Phdr::type().

This lists only the types used at runtime.

Defined at line 73 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfShdrType

Name	Value
kNull	0
kProgbits	1
kSymtab	2
kStrtab	3
kRela	4
kHash	5
kDynamic	6
kNote	7
kNobits	8
kRel	9
kShlib	10
kDynsym	11
kInitArray	14
kFiniArray	15
kPreinitArray	16
kGroup	17
kSymtabShndx	18
kGnuAttributes	0x6ffffff5
kGnuHash	0x6ffffff6
kGnuLiblist	0x6ffffff7
kChecksum	0x6ffffff8
kSunwMove	0x6ffffffa
kSunwComdat	0x6ffffffb
kSunwSyminfo	0x6ffffffc
kGnuVerdef	0x6ffffffd
kGnuVerneed	0x6ffffffe
kGnuVersym	0x6fffffff

These are the types of section headers, found in Elf::Shdr::type().

Defined at line 87 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfDynTag

Name	Value
kNull	0
kNeeded	1
kPltRelSz	2
kPltGot	3
kHash	4
kStrTab	5
kSymTab	6
kRela	7
kRelaSz	8
kRelaEnt	9
kStrSz	10
kSymEnt	11
kInit	12
kFini	13
kSoname	14
kRpath	15
kSymbolic	16
kRel	17
kRelSz	18
kRelEnt	19
kPltRel	20
kDebug	21
kTextRel	22
kJmpRel	23
kBindNow	24
kInitArray	25
kFiniArray	26
kInitArraySz	27
kFiniArraySz	28
kRunPath	29
kFlags	30
kPreinitArray	32
kPreinitArraySz	33
kSymTabShndx	34
kRelrSz	35
kRelr	36
kRelrEnt	37
kFeature1	0x6ffffdfc
kGnuHash	0x6ffffef5
kTlsDescPlt	0x6ffffef6
kTlsDescGot	0x6ffffef7
kRelaCount	0x6ffffff9
kRelCount	0x6ffffffa
kFlags1	0x6ffffffb

These are the PT_DYNAMIC entry tags, found in Elf::Dyn::tag().

Defined at line 118 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfSymBind

Name	Value
kLocal	0
kGlobal	1
kWeak	2
kUnique	10

These are the "binding" classes of symbols, found in Elf::Sym::bind().

Defined at line 194 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfSymType

Name	Value
kNoType	0
kObject	1
kFunc	2
kSection	3
kFile	4
kCommon	5
kTls	6
kIfunc	10

These are the types of symbols, found in Elf::Sym::type().

Defined at line 202 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfSymVisibility

Name	Value
kDefault	0
kInternal	1
kHidden	2
kProtected	3

These are the symbol visibility types, found in Elf::Sym::visibility().

Defined at line 214 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfMachine

Name	Value
kNone	0
k386	3
kArm	40
kX86_64	62
kAarch64	183
kRiscv	243
kNative	[]() { #ifdef __aarch64__ return kAarch64; #elif defined(__arm__) return kArm; #elif defined(__i386__) return k386; #elif defined(__x86_64__) return kX86_64; #elif defined(__riscv) return kRiscv; #endif return kNone; }()

This indicates the machine architecture the ELF file is for, as found in

Elf::Ehdr::machine(). There are many more EM_* constants specified by ELF.

This lists only those for which the library provides some degree of support.

Defined at line 224 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum ElfNoteType

Name	Value
kGnuBuildId	3
kGnuPropertyType0	5

These are types used in notes. Other types might appear in note headers.

Only those used by the library are listed here.

Defined at line 292 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h

enum PhdrLoadPolicy

Name	Value
kBasic	0
kFileRangeMonotonic	1
kContiguous	2

PT_LOAD validation policy. Subsequent values extend previous ones.

Defined at line 399 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h

Records

Functions

template <class Diagnostics>

UniqueFdFile<Diagnostics> <deduction guide for UniqueFdFile> (fbl::unique_fd fd, Diagnostics & diagnostics)

Deduction guides.

template <class Diagnostics>

UniqueFdFile<Diagnostics> <deduction guide for UniqueFdFile> (Diagnostics & diagnostics)

template <class Diagnostics>

FdFile<Diagnostics> <deduction guide for FdFile> (int fd, Diagnostics & diagnostics)

Deduction guides.

template <class Diagnostics>

FdFile<Diagnostics> <deduction guide for FdFile> (Diagnostics & diagnostics)

template <class Diagnostics>

VmoFile<Diagnostics> <deduction guide for VmoFile> (zx::vmo vmo, Diagnostics && diagnostics)

Deduction guide.

template <typename... Args>

AbiSpan<typename decltype(std::span{std::forward<Args>(args)...})::element_type, decltype(std::span{std::forward<Args>(args)...})::extent> <deduction guide for AbiSpan> (Args &&... args)

Deduction guide, equivalent to the std::span deduction guide.

template <typename... Args>

AbiSpan<typename decltype(std::span{std::forward<Args>(args)...})::element_type, decltype(std::span{std::forward<Args>(args)...})::extent> <deduction guide for AbiSpan> (Args &&... args)

Deduction guide, equivalent to the std::span deduction guide.

template <typename... Args>

AbiSpan<typename decltype(std::span{std::forward<Args>(args)...})::element_type, decltype(std::span{std::forward<Args>(args)...})::extent> <deduction guide for AbiSpan> (Args &&... args)

Deduction guide, equivalent to the std::span deduction guide.

template <class LoadInfo, class Memory>

LoadInfoMappedMemory<LoadInfo, Memory> <deduction guide for LoadInfoMappedMemory> (const LoadInfo & , Memory & )

Deduction guide.

template <class Diagnostics>

UnownedVmoFile<Diagnostics> <deduction guide for UnownedVmoFile> (zx::unowned_vmo vmo, Diagnostics && diagnostics)

Deduction guide.

template <typename size_type>

FileOffset<size_type> <deduction guide for FileOffset> (size_type )

Deduction guides.

template <typename size_type, bool kSwap>

FileOffset<size_type> <deduction guide for FileOffset> (UnsignedField<size_type, kSwap> )

template <typename size_type>

FileAddress<size_type> <deduction guide for FileAddress> (size_type )

Deduction guides.

template <typename size_type, bool kSwap>

FileAddress<size_type> <deduction guide for FileAddress> (UnsignedField<size_type, kSwap> )

template <typename T>

AbiPtr<T> <deduction guide for AbiPtr> (T * )

Deduction guide.

template <typename T>

AbiPtr<T> <deduction guide for AbiPtr> (T * )

Deduction guide.

template <class Diagnostics, class LoadInfo, typename GetMutableMemory>

LoadInfoMutableMemory<Diagnostics, LoadInfo, std::decay_t<GetMutableMemory>> <deduction guide for LoadInfoMutableMemory> (Diagnostics & , LoadInfo & , GetMutableMemory && )

Deduction guide. Explicit template parameters must be used for everything

to use a different Container template, since deduction guides can't be

partially specialized.

template <typename T, size_t N>

PreallocatedVector<T, N> <deduction guide for PreallocatedVector> (std::span<T, N> )

Deduction guide.

template <typename T, size_t N>

PreallocatedVector<T, N> <deduction guide for PreallocatedVector> (std::span<T, N> )

Deduction guide.

template <typename T, size_t N>

PreallocatedVector<T, N> <deduction guide for PreallocatedVector> (std::span<T, N> )

Deduction guide.

template <typename T, size_t N>

PreallocatedVector<T, N> <deduction guide for PreallocatedVector> (std::span<T, N> )

Deduction guide.

template <typename T, size_t N>

PreallocatedVector<T, N> <deduction guide for PreallocatedVector> (std::span<T, N> )

Deduction guide.

```
template <class Elf, class File, typename Allocator, typename... Callback>
```
```
PhdrFileNoteObserver<std::decay_t<Elf>::kData, File, std::decay_t<Allocator>, std::decay_t<Callback>...> <deduction guide for PhdrFileNoteObserver> (Elf && , File & , Allocator && , Callback &&... )
```
Deduction guide. When used without template parameters, the first

constructor argument is an empty Elf

<

...> object to identify the format; the

second is always an lvalue reference (see memory.h); the third is forwarded

as the allocator object used by File::ReadArrayFromFile

<std

::byte>; while

the later arguments (some objects invocable as if functions with type

`fit::result

<fit

::failed, bool>(ElfNote)`) are moved or copied so they can

safely be temporaries. Use std::ref or std::cref to make the

PhdrFileNoteObserver object hold a callback by reference instead.

template <class Elf>

DynamicRelocationInfoObserver<Elf> <deduction guide for DynamicRelocationInfoObserver> (RelocationInfo<Elf> & info)

Deduction guide.

template <class Elf, class Memory, typename... Callback>

PhdrMemoryNoteObserver<std::decay_t<Elf>::kData, Memory, std::decay_t<Callback>...> <deduction guide for PhdrMemoryNoteObserver> (Elf && , Memory & , Callback &&... )

Deduction guide, as for PhdrFileNoteObserver but with no allocator argument.

template <class Elf>

DynamicSymbolInfoObserver<Elf> <deduction guide for DynamicSymbolInfoObserver> (SymbolInfo<Elf> & info)

Deduction guide.

template <class Elf>

DynamicInitObserver<Elf> <deduction guide for DynamicInitObserver> (InitFiniInfo<Elf> & info)

Deduction guides.

template <class Elf>

DynamicFiniObserver<Elf> <deduction guide for DynamicFiniObserver> (InitFiniInfo<Elf> & info)

template <class Elf, class AbiTraits, template <class, class> class SymbolInfo, class Callback>

DynamicNeededObserver<Elf, SymbolInfo<Elf, AbiTraits>, Callback> <deduction guide for DynamicNeededObserver> (const SymbolInfo<Elf, AbiTraits> & info, Callback )

Deduction guides.

```
template <class Phdr>
```
```
std::pair<decltype(phdr.vaddr()), decltype(phdr.memsz())> RelroBounds (const Phdr & phdr, decltype(phdr.memsz()) pagesize)
```
Returns {start, size} whole-page subregion of the segment, possibly {0, 0}.

Defined at line 18 of file ../../src/lib/elfldltl/include/lib/elfldltl/relro.h
```
template <typename Handle>
```
```
auto DefaultMakeInvalidHandle ()
```
Defined at line 23 of file ../../src/lib/elfldltl/include/lib/elfldltl/file.h
```
uint32_t CompatHashString (std::string_view name)
```
This handles the DT_HASH format, which is mostly obsolete but is the

official ELF standard format. This interface matches GnuHash (gnu-hash.h).

See SymbolInfo (symbol.h) for details.

Defined at line 23 of file ../../src/lib/elfldltl/include/lib/elfldltl/compat-hash.h
```
uint32_t CompatHashString (std::string_view name)
```
This handles the DT_HASH format, which is mostly obsolete but is the

official ELF standard format. This interface matches GnuHash (gnu-hash.h).

See SymbolInfo (symbol.h) for details.

Defined at line 23 of file ../../src/lib/elfldltl/include/lib/elfldltl/compat-hash.h
```
template <typename S, typename CharT, class Traits>
```
```
decltype(auto) operator<< (S && ostream, const internal::ConstString<CharT, Traits> & string)
```
These overloads let the object returned by OstreamDiagnostics format the

special argument types.

Defined at line 25 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h
```
uint32_t GnuHashString (std::string_view name)
```
This handles the DT_GNU_HASH format, which is the de facto standard format.

This interface matches CompatHash (compat-hash.h).

See SymbolInfo (symbol.h) for details.

Defined at line 25 of file ../../src/lib/elfldltl/include/lib/elfldltl/gnu-hash.h
```
uint32_t GnuHashString (std::string_view name)
```
This handles the DT_GNU_HASH format, which is the de facto standard format.

This interface matches CompatHash (compat-hash.h).

See SymbolInfo (symbol.h) for details.

Defined at line 25 of file ../../src/lib/elfldltl/include/lib/elfldltl/gnu-hash.h
```
template <class Diagnostics, class RelocInfo, auto& memory>
```
```
bool RelocateRelative (Diagnostics & diag, MemoryWriter<typename RelocInfo::size_type, typename RelocInfo::Addr> auto & memory, const RelocInfo & info, typename RelocInfo::size_type bias)
```
Apply simple fixups as directed by Elf::RelocationInfo, given the load bias:

the difference between runtime addresses and addresses that appear in the

relocation records. This calls memory.Store(reloc_address, runtime_address)

or memory.StoreAdd(reloc_address, bias) to store the adjusted values.

Returns false iff any calls into the Memory object returned false.

Defined at line 29 of file ../../src/lib/elfldltl/include/lib/elfldltl/link.h

template <typename S, typename T>

decltype(auto) operator<< (S && ostream, FileOffset<T> offset)

Defined at line 32 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h

template <class Phdr>

std::pair<decltype(phdrs[0].vaddr()), decltype(phdrs[0].memsz())> RelroBounds (std::span<const Phdr> phdrs, decltype(phdrs[0].memsz()) pagesize)

Given a span of all the phdrs, find and reduce the PT_GNU_RELRO segment.

Defined at line 34 of file ../../src/lib/elfldltl/include/lib/elfldltl/relro.h

template <class Phdr>

std::pair<decltype(phdrs[0].vaddr()), decltype(phdrs[0].memsz())> RelroBounds (std::span<const Phdr> phdrs, decltype(phdrs[0].memsz()) pagesize)

Given a span of all the phdrs, find and reduce the PT_GNU_RELRO segment.

Defined at line 34 of file ../../src/lib/elfldltl/include/lib/elfldltl/relro.h

```
template <size_t N>
```
```
std::array<SymbolName, N> PerfectSymbolTable (SymbolName (&&)[N] names)
```
Use this to initialize a constexpr variable, as in:

```

constexpr auto kFooSymbols = elfldltl::PerfectSymbolTable({

"foo",

"bar",

});

```

Thereafter use `kFooSymbols` as a template parameter for the classes below.

It's a good idea to do this in an anonymous namespace, so that all the

instantiations using it have internal linkage and the tables are only

generated or used directly in a single translation unit.

Defined at line 36 of file ../../src/lib/elfldltl/include/lib/elfldltl/perfect-symbol-table.h
```
template <class Self, class DiagnosticsType, typename... Args>
```
```
void LinkStaticPie (const Self & self, DiagnosticsType & diagnostics, Args &&... args)
```
The templated form uses the elfldltl::Self implementation for the known

ElfClass of the metadata, selected by the type of the first (self) argument.

There are two optional std::byte* arguments for the bounds of the program

image, as for elfldltl::Self::Memory(), which see. Those arguments can be

omitted for a normal PIE layout ELF runtime image where the `__ehdr_start`

and `_end` link-time symbols define the bounds of the image.

Defined at line 37 of file ../../src/lib/elfldltl/include/lib/elfldltl/static-pie.h
```
template <class Diagnostics, class Ehdr, ReadArrayFromFileAllocator<typename Ehdr::ElfLayout::Phdr, uint32_t> Allocator, auto& file>
```
```
auto ReadPhdrsFromFile (Diagnostics & diagnostics, CanReadArrayFromFile<typename Ehdr::ElfLayout::Phdr, Allocator, typename Ehdr::ElfLayout::size_type> auto & file, Allocator && allocator, const Ehdr & ehdr)
```
Read program headers from an ELF file using the File API (see memory.h),

given its file header (Ehdr) already read and validated.

This takes a Diagnostics object (see diagnostics.h) and a File object (see

memory.h) by reference. It ultimately calls `file.ReadArrayFromFile

<Phdr

>`

and returns that value if all goes well. The Allocator argument is just

forwarded to File::ReadArrayFromFile; see memory.h for API details.

All the template parameters are normally deduced, including the Elf layout

to use based on the Ehdr type used for the last argument.

Defined at line 37 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h

template <typename S, typename T>

decltype(auto) operator<< (S && ostream, FileAddress<T> address)

Defined at line 40 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h

```
template <class Elf, class Diagnostics, auto& file>
```
```
decltype(file.template ReadFromFile<typename Elf::Ehdr>(0)) LoadEhdrFromFile (Diagnostics & diagnostics, CanReadFromFile<typename Elf::Ehdr, decltype(0)> auto & file, std::optional<ElfMachine> machine)
```
Read the ELF file header (Ehdr) from an ELF file using the File API (see

memory.h), and validate it for loading on this machine.

The first template parameter gives the elfldltl::Elf

<

...> layout to use,

i.e. usually elfldltl::Elf

<

> for native loading. The rest are deduced. If

the optional final argument is passed, it can be std::nullopt to accept any

machine or another ElfMachine value to match rather than the native machine.

This returns the return value of calling file.ReadFromFile

<Ehdr

>,

i.e. some type std::optional

<E

> where `const Ehdr

&

ehdr =

<E

object>;`

works and the E object owns the storage ehdr points into.

Defined at line 42 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
template <class Elf, class Diagnostics, auto& file>
```
```
decltype(file.template ReadFromFile<typename Elf::Ehdr>(0)) LoadEhdrFromFile (Diagnostics & diagnostics, CanReadFromFile<typename Elf::Ehdr, decltype(0)> auto & file, std::optional<ElfMachine> machine)
```
Read the ELF file header (Ehdr) from an ELF file using the File API (see

memory.h), and validate it for loading on this machine.

The first template parameter gives the elfldltl::Elf

<

...> layout to use,

i.e. usually elfldltl::Elf

<

> for native loading. The rest are deduced. If

the optional final argument is passed, it can be std::nullopt to accept any

machine or another ElfMachine value to match rather than the native machine.

This returns the return value of calling file.ReadFromFile

<Ehdr

>,

i.e. some type std::optional

<E

> where `const Ehdr

&

ehdr =

<E

object>;`

works and the E object owns the storage ehdr points into.

Defined at line 42 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
std::string_view ElfDataName (ElfData data, bool upper)
```
Defined at line 47 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h
```
template <typename S>
```
```
decltype(auto) operator<< (S && ostream, ElfMachine machine)
```
Defined at line 48 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h

template <class Self, class DiagnosticsType, typename... DynamicObservers>

SymbolInfo<typename Self::Elf> LinkStaticPieWithVdso (const Self & self, DiagnosticsType & diagnostics, const SymbolInfo<typename Self::Elf> & vdso_symbols, typename Self::Elf::size_type vdso_bias, DynamicObservers &&... dynamic_observers)

This version takes vDSO details already distilled separately.

Defined at line 49 of file ../../src/lib/elfldltl/include/lib/elfldltl/static-pie-with-vdso.h

template <class Elf = elfldltl::Elf<>, forward_range Range, invocable<std::ranges::range_reference_t<Range>> Proj, auto& diag>

fit::result<bool, ResolveSymbolResult<Elf, std::ranges::iterator_t<Range>>> ResolveSymbol (auto & diag, Range && modules, Proj && proj, ResolverPolicy policy)

Defined at line 56 of file ../../src/lib/elfldltl/include/lib/elfldltl/resolve.h

template <typename S, typename T, typename = decltype(std::declval<T>().str())>

decltype(auto) operator<< (S && ostream, T && t)

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h

```
template <class DiagnosticsType, class Memory, class Dyn, size_t N, class... Observers>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, std::span<const Dyn, N> dyn, Observers &&... observers)
```
This decodes a dynamic section by matching each entry against a list of

observers. Each observer should be of a subclass of DynamicTagObserver that

indicates the tags it matches. If any matching observer returns false then

this stops processing early and returns false. Otherwise, each observer's

Finish method is called, stopping early if one returns false.

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <class DiagnosticsType, class Memory, class Dyn, size_t N, class... Observers>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, std::span<const Dyn, N> dyn, Observers &&... observers)
```
This decodes a dynamic section by matching each entry against a list of

observers. Each observer should be of a subclass of DynamicTagObserver that

indicates the tags it matches. If any matching observer returns false then

this stops processing early and returns false. Otherwise, each observer's

Finish method is called, stopping early if one returns false.

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <class DiagnosticsType, class Memory, class Dyn, size_t N, class... Observers>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, std::span<const Dyn, N> dyn, Observers &&... observers)
```
This decodes a dynamic section by matching each entry against a list of

observers. Each observer should be of a subclass of DynamicTagObserver that

indicates the tags it matches. If any matching observer returns false then

this stops processing early and returns false. Otherwise, each observer's

Finish method is called, stopping early if one returns false.

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <class DiagnosticsType, class Memory, class Dyn, size_t N, class... Observers>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, std::span<const Dyn, N> dyn, Observers &&... observers)
```
This decodes a dynamic section by matching each entry against a list of

observers. Each observer should be of a subclass of DynamicTagObserver that

indicates the tags it matches. If any matching observer returns false then

this stops processing early and returns false. Otherwise, each observer's

Finish method is called, stopping early if one returns false.

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <class DiagnosticsType, class Memory, class Dyn, size_t N, class... Observers>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, std::span<const Dyn, N> dyn, Observers &&... observers)
```
This decodes a dynamic section by matching each entry against a list of

observers. Each observer should be of a subclass of DynamicTagObserver that

indicates the tags it matches. If any matching observer returns false then

this stops processing early and returns false. Otherwise, each observer's

Finish method is called, stopping early if one returns false.

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <typename Ostream, typename... Args>
```
```
auto OstreamDiagnosticsReport (Ostream & ostream, Args &&... prefix)
```
This returns a Report callable that uses

<

<

on an ostream-style object.

Any additional arguments are passed via

<

<

as a prefix on each message. The

ostream should probably be in

<

<

std::hex state for the output to look good.

Defined at line 65 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h
```
template <typename Ostream, class Flags = DiagnosticsFlags, typename... Args>
```
```
auto OstreamDiagnostics (Ostream & ostream, Flags && flags, Args &&... prefix)
```
This returns a Diagnostics object using OstreamDiagnosticsReport.

Defined at line 78 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics-ostream.h
```
template <class DiagnosticsType, class Memory, class Dyn, class Observer, ElfDynTag... Tags>
```
```
bool DecodeDynamic (DiagnosticsType && diagnostics, Memory && memory, const Dyn & entry, DynamicTagObserver<Observer, Tags...> & observer)
```
Match a single dynamic section entry against a single observer. If the

observer matches, its Observe overload for the matching tag is called.

Returns the value of that call, or true if this observer didn't match.

Defined at line 80 of file ../../src/lib/elfldltl/include/lib/elfldltl/dynamic.h
```
template <class Elf, class Diagnostics, class File, ReadArrayFromFileAllocator<typename Elf::Phdr, uint32_t> PhdrAllocator>
```
```
decltype(std::make_optional(std::make_pair(*file.template ReadFromFile<typename Elf::Ehdr>(0), *file.template ReadArrayFromFile<typename Elf::Phdr>(0, phdr_allocator, 0)))) LoadHeadersFromFile (Diagnostics & diagnostics, File & file, PhdrAllocator && phdr_allocator, std::optional<ElfMachine> machine)
```
Read the ELF file header (Ehdr) and program headers (Phdr) from an ELF file

using the File API (see memory.h), and validate for loading on this machine.

This just combines LoadEhdrFromFile and ReadPhdrsFromFile (see phdr.h).

It returns std::optional

<std

::pair

<E

, P>> where LoadEhdrFromFile returns

std::optional

<E

> and ReadPhdrsFromFile returns std::optional

<P

>. e.g.,

```

auto headers = elfldltl::LoadHeadersFromFile

<elfldltl

::Elf

<

>>(...);

if (headers) {

auto [ehdr_owner, phdrs_owner] = *headers;

const Ehdr

&

ehdr = ehdr_owner;

const std::span

<const

Phdr> phdrs = phdrs_owner;

...

}

```

Defined at line 80 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
template <class Elf, class Diagnostics, class File, ReadArrayFromFileAllocator<typename Elf::Phdr, uint32_t> PhdrAllocator>
```
```
decltype(std::make_optional(std::make_pair(*file.template ReadFromFile<typename Elf::Ehdr>(0), *file.template ReadArrayFromFile<typename Elf::Phdr>(0, phdr_allocator, 0)))) LoadHeadersFromFile (Diagnostics & diagnostics, File & file, PhdrAllocator && phdr_allocator, std::optional<ElfMachine> machine)
```
Read the ELF file header (Ehdr) and program headers (Phdr) from an ELF file

using the File API (see memory.h), and validate for loading on this machine.

This just combines LoadEhdrFromFile and ReadPhdrsFromFile (see phdr.h).

It returns std::optional

<std

::pair

<E

, P>> where LoadEhdrFromFile returns

std::optional

<E

> and ReadPhdrsFromFile returns std::optional

<P

>. e.g.,

```

auto headers = elfldltl::LoadHeadersFromFile

<elfldltl

::Elf

<

>>(...);

if (headers) {

auto [ehdr_owner, phdrs_owner] = *headers;

const Ehdr

&

ehdr = ehdr_owner;

const std::span

<const

Phdr> phdrs = phdrs_owner;

...

}

```

Defined at line 80 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
template <class Diagnostics, class File, class MetaAllocator, typename Callback>
```
```
bool WithLoadHeadersFromFile (Diagnostics & diagnostics, File & file, MetaAllocator && meta_allocator, Callback && callback, std::optional<ElfData> expected_data, std::optional<ElfMachine> machine)
```
This does the same work as LoadHeadersFromFile, but handles different

ELFCLASS (and optionally, ELFDATA) formats in the ELF file. It returns

false if the file is invalid, or else returns the result of invoking the

callback as `bool(const Ehdr

&

, std::span

<const

Phdr>)` for the particular

Elf64

<

...> or Elf32

<

...> instantiation chosen.

The MetaAllocator is a lambda

<typename

T>(size_t) that is called with the

specific elfldltl::Elf

<

...>Phdr type as an explicit template parameter and

should otherwise act like the Allocator API object for ReadArrayFromFile

<T

>.

If the optional expected_data argument is provided, it can be std::nullopt

to permit callbacks with either data format (byte order) as well as either

class. The final optional argument gives the machine architecture to match,

and likewise can be std::nullopt to accept any machine.

Defined at line 111 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
template <class Diagnostics, class File, class MetaAllocator, typename Callback>
```
```
bool WithLoadHeadersFromFile (Diagnostics & diagnostics, File & file, MetaAllocator && meta_allocator, Callback && callback, std::optional<ElfData> expected_data, std::optional<ElfMachine> machine)
```
This does the same work as LoadHeadersFromFile, but handles different

ELFCLASS (and optionally, ELFDATA) formats in the ELF file. It returns

false if the file is invalid, or else returns the result of invoking the

callback as `bool(const Ehdr

&

, std::span

<const

Phdr>)` for the particular

Elf64

<

...> or Elf32

<

...> instantiation chosen.

The MetaAllocator is a lambda

<typename

T>(size_t) that is called with the

specific elfldltl::Elf

<

...>Phdr type as an explicit template parameter and

should otherwise act like the Allocator API object for ReadArrayFromFile

<T

>.

If the optional expected_data argument is provided, it can be std::nullopt

to permit callbacks with either data format (byte order) as well as either

class. The final optional argument gives the machine architecture to match,

and likewise can be std::nullopt to accept any machine.

Defined at line 111 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h
```
template <class Elf, class DiagnosticsType>
```
```
std::pair<SymbolInfo<Elf>, uintptr_t> GetVdsoSymbols (DiagnosticsType & diagnostics, const void * vdso_base)
```
This distills the vDSO symbols and load bias from the image in memory.

Defined at line 124 of file ../../src/lib/elfldltl/include/lib/elfldltl/static-pie-with-vdso.h
```
template <class Elf, class DiagnosticsType>
```
```
std::pair<SymbolInfo<Elf>, uintptr_t> GetVdsoSymbols (DiagnosticsType & diagnostics, const void * vdso_base)
```
This distills the vDSO symbols and load bias from the image in memory.

Defined at line 124 of file ../../src/lib/elfldltl/include/lib/elfldltl/static-pie-with-vdso.h
```
template <ElfMachine Machine = ElfMachine::kNative, class DiagnosticsType, class RelocInfo, class SymbolInfo, typename Resolve, auto& memory>
```
```
bool RelocateSymbolic (MemoryApi<typename RelocInfo::size_type, typename RelocInfo::Elf::Addr, typename RelocInfo::Elf::Addend> auto & memory, DiagnosticsType & diagnostics, const RelocInfo & reloc_info, const SymbolInfo & symbol_info, typename RelocInfo::size_type bias, Resolve && resolve)
```
Apply symbolic relocations as directed by Elf::RelocationInfo, referring to

Elf::SymbolInfo as adjusted by the load bias (as used in RelocateRelative).

The callback function and methods on its returned Definition here use

`fit::result

<bool

, ...>` for cases where failure to deliver a result is an

option. The error value is like the return value from a Diagnostics object,

indicating whether to continue applying more relocations or to bail out

after this failure. The callback function is:

* fit::result

<bool

, Definition> resolve(const Sym

&

, RelocateTls)

where Definition is some type defined by the caller that supports methods:

* bool undefined_weak()

Returns true iff the symbol was resolved as an undefined weak reference.

* size_type bias()

Returns the load bias for symbol addresses in the defining module.

* const Sym

&

symbol()

Returns the defining symbol table entry.

* size_type tls_module_id()

Returns the TLS module ID number for the defining module.

* size_type static_tls_bias()

Returns the static TLS layout bias for the defining module.

* TlsDescGot tls_desc_undefined_weak()

This is only called if undefined_weak() returned true first.

Returns the GOT contents for a TLSDESC resolution that was an

undefined weak symbol. This overload does not require the addend

up front. Instead, the TlsDescGot::value field will have the

addend applied implicitly.

* TlsDescGot tls_desc_undefined_weak(Addend addend)

This is only called if undefined_weak() returned true first.

Returns the GOT contents for a TLSDESC resolution that was an

undefined weak. This overload can use the relocation addend in

choosing the TLSDESC implementation, but this requires an extra

load in the DT_REL case. The return value will be used as is.

* fit::result

<bool

,

<TlsDescGot

> tls_desc(Diagnostics

&

, Addend addend)

Returns the GOT contents for a TLSDESC resolution, which can fail.

If this overload is present, then it is always used and the second

overload need not be defined. This overload can use the relocation

addend in choosing the TLSDESC implementation, but this requires an

extra load in the DT_REL case. The return value will be used as is.

* fit::result

<bool

, TlsDescGot> tls_desc(Diagnostics

&

)

Returns the GOT contents for a TLSDESC resolution, which can fail.

This overload does not require the addend up front. Instead, the

TlsDescGot::value field will have the addend applied implicitly.

Defined at line 127 of file ../../src/lib/elfldltl/include/lib/elfldltl/link.h
```
template <class Diagnostics, class Phdr, size_t N, class... Observers>
```
```
bool DecodePhdrs (Diagnostics && diagnostics, std::span<const Phdr, N> phdrs, Observers &&... observers)
```
This decodes a program header table by matching each entry against a list of

observers. Each observer should be of a subclass of PhdrObserver that

indicates the segment type it matches. If any matching observer returns

false then this stops processing early and returns false. Otherwise, each

observer's Finish method is called, stopping early if one returns false.

Defined at line 154 of file ../../src/lib/elfldltl/include/lib/elfldltl/internal/../phdr.h
```
template <class Diagnostics, class Phdr, size_t N, class... Observers>
```
```
bool DecodePhdrs (Diagnostics && diagnostics, std::span<const Phdr, N> phdrs, Observers &&... observers)
```
This decodes a program header table by matching each entry against a list of

observers. Each observer should be of a subclass of PhdrObserver that

indicates the segment type it matches. If any matching observer returns

false then this stops processing early and returns false. Otherwise, each

observer's Finish method is called, stopping early if one returns false.

Defined at line 154 of file ../../src/lib/elfldltl/include/lib/elfldltl/internal/../phdr.h
```
template <class Diagnostics, class Phdr, size_t N, class... Observers>
```
```
bool DecodePhdrs (Diagnostics && diagnostics, std::span<const Phdr, N> phdrs, Observers &&... observers)
```
This decodes a program header table by matching each entry against a list of

observers. Each observer should be of a subclass of PhdrObserver that

indicates the segment type it matches. If any matching observer returns

false then this stops processing early and returns false. Otherwise, each

observer's Finish method is called, stopping early if one returns false.

Defined at line 154 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <class Diagnostics, class Phdr, size_t N, class... Observers>
```
```
bool DecodePhdrs (Diagnostics && diagnostics, std::span<const Phdr, N> phdrs, Observers &&... observers)
```
This decodes a program header table by matching each entry against a list of

observers. Each observer should be of a subclass of PhdrObserver that

indicates the segment type it matches. If any matching observer returns

false then this stops processing early and returns false. Otherwise, each

observer's Finish method is called, stopping early if one returns false.

Defined at line 154 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <class Diagnostics, class Phdr, size_t N, class... Observers>
```
```
bool DecodePhdrs (Diagnostics && diagnostics, std::span<const Phdr, N> phdrs, Observers &&... observers)
```
This decodes a program header table by matching each entry against a list of

observers. Each observer should be of a subclass of PhdrObserver that

indicates the segment type it matches. If any matching observer returns

false then this stops processing early and returns false. Otherwise, each

observer's Finish method is called, stopping early if one returns false.

Defined at line 154 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <class Diagnostics, class Phdr, class Observer, ElfPhdrType... Type>
```
```
bool DecodePhdr (Diagnostics && diagnostics, const Phdr & phdr, PhdrObserver<Observer, Type...> & observer)
```
Match a single program header against a single observer. If the

observer matches, its Observe overload for the matching tag is called.

Returns the value of that call, or true if this observer didn't match.

Defined at line 168 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <typename T>
```
```
decltype(auto) VisitSelf (T && visitor)
```
Determine which ELF class is used in this program's own ELF header, in

case a 64-bit program was converted to ELFCLASS32 at link time.

Use it like:

```

auto rv = elfldltl::VisitSelf([](auto

&

&

self) { return self.Method(...); });

```

Defined at line 172 of file ../../src/lib/elfldltl/include/lib/elfldltl/self.h
```
template <class Self, class DiagnosticsType>
```
```
SymbolInfo<typename Self::Elf> LinkStaticPieWithVdso (const Self & self, DiagnosticsType & diagnostics, const void * vdso_base)
```
Do self-relocation against the vDSO so system calls can be made normally.

This is the simplified all-in-one version that decodes the all vDSO details

from memory itself. It returns the the program's own SymbolInfo data; see

<lib

/elfldltl/symbol.h> for details.

Defined at line 177 of file ../../src/lib/elfldltl/include/lib/elfldltl/static-pie-with-vdso.h
```
template <class Module, forward_range ModuleList, class Diagnostics, typename TlsDescResolver>
```
```
auto MakeSymbolResolver (const Module & ref_module, ModuleList & modules, Diagnostics & diag, TlsDescResolver & tlsdesc_resolver, ResolverPolicy policy)
```
Returns a callable object which can be used for RelocateSymbolic's `resolve`

argument. This takes some Module object (as described above) whose

symbol_info() contains the symbol given by RelocateSymbolic. The `modules`

argument is a list of modules from where symbolic definitions can be

resolved, this list is in order of precedence. The ModuleList type is a

forward iterable range or container. diag is a diagnostics object for

reporting errors. The TlsDescResolver is a callable object that's called as

`fit::result

<bool

, TlsDescGot>(Diagnostics

&

, const Definition

&

, Addend)` or

`fit::result

<bool

, TlsDescGot>(Diagnostics

&

, const Definition

&

)` for a

TLSDESDC relocation resolved to a defined symbol; and as `TlsDescGot()` or

`TlsDescGot(Addend)` for one resolved as an undefined weak reference.

All references passed to elfldltl::MakeSymbolResolver should outlive the

returned object, which in turn must outlive its return values (Definition

objects). The tlsdesc_resolver reference is saved in Definition objects so

it can be called from the RelocateSymbolic callbacks.

Defined at line 227 of file ../../src/lib/elfldltl/include/lib/elfldltl/resolve.h
```
template <class Container, class Diagnostics>
```
```
ReadArrayFromFileAllocator<typename Container::value_type> auto ContainerArrayFromFile (Diagnostics & diag, std::string_view error)
```
This returns an Allocator API object File::ReadArrayFromFile that uses a

Container API instantiation (see

<lib

/elfldltl/container.h>). The explicit

template parameter should be a specific ...::Container

<T

> instantiation to

be used with ReadArrayFromFile

<T

> (which should already meet the Allocator

API's return value requirement of being coercible to std::span

<T

> as

contiguous containers do). Note that this uses Container::resize and then

overwrites the default-constructed contents, so it's not best suited for

optimized use cases that should avoid the redundant default construction.

Defined at line 233 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h
```
template <class Container, class Diagnostics>
```
```
ReadArrayFromFileAllocator<typename Container::value_type> auto ContainerArrayFromFile (Diagnostics & diag, std::string_view error)
```
This returns an Allocator API object File::ReadArrayFromFile that uses a

Container API instantiation (see

<lib

/elfldltl/container.h>). The explicit

template parameter should be a specific ...::Container

<T

> instantiation to

be used with ReadArrayFromFile

<T

> (which should already meet the Allocator

API's return value requirement of being coercible to std::span

<T

> as

contiguous containers do). Note that this uses Container::resize and then

overwrites the default-constructed contents, so it's not best suited for

optimized use cases that should avoid the redundant default construction.

Defined at line 233 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h
```
std::string_view ElfMachineName (ElfMachine machine)
```
This is used by diagnostics-ostream.h and diagnostics-printf.h to handle

ElfMachine arguments nicely.

Defined at line 251 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h
```
std::string_view ElfMachineFileName (ElfMachine machine, ElfClass elfclass)
```
This can be used to assemble a file name or the like using the string that

the GN build system uses as $current_cpu when building modules of this sort.

Defined at line 271 of file ../../src/lib/elfldltl/include/lib/elfldltl/constants.h
```
template <typename Printer, typename... Prefix>
```
```
auto PrintfDiagnosticsReport (Printer && printer, Prefix &&... prefix)
```
This creates a callable object to use as the Report function in a

Diagnostics object; it calls the printer function like calling printf. The

remaining prefix arguments are treated like initial arguments passed to

every Diagnostics::FormatError call. The printer is called with a format

string literal, followed by various argument types corresponding to the '%'

formats used therein. That format and argument sequence is generated based

on the argument types as passed to FormatError.

Defined at line 360 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
template <typename... Prefix>
```
```
auto FprintfDiagnosticsReport (FILE * stream, Prefix &&... prefix)
```
This is just PrintfDiagnosticsReport with a printer function that calls

fprintf with the given FILE* argument.

Defined at line 371 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
template <typename... Prefix>
```
```
auto FprintfDiagnosticsReport (FILE * stream, Prefix &&... prefix)
```
This is just PrintfDiagnosticsReport with a printer function that calls

fprintf with the given FILE* argument.

Defined at line 371 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
Diagnostics<(lambda at ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h:387:25), elfldltl::DiagnosticsPanicFlags> TrapDiagnostics ()
```
This returns a Diagnostics object that crashes immediately for any error or

warning. There are no library dependencies of any kind. This behavior is

appropriate only for self-relocation and bootstrapping cases where if there

is anything wrong in the ELF data then something went wrong in building this

program itself and it shouldn't be running at all.

Defined at line 386 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
template <typename T, typename... Flags>
```
```
auto OneStringDiagnostics (T & holder, Flags &&... flags)
```
This returns a Diagnostics object that simply stores a single error or

warning message string. It always request early bail-out for errors on the

expectation that only one error will be reported. But if the same object is

indeed called again for another failure, the new error message will replace

the old one.

Defined at line 400 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
template <typename T, typename... Flags>
```
```
auto CollectStringsDiagnostics (T & container, Flags &&... flags)
```
This returns a Diagnostics object that collects a container of messages.

Defined at line 410 of file ../../src/lib/elfldltl/include/lib/elfldltl/diagnostics.h
```
(lambda at ../../src/lib/elfldltl/include/lib/elfldltl/note.h:432:10) ObserveBuildIdNote (std::optional<ElfNote> & build_id, bool keep_going)
```
This returns a fit::result

<fit

::failed.bool >(ElfNote) callback object that

can be passed to PhdrFileNoteObserver or PhdrMemoryNoteObserver. That

callback updates build_id to the file's (first) build ID note. If the

optional second argument is true, that callback returns fit::ok(false) after

it's found the build ID, so that PhdrFileNoteObserver would continue to call

additional callbacks on this and other notes rather than finish immediately.

Defined at line 431 of file ../../src/lib/elfldltl/include/lib/elfldltl/note.h
```
(lambda at ../../src/lib/elfldltl/include/lib/elfldltl/note.h:432:10) ObserveBuildIdNote (std::optional<ElfNote> & build_id, bool keep_going)
```
This returns a fit::result

<fit

::failed.bool >(ElfNote) callback object that

can be passed to PhdrFileNoteObserver or PhdrMemoryNoteObserver. That

callback updates build_id to the file's (first) build ID note. If the

optional second argument is true, that callback returns fit::ok(false) after

it's found the build ID, so that PhdrFileNoteObserver would continue to call

additional callbacks on this and other notes rather than finish immediately.

Defined at line 431 of file ../../src/lib/elfldltl/include/lib/elfldltl/note.h

template <class Elf, PhdrLoadPolicy Policy = PhdrLoadPolicy::kBasic, typename T>

auto MakePhdrLoadObserver (typename Elf::size_type page_size, typename Elf::size_type & vaddr_start, typename Elf::size_type & vaddr_size, T && callback)

This acts as a deduction guide with partial explicit specialization.

Defined at line 609 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h

```
template <class Phdr, typename T>
```
```
bool OnPhdrWritableSegments (std::span<const Phdr> phdrs, T && callback)
```
Given a set of phdrs, call the callback as `bool(size_t vaddr, size_t

memsz)` to cover all the writable segment data described by PT_LOAD

segments, excluding the RELRO region. Returns false as soon as the first

callback returns false, or else returns true.

Defined at line 621 of file ../../src/lib/elfldltl/include/lib/elfldltl/internal/../phdr.h
```
template <class Phdr, typename T>
```
```
bool OnPhdrWritableSegments (std::span<const Phdr> phdrs, T && callback)
```
Given a set of phdrs, call the callback as `bool(size_t vaddr, size_t

memsz)` to cover all the writable segment data described by PT_LOAD

segments, excluding the RELRO region. Returns false as soon as the first

callback returns false, or else returns true.

Defined at line 621 of file ../../src/lib/elfldltl/include/lib/elfldltl/internal/../phdr.h
```
template <class Phdr, typename T>
```
```
bool OnPhdrWritableSegments (std::span<const Phdr> phdrs, T && callback)
```
Given a set of phdrs, call the callback as `bool(size_t vaddr, size_t

memsz)` to cover all the writable segment data described by PT_LOAD

segments, excluding the RELRO region. Returns false as soon as the first

callback returns false, or else returns true.

Defined at line 621 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <class Phdr, typename T>
```
```
bool OnPhdrWritableSegments (std::span<const Phdr> phdrs, T && callback)
```
Given a set of phdrs, call the callback as `bool(size_t vaddr, size_t

memsz)` to cover all the writable segment data described by PT_LOAD

segments, excluding the RELRO region. Returns false as soon as the first

callback returns false, or else returns true.

Defined at line 621 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h
```
template <class Phdrtypename T>
```
```
bool OnPhdrWritableSegments (std::span<const Phdr> phdrsT && callback)
```
Given a set of phdrs, call the callback as `bool(size_t vaddr, size_t

memsz)` to cover all the writable segment data described by PT_LOAD

segments, excluding the RELRO region. Returns false as soon as the first

callback returns false, or else returns true.

Defined at line 621 of file ../../src/lib/elfldltl/include/lib/elfldltl/phdr.h

Concepts

template <class File, class Elf, typename PhdrAllocator> FileApiForLoad CanReadFromFile<File, typename Elf::Ehdr> && CanReadArrayFromFile<File, typename Elf::Phdr, PhdrAllocator, uint32_t>

Like elfldltl::FileApi but for Ehdr and Phdr as required by functions in

this file, and with only a concrete Phdr allocator rather than a template

for allocators of various types.

Defined at line 26 of file ../../src/lib/elfldltl/include/lib/elfldltl/load.h

template <class T, class Diagnostics, class Handle, auto MakeInvalidHandle = &DefaultMakeInvalidHandle<Handle>> FileWithDiagnosticsApi std::move_constructible<T> && std::move_constructible<Handle> && std::default_initializable<Handle> && requires (Handle &&handle, Diagnostics &diag) { { MakeInvalidHandle() } -> std::convertible_to<Handle>; { T{std::forward<Handle>(handle), diag} }; { T{diag} }; }

Classes derived from elfldltl::File instantiations should meet the

elfldltl::FileWithDiagnosticsApi concept. The constructor should take two

arguments with deducible types. Each of the two template parameters to the

concept can either be a class template parameter to the implementation or

just a function template parameter to its two-argument constructor.

Defined at line 32 of file ../../src/lib/elfldltl/include/lib/elfldltl/file.h

template <typename T> SymbolNameArray std::tuple_size<std::decay_t<T> >{} > 0 && std::same_as<T, const std::array<SymbolName, std::tuple_size<std::decay_t<T> >{}> &>

This requires that a type be a const reference to std::array

<SymbolName

, N>

as returned by elfldltl::PerfectSymbolTable.

Defined at line 42 of file ../../src/lib/elfldltl/include/lib/elfldltl/perfect-symbol-table.h

template <typename StorageType, typename T, typename size_type> AbiPtrTraitsStorageType std::same_as<StorageType, T *> || requires (StorageType storage, size_type unsigned_integer, std::make_signed_t<size_type> signed_integer) { { storage + unsigned_integer } -> std::convertible_to<StorageType>; { storage + signed_integer } -> std::convertible_to<StorageType>; { storage - unsigned_integer } -> std::convertible_to<StorageType>; { storage - signed_integer } -> std::convertible_to<StorageType>; { storage - storage } -> std::integral; }

This concept is used as part of the AbiTraitsApi concept.

Defined at line 47 of file ../../src/lib/elfldltl/include/lib/elfldltl/abi-ptr.h

template <class T, class LoadInfo> GetMutableMemoryApiResult std::same_as<T, fit::result<_Bool, typename T::value_type> > && MemoryWriter<typename T::value_type, typename LoadInfo::Elf::size_type, typename LoadInfo::Elf::Addr> && (std::copy_constructible<typename T::value_type> || (!std::is_const_v<typename LoadInfo::Segment> && std::move_constructible<typename T::value_type>))

elfldltl::LoadInfoMutableMemory is an adapter providing mutation methods of

the Memory API (see Store and StoreAdd

<lib

/elfldltl/memory.h>) representing

a module image described by elfldltl::LoadInfo (see

<lib

/elfldltl/load.h>).

This Memory API object can be used to apply relocations via the interfaces

<lib

/elfldltl/link.h>.

The constructor requires Diagnostics and LoadInfo objects by reference, and

some callable object by value. The callable object is used as

`fit::result

<bool

, T>(Diagnostics

,LoadInfo::Segment

)`. In the error case,

the `bool` value is as would be returned by `Diagnostics::FormatError`. In

the success case, the T is any movable object that provides the mutation

methods of the Memory API. This Memory object represents just the segment

and should accept addresses from `segment.vaddr()` for `segment.filesz()`

bytes, but need not accept any other addresses. Each segment's object is

only requested once and then is used for the lifetime of the adapter.

The callback takes the `LoadInfo::Segment` object by mutable reference so it

can update it to store mutation state when using a segment wrapper subclass.

That state stored in the LoadInfo segments can be used to map the mutated

data into a process later.

The final optional template parameter provides a container template to be

used for the internal storage. To specify that, the Diagnostics, LoadInfo,

and GetMutableMemory callable types must be specified explicitly too. With

the default container (std::vector) a deduction guide allows construction

with no template parameters.

Defined at line 48 of file ../../src/lib/elfldltl/include/lib/elfldltl/loadinfo-mutable-memory.h

template <class Memory, typename Size, typename T> MemoryReaderForType std::integral<Size> && requires (Memory &memory, Size address, Size count, T value) { { memory.template ReadArray<T>(address, count) } -> std::same_as<std::optional<std::span<const T> >>; { memory.template ReadArray<T>(address) } -> std::same_as<std::optional<std::span<const T> >>; }

Various interfaces require a File or Memory type to access data structures.

This header specifies the API contracts those template interfaces require,

and provides an implementation for the simplest case.

Both File and Memory types are not copied or moved, only used by reference.

Each interface uses either the File API or the Memory API, but both APIs

can be implemented by a single object when appropriate.

The primary distinction between File and Memory is that methods for reading

from File handle ownership since copying data into a local buffer may be

required: the lifetime of the data read is tied to an owned object returned

by the call (though it should be presumed that those objects are also only

valid for the lifetime of the File object itself). The Methods for reading

from Memory instead simply return pointers (really references or spans) into

mapped memory whose lifetime is that of the Memory object itself.

The Memory API also has a write aspect, whereas File does only reading. The

Memory API is really the union of MemoryReader and MemoryWriter APIs.

The methods on these objects all require an explicit template parameter for

the datum type to be accessed in the File or Memory object. This means

there can't be a single C++20 concept for File or for Memory generically.

Instead, each concept is parameterized for a particular list of types that

its methods must work with.

Defined at line 48 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <typename T, class Diagnostics, class LoadInfo> GetMutableMemoryApi std::invocable<T, Diagnostics &, typename LoadInfo::Segment &> && GetMutableMemoryApiResult<std::invoke_result_t<T, Diagnostics &, typename LoadInfo::Segment &>, LoadInfo>

Defined at line 57 of file ../../src/lib/elfldltl/include/lib/elfldltl/loadinfo-mutable-memory.h

template <class Traits, typename T, class Elf> AbiPtrTraitsApi requires (typename Elf::Addr addr, typename Traits::template StorageType<Elf, T> storage) { typename Traits::template StorageType<Elf, T>; { typename Traits::template StorageType<Elf, T>{} } -> AbiPtrTraitsStorageType<T, typename Elf::size_type>; { Traits::GetAddress(storage) } -> std::unsigned_integral; { Traits::ComparisonValue(storage) } -> std::totally_ordered; { Traits::template FromAddress<Elf, T>(addr) } -> std::convertible_to<decltype(storage)>; }

Any Traits type used with AbiPtr must meet the AbiTraitsApi requirements.

Defined at line 59 of file ../../src/lib/elfldltl/include/lib/elfldltl/abi-ptr.h

template <class Memory, typename Size, typename... Ts> MemoryReader (MemoryReaderForType<Memory, Size, Ts> && ...)

A general-purpose MemoryReader should work for all T, but templates taking a

Memory object will constrain it to the types they actually use.

Defined at line 80 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class Memory, typename Size, typename T> MemoryWriterForType std::integral<Size> && requires (Memory &memory, Size address, T value) { { memory.template Store<T>(address, value) } -> std::convertible_to<_Bool>; { memory.template StoreAdd<T>(address, value) } -> std::convertible_to<_Bool>; }

Defined at line 83 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class Traits, typename T, class Elf> AbiPtrLocalTraitsApi AbiPtrTraitsApi<Traits, T, Elf> && requires (T *ptr, typename Traits::template StorageType<Elf, T> storage) { { Traits::template Make<Elf, T>(ptr) } -> std::convertible_to<typename Traits::template StorageType<Elf, T>>; { Traits::template Get<Elf, T>(storage) } -> std::convertible_to<T *>; }

If an AbiTraits class offers the Make and Get methods to convert directly to

a local pointer, it qualifies as a LocalAbiTraitsApi class. In this case,

AbiPtr will support all the smart-pointer methods and operators and be

convertible to and from normal pointers (T*).

Defined at line 105 of file ../../src/lib/elfldltl/include/lib/elfldltl/abi-ptr.h

template <class Memory, typename Size, typename... Ts> MemoryWriter (MemoryWriterForType<Memory, Size, Ts> && ...)

A general-purpose MemoryWriter should work for all T, but templates taking a

Memory object will constrain it to the types they actually use.

Defined at line 114 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class Memory, typename Size, typename... Ts> MemoryApi MemoryReader<Memory, Size, Ts...> && MemoryWriter<Memory, Size, Ts...>

A fully-general Memory object does all of them.

Defined at line 118 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class Result, typename T> OwnedResult std::same_as<Result, T> || std::convertible_to<const T &, Result>

Successfully reading a single datum of type T yields a value of an

OwnedResult

>. Basically, this means it can be used as if it's a T: either

it's a T or it's equivalent to a const T

that's valid for the lifetime of

the File object.

Defined at line 142 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class OptionalResult, typename T> OptionalOwnedResult OwnedResult<OptionalOf<OptionalResult>, T>

OptionalOwnedResult

> is std::optional of some OwnedResult

> type.

Defined at line 146 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class File, typename T, typename Size = size_t> CanReadFromFile requires (File &file, Size offset, Size count) { { file.template ReadFromFile<T>(offset) } -> OptionalOwnedResult<T>; }

The ReadFromFile

> reads a single datum of fixed size. If this aspect of

the File API is used alone then on allocation is required. However, the

return value is nonetheless an owning object that (presumably) must be kept

alive as long it's used as const T

. It also must be presumed valid only

during the lifetime of the File object itself. Or it might just be T--but

if not then it may need to be copied to an explicitly typed T to be used

longer than the File object itself.

Defined at line 156 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <typename T> SymbolHashBucketApi std::ranges::forward_range<T> && std::same_as<uint32_t, std::ranges::range_value_t<T> >

The elfldltl::GnuHash (

<lib

/elfldltl/gnu-hash.h>) and elfldltl::CompatHash

(

<lib

/elfldltl/compat-hash.h>) classes are used by elfldltl::SymbolInfo,

below. They both conform to the same template API. A hash table yields a

std::forward_range of hash buckets for enumeration: each bucket holds a set

of symbols with equivalent hash values. Each hash bucket is itself a

std::forward_range of uint32_t indices into the symbol table.

Defined at line 166 of file ../../src/lib/elfldltl/include/lib/elfldltl/symbol.h

template <typename Result, typename T> OwnedResultArray std::convertible_to<Result, std::span<const T> >

OwnedResultArray

> is an object that owns some memory resource but that can

be converted to std::span

<const

T>.

Defined at line 171 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <typename T> SymbolHashAllBucketsApi std::ranges::forward_range<T> && SymbolHashBucketApi<std::ranges::range_value_t<T> >

Defined at line 171 of file ../../src/lib/elfldltl/include/lib/elfldltl/symbol.h

template <class OptionalResult, typename T> OptionalOwnedResultArray OwnedResultArray<OptionalOf<OptionalResult>, T>

OptionalOwnedResultArray

> is std::optional of an OwnedResultArray

> type.

Defined at line 175 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <typename T, typename RawElement> SymbolHashTableApi std::constructible_from<std::span<const RawElement> > && requires (const T &table) { { T::Valid(std::span<const RawElement>{}) } -> std::same_as<_Bool>; { table.symtab_size() } -> std::same_as<uint32_t>; { table.Bucket(uint32_t{}) } -> SymbolHashBucketApi; { table.AllBuckets() } -> SymbolHashAllBucketsApi; }

Defined at line 176 of file ../../src/lib/elfldltl/include/lib/elfldltl/symbol.h

template <class Allocator, typename T, typename Size = size_t> ReadArrayFromFileAllocator std::integral<Size> && requires (Allocator &&allocator, Size count) { { allocator(count) } -> OptionalOwnedResultArray<T>; }

The allocator passed to ReadArrayFromFile

> methods must be a callable

object that returns std::optional of an OwnedResultArray

> type.

Defined at line 180 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class File, typename T, typename Allocator, typename Size = size_t> CanReadArrayFromFile ReadArrayFromFileAllocator<Allocator, T, Size> && requires (File &file, Size offset, Allocator &&allocator, Size count) { { file.template ReadArrayFromFile<T>(offset, allocator, count) } -> OptionalOwnedResultArray<T>; }

The other method required in the File API uses an allocator object.

Defined at line 187 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <typename T, class Sym> SymbolFilterApi std::invocable<T, const Sym &> && std::same_as<_Bool, std::invoke_result_t<T, const Sym &> >

A few SymbolInfo methods take a bool(const Sym

) callable.

Defined at line 201 of file ../../src/lib/elfldltl/include/lib/elfldltl/symbol.h

template <class File, template <typename> class Allocator, typename... Ts> FileApiFor ((CanReadFromFile<File, Ts> && CanReadArrayFromFile<File, Ts, Allocator<Ts> >) && ...)

The full File API requires both methods. A general-purpose File should work

for all T, but templates taking a File object will constrain it to the types

they actually use. Multiple ReadArrayFromFile

> for different datum types

T calls can't use the same allocator, but users of the File API will often

often use a single template class to supply the allocator objects for all

their calls, so the File object can be validated for calls made with

allocator objects instantiated using the given Allocator template.

Defined at line 203 of file ../../src/lib/elfldltl/include/lib/elfldltl/memory.h

template <class Traitsclass Elf = Elf<>> TlsTraitsApi requires { typename Traits::GotAddr; { std::integral_constant<typename Elf::size_type, Traits::kTlsLocalExecOffset>{} }; { std::bool_constant<Traits::kTlsNegative>{} }; { std::bool_constant<Traits::kTpSelfPointer>{} }; { std::integral_constant<typename Elf::size_type, Traits::kTlsRelativeBias>{} }; }

This defines the API for each TlsTraitsImpl

<Elf

, Machine> class, given Elf.

_Note:_ An expression like `std::integral_constant

, Traits::K>{}`

indicates the requirement for a public member `static constexpr T K = ...;`.

Defined at line 261 of file ../../src/lib/elfldltl/include/lib/elfldltl/machine.h