obj

type AsDebugDwarf interface {
	File
	AsDebugDwarf() (*dwarf.Data, error)
}

type AsDebugElf interface {
	File
	AsDebugElf() *elf.File
}

type Data struct {
	// Addr is the address at which this data starts.
	//
	// If this Data is for a Section or a Sym, this is the base address
	// of the section or symbol.
	Addr uint64

	// B stores the raw byte data. Callers must not modify this.
	B []byte

	// R stores the relocations applied to this Data in increasing
	// address order.
	//
	// This may include relocations outside or partially outside of this
	// Data's address range.
	R []Reloc

	// Layout specifies the byte order and word size of this data. This
	// is inferred from the object file's architecture, and hence may
	// not be correct for sections or symbols that have a fixed byte
	// order regardless of the host order.
	Layout arch.Layout
}

type ErrNoData struct {
	Detail string
}

type File interface {
	// Close closes this object file, releasing any OS resources used by it.
	//
	// It's possible that referencing a Data object returned from this File
	// after closing the File will panic.
	Close()

	// Info returns metadata about the whole object file.
	Info() FileInfo

	// Sections returns a slice of sections in this object file, indexed
	// by SectionID.
	//
	// All data in the object file (code, program data, etc) is stored
	// in sections. Often many metadata tables (e.g., symbol tables) are
	// as well.
	//
	// Each section has a name that generally follows a platform
	// convention, such as ".text" or ".data".
	//
	// All addresses within an object file, such as symbol addresses,
	// relocation targets, etc. are relative to some section of the
	// object file. Each section may or may not have a fixed base
	// address and sections may overlap. For example, in an executable
	// image, all of the mapped sections will have base addresses and
	// will not overlap, but there may be additional information in
	// non-mapped sections such as debugging info. In an unlinked
	// object file, typically none of the sections have base addresses.
	// And in a position-independent executable, sections may have base
	// addresses, but may be relocated to another address.
	Sections() []*Section

	// Section returns the i'th section. If i is out of range, it panics.
	Section(i SectionID) *Section

	// ResolveAddr finds the Section containing the given address in the
	// mapped address space. It returns nil if addr is not in a mapped
	// section. Not all sections are mapped, and some types of object
	// files don't have any mapped address space at all (for example,
	// ELF relocatable objects).
	//
	// TODO: Reconsider this API. Eventually it would be nice to be able
	// to handle addresses from relocated PIE images and core files. Do
	// those just implement the File interface and present the
	// underlying file relocated to the target addresses given by the
	// PIE loading/core file?
	//
	// TODO: Does this need to be a method on File at all or can it be a
	// global function?
	ResolveAddr(addr uint64) *Section

	// Sym returns i'th symbol. If i is our of range, it panics.
	Sym(i SymID) Sym

	// NumSyms returns the number of symbols.
	//
	// If an object file has more than one symbol table, they will be
	// concatenated. As a result, the "same" symbol may appear multiple times.
	NumSyms() SymID
	// contains filtered or unexported methods
}

type FileInfo struct {
	// Arch is the machine architecture of this object file, or
	// nil if unknown.
	Arch *arch.Arch
}

type Reader struct {
	// contains filtered or unexported fields
}

type Reloc struct {
	// Addr is the address where this Reloc is applied.
	//
	// This is an absolute address within some section. Hence, to compute the
	// offset of the Reloc within a Section, use Addr - Section.Addr, and to
	// compute the byte offset of the Reloc within a Data, use Addr - Data.Addr.
	Addr uint64
	// Type is the relocation type. This determines how to calculate the value
	// that would be stored at Offset.
	Type RelocType
	// Symbol is the target of this Reloc, or NoSym if Type does not have a
	// symbol as an input.
	Symbol SymID
	// Addend is the addend input to Type, if any.
	//
	// If the file format uses addends smaller than 64-bits, they will be sign
	// extended.
	//
	// Objects formats store addends either explicitly in the relocations table
	// or implicitly at the target of the relocation. The obj package hides this
	// difference and populate Addend in either case.
	Addend int64
}

type RelocType struct {
	// contains filtered or unexported fields
}

type Section struct {
	// File is the object file containing this section.
	File File

	// Name is the name of this section. This typically follows platform
	// conventions, such as ".text" or ".data", but isn't necessarily
	// meaningful.
	Name string

	// ID is the obj-internal index of this section.
	ID SectionID

	// RawID is the index of this section in the underlying format's
	// representation, or -1 if this is not meaningful.
	RawID int

	// Addr is the virtual address at which this section begins in
	// memory, or 0 if either this section should not be loaded into
	// memory, or it has not yet been assigned a meaningful address.
	Addr uint64

	// Size is the size of this section in memory, in bytes.
	//
	// This may not be the size of the section on disk. For example, a
	// section that is all zeros may not be represented on disk at all,
	// or the section on disk may be compressed.
	Size uint64

	// SectionFlags stores flags for this section. This field is
	// embedded so Section inherits the methods of SectionFlags.
	SectionFlags
}

type SectionFlags struct {
	// contains filtered or unexported fields
}

type SectionID int

type Sym struct {
	// Name is the string name of this symbol.
	Name string
	// Section is the section this symbol is defined in, or nil if this symbol
	// is not defined in any section. A symbol has data if and only if Section
	// is non-nil.
	Section *Section
	// Value is the value of this symbol. The interpretation of this differs
	// between different kinds of symbols. If this is a data symbol (Section is
	// non-nil), this is an absolute address within Section.
	Value uint64
	// Size is the size of this symbol in bytes, if it is a data symbol, or 0 if
	// unknown.
	Size uint64
	// Kind gives the general kind of this symbol.
	Kind SymKind
	// SymFlags stores flags for this symbol. This field is embedded so Sym
	// inherits the methods of SymFlags.
	SymFlags
}

type SymFlags struct {
	// contains filtered or unexported fields
}

type SymID uint32

type SymKind uint8