class DecodedModule

Derived types might or might not be default-constructed.

Derived types might or might not be copyable and/or movable, depending on

the SegmentContainer and SegmentWrapper semantics.

When a module has been actually decoded at all, this returns true.

In default-constructed state, module() cannot be called. Once

HasModule() is true, then module() can be inspected and its

contains will be safe, but may be incomplete if decoding hit errors

but the Diagnostics object said to keep going.

This should be used only after EmplaceModule or (successful) NewModule.

**NOTE:** Most methods below use module() and cannot be called unless

HasModule() returns true, i.e. after EmplaceModule / NewModule.

This is the DT_SONAME in the file or empty if there was none (or if

decoding was incomplete). This often matches the name by which the

module is known, but need not. There may be no SONAME at all (normal for

an executable or loadable module rather than a shared library), or the

embedded SONAME is not the same as the lookup name (file name, usually)

used to get the file.

See

<lib

/elfldtl/load.h> for details; the LoadInfo provides information

on address layout. This is used to map file segments into memory and/or

to convert memory addresses to file offsets. The SegmentWrapper template

class may extend the load_info().segments() element types with holders of

segment data mapped or copied from the file (and maybe further prepared).

See

<lib

/elfldtl/relocation.h> for details; the RelocationInfo provides

information need by the

<lib

/elfldtl/link.h> layer to drive dynamic

linking of this module. It doesn't need to be stored at all if a module

is being cached after relocation without concern for a separate dynamic

linking session reusing the same data.

This fills out module() and (if present) reloc_info() from the PT_DYNAMIC

data read via the Memory object. Additional observers can be passed as

for ld::DecodeModuleDynamic, and the return value is the same as that.

This fills out module() and (if present) reloc_info() from the PT_DYNAMIC

data read via the Memory object. Additional observers can be passed as

for ld::DecodeModuleDynamic, and the return value is the same as that.

Set up the Abi

<

>::TlsModule in tls_module() based on the PT_TLS segment.

The modid must be nonzero, but its only actual use is in the module() and

tls_module_id() values returned by this object. In a derived object only

used as a pure cache of the ELF file's metadata, constant 1 is fine.

This returns the TLS module ID assigned by SetTls, or zero if none is

set. In a derived type representing a pure cache of the ELF file's

metadata, this is just a flag where nonzero indicates it has a PT_TLS.

In a derived type for a module in a specific dynamic linking session,

this is the ABI's meaning of TLS module ID at runtime. In either case,

it's always nonzero if the module has a PT_TLS and zero if it doesn't.

This should only be called after SetTls.

A derived class should wrap EmplaceModule and NewModule with calls to

SetAbiName passing the derived class's notion of primary name for the

module, so that the AbiModule representation always matches that name.

In an instantiation with InlineModule=kYes, EmplaceModule(..) just

constructs Module{...}). The modid is always required, though it need

not be meaningful. In a derived type representing a pure cache of the

ELF file's metadta, it could be zero in every module. In a derived type

representing a module in a specific dynamic linking scenario, it's useful

to assign the ld::abi::Abi::Module::symbolizer_modid value early and rely

on it corresponding to the module's order in the linking session's

"load-order" list of modules; this allows the index to serve as a means

of back-pointer from the module() object to a containing LoadModule sort

of object via reference to the session's primary module list.

In an instantiation with InlineModule=false, NewModule(a..., c...) does

new (a...) Module{c...}. See above about the modid argument. The last

argument in a... must be a fbl::AllocChecker that indicates whether `new`

succeeded.

This returns an observer that can be passed to DecodeDynamic to collect

DT_NEEDED entries into a container of size_type. (Container can be

anything that meets the

<lib

/elfldltl/container.h> template API with a

value_type of size_type.) This records just the offsets and so can be

used in the initial DecodeDynamic that also discovers DT_STRTAB et al.

The offsets can later be converted using ReifyNeeded (see below).

This turns a DT_NEEDED offset (as collected via MakeNeededObserver) into

its string from the DT_STRTAB, normalized as a Soname object. It returns

failure for an invalid string table entry. The error value is the "keep

going" result from the Diagnostics object.

This overload applies ReifyNeeded to each offset in a container of

size_type and returns a new container of Soname. It's invoked e.g.

```

std::optional needed_names =

ReifyNeeded

<elfldltl

::StdContainer

<std

::vector>::Container>(

diag, needed_offsets);

```

A return of std::nullopt means the Diagnostics object returned false after

a bad entry was diagnosed, or there was an allocation failure. If the

Diagnostics object returned true for a bad entry, that entry is just

omitted from the container it's success even with an empty container.