loadelf

Imports

Imports #

"bytes"
"cmd/internal/bio"
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/loader"
"cmd/link/internal/sym"
"debug/elf"
"encoding/binary"
"fmt"
"io"
"log"
"strings"

Constants & Variables

SHT_ARM_ATTRIBUTES const #

const SHT_ARM_ATTRIBUTES = 0x70000003

TagABIVFPArgs const #

const TagABIVFPArgs = 28

TagAlsoCompatibleWith const #

const TagAlsoCompatibleWith = 65

TagCPUName const #

const TagCPUName = 4

TagCPURawName const #

const TagCPURawName = 5

TagCompatibility const #

const TagCompatibility = 32

TagFile const #

const TagFile = 1

TagNoDefaults const #

const TagNoDefaults = 64

Structs

ElfObj struct #

type ElfObj struct {
f *bio.Reader
base int64
length int64
is64 int
name string
e binary.ByteOrder
sect []ElfSect
nsect uint
nsymtab int
symtab *ElfSect
symstr *ElfSect
type_ uint32
machine uint32
version uint32
entry uint64
phoff uint64
shoff uint64
flags uint32
ehsize uint32
phentsize uint32
phnum uint32
shentsize uint32
shnum uint32
shstrndx uint32
}

ElfSect struct #

type ElfSect struct {
name string
nameoff uint32
type_ elf.SectionType
flags elf.SectionFlag
addr uint64
off uint64
size uint64
link uint32
info uint32
align uint64
entsize uint64
base []byte
readOnlyMem bool
sym loader.Sym
}

ElfSym struct #

type ElfSym struct {
name string
value uint64
size uint64
bind elf.SymBind
type_ elf.SymType
other uint8
shndx elf.SectionIndex
sym loader.Sym
}

elfAttribute struct #

type elfAttribute struct {
tag uint64
sval string
ival uint64
}

elfAttributeList struct #

type elfAttributeList struct {
data []byte
err error
}

Functions

Load function #

Load loads the ELF file pn from f. Symbols are installed into the loader, and a slice of the text symbols is returned. On ARM systems, Load will attempt to determine what ELF header flags to emit by scanning the attributes in the ELF file being loaded. The parameter initEhdrFlags contains the current header flags for the output object, and the returned ehdrFlags contains what this Load function computes. TODO: find a better place for this logic.

func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader, pkg string, length int64, pn string, initEhdrFlags uint32) (textp []loader.Sym, ehdrFlags uint32, err error)

armAttr method #

Read an elfAttribute from the list following the rules used on ARM systems.

func (a *elfAttributeList) armAttr() elfAttribute

cstring function #

func cstring(x []byte) string

done method #

func (a *elfAttributeList) done() bool

elfmap function #

func elfmap(elfobj *ElfObj, sect *ElfSect) (err error)

parseArmAttributes function #

Look for the attribute that indicates the object uses the hard-float ABI (a file-level attribute with tag Tag_VFP_arch and value 1). Unfortunately the format used means that we have to parse all of the file-level attributes to find the one we are looking for. This format is slightly documented in "ELF for the ARM Architecture" but mostly this is derived from reading the source to gold and readelf.

func parseArmAttributes(e binary.ByteOrder, data []byte) (found bool, ehdrFlags uint32, err error)

readelfsym function #

func readelfsym(l *loader.Loader, arch *sys.Arch, elfobj *ElfObj, i int, elfsym *ElfSym, needSym int, localSymVersion int) (err error)

relSize function #

Return the size of the relocated field, and the size of the addend as the first and second values. Note, the addend may be larger than the relocation field in some cases when a relocated value is split across multiple relocations.

func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, uint8, error)

section function #

func section(elfobj *ElfObj, name string) *ElfSect

string method #

func (a *elfAttributeList) string() string

uleb128 method #

func (a *elfAttributeList) uleb128() uint64

Generated with Arrow