const (
SARMAG = 8
SAR_HDR = 16 + 44
)
https://sourceware.org/gdb/onlinedocs/gdb/dotdebug_005fgdb_005fscripts-section.html Each entry inside .debug_gdb_scripts section begins with a non-null prefix byte that specifies the kind of entry. The following entries are supported:
const (
GdbScriptPythonFileId = 1
GdbScriptSchemeFileId = 3
GdbScriptPythonTextId = 4
GdbScriptSchemeTextId = 6
)
* Generate a sequence of opcodes that is as short as possible. * See section 6.2.5
const (
LINE_BASE = -4
LINE_RANGE = 10
PC_RANGE = (255 - OPCODE_BASE) / LINE_RANGE
OPCODE_BASE = 11
)
* Go linker interface
const (
ELF64HDRSIZE = 64
ELF64PHDRSIZE = 56
ELF64SHDRSIZE = 64
ELF64RELSIZE = 16
ELF64RELASIZE = 24
ELF64SYMSIZE = 24
ELF32HDRSIZE = 52
ELF32PHDRSIZE = 32
ELF32SHDRSIZE = 40
ELF32SYMSIZE = 16
ELF32RELSIZE = 8
)
member of .gnu.attributes of MIPS for fpAbi
const (
// No floating point is present in the module (default)
MIPS_FPABI_NONE = 0
// FP code in the module uses the FP32 ABI for a 32-bit ABI
MIPS_FPABI_ANY = 1
// FP code in the module only uses single precision ABI
MIPS_FPABI_SINGLE = 2
// FP code in the module uses soft-float ABI
MIPS_FPABI_SOFT = 3
// FP code in the module assumes an FPU with FR=1 and has 12
// callee-saved doubles. Historic, no longer supported.
MIPS_FPABI_HIST = 4
// FP code in the module uses the FPXX ABI
MIPS_FPABI_FPXX = 5
// FP code in the module uses the FP64 ABI
MIPS_FPABI_FP64 = 6
// FP code in the module uses the FP64A ABI
MIPS_FPABI_FP64A = 7
)
NetBSD Signature (as per sys/exec_elf.h)
const (
ELF_NOTE_NETBSD_NAMESZ = 7
ELF_NOTE_NETBSD_DESCSZ = 4
ELF_NOTE_NETBSD_TAG = 1
ELF_NOTE_NETBSD_VERSION = 700000000 /* NetBSD 7.0 */
)
OpenBSD Signature
const (
ELF_NOTE_OPENBSD_NAMESZ = 8
ELF_NOTE_OPENBSD_DESCSZ = 4
ELF_NOTE_OPENBSD_TAG = 1
ELF_NOTE_OPENBSD_VERSION = 0
)
FreeBSD Signature (as per sys/elf_common.h)
const (
ELF_NOTE_FREEBSD_NAMESZ = 8
ELF_NOTE_FREEBSD_DESCSZ = 4
ELF_NOTE_FREEBSD_ABI_TAG = 1
ELF_NOTE_FREEBSD_NOINIT_TAG = 2
ELF_NOTE_FREEBSD_FEATURE_CTL_TAG = 4
ELF_NOTE_FREEBSD_VERSION = 1203000 // 12.3-RELEASE
ELF_NOTE_FREEBSD_FCTL_ASLR_DISABLE = 0x1
)
Build info note
const (
ELF_NOTE_BUILDINFO_NAMESZ = 4
ELF_NOTE_BUILDINFO_TAG = 3
)
Go specific notes
const (
ELF_NOTE_GOPKGLIST_TAG = 1
ELF_NOTE_GOABIHASH_TAG = 2
ELF_NOTE_GODEPS_TAG = 3
ELF_NOTE_GOBUILDID_TAG = 4
)
const (
MACHO_CPU_AMD64 = 1<<24 | 7
MACHO_CPU_386 = 7
MACHO_SUBCPU_X86 = 3
MACHO_CPU_ARM = 12
MACHO_SUBCPU_ARM = 0
MACHO_SUBCPU_ARMV7 = 9
MACHO_CPU_ARM64 = 1<<24 | 12
MACHO_SUBCPU_ARM64_ALL = 0
MACHO_SUBCPU_ARM64_V8 = 1
MACHO_SUBCPU_ARM64E = 2
MACHO32SYMSIZE = 12
MACHO64SYMSIZE = 16
MACHO_X86_64_RELOC_UNSIGNED = 0
MACHO_X86_64_RELOC_SIGNED = 1
MACHO_X86_64_RELOC_BRANCH = 2
MACHO_X86_64_RELOC_GOT_LOAD = 3
MACHO_X86_64_RELOC_GOT = 4
MACHO_X86_64_RELOC_SUBTRACTOR = 5
MACHO_X86_64_RELOC_SIGNED_1 = 6
MACHO_X86_64_RELOC_SIGNED_2 = 7
MACHO_X86_64_RELOC_SIGNED_4 = 8
MACHO_ARM_RELOC_VANILLA = 0
MACHO_ARM_RELOC_PAIR = 1
MACHO_ARM_RELOC_SECTDIFF = 2
MACHO_ARM_RELOC_BR24 = 5
MACHO_ARM64_RELOC_UNSIGNED = 0
MACHO_ARM64_RELOC_BRANCH26 = 2
MACHO_ARM64_RELOC_PAGE21 = 3
MACHO_ARM64_RELOC_PAGEOFF12 = 4
MACHO_ARM64_RELOC_GOT_LOAD_PAGE21 = 5
MACHO_ARM64_RELOC_GOT_LOAD_PAGEOFF12 = 6
MACHO_ARM64_RELOC_ADDEND = 10
MACHO_GENERIC_RELOC_VANILLA = 0
MACHO_FAKE_GOTPCREL = 100
)
const (
MH_MAGIC = 0xfeedface
MH_MAGIC_64 = 0xfeedfacf
MH_OBJECT = 0x1
MH_EXECUTE = 0x2
MH_NOUNDEFS = 0x1
MH_DYLDLINK = 0x4
MH_PIE = 0x200000
)
const (
S_REGULAR = 0x0
S_ZEROFILL = 0x1
S_NON_LAZY_SYMBOL_POINTERS = 0x6
S_SYMBOL_STUBS = 0x8
S_MOD_INIT_FUNC_POINTERS = 0x9
S_ATTR_PURE_INSTRUCTIONS = 0x80000000
S_ATTR_DEBUG = 0x02000000
S_ATTR_SOME_INSTRUCTIONS = 0x00000400
)
rebase table opcode
const (
REBASE_TYPE_POINTER = 1
REBASE_TYPE_TEXT_ABSOLUTE32 = 2
REBASE_TYPE_TEXT_PCREL32 = 3
REBASE_OPCODE_MASK = 0xF0
REBASE_IMMEDIATE_MASK = 0x0F
REBASE_OPCODE_DONE = 0x00
REBASE_OPCODE_SET_TYPE_IMM = 0x10
REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x20
REBASE_OPCODE_ADD_ADDR_ULEB = 0x30
REBASE_OPCODE_ADD_ADDR_IMM_SCALED = 0x40
REBASE_OPCODE_DO_REBASE_IMM_TIMES = 0x50
REBASE_OPCODE_DO_REBASE_ULEB_TIMES = 0x60
REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB = 0x70
REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80
)
bind table opcode
const (
BIND_TYPE_POINTER = 1
BIND_TYPE_TEXT_ABSOLUTE32 = 2
BIND_TYPE_TEXT_PCREL32 = 3
BIND_SPECIAL_DYLIB_SELF = 0
BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE = -1
BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2
BIND_SPECIAL_DYLIB_WEAK_LOOKUP = -3
BIND_OPCODE_MASK = 0xF0
BIND_IMMEDIATE_MASK = 0x0F
BIND_OPCODE_DONE = 0x00
BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10
BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20
BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30
BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40
BIND_OPCODE_SET_TYPE_IMM = 0x50
BIND_OPCODE_SET_ADDEND_SLEB = 0x60
BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70
BIND_OPCODE_ADD_ADDR_ULEB = 0x80
BIND_OPCODE_DO_BIND = 0x90
BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 0xA0
BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 0xB0
BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0
BIND_OPCODE_THREADED = 0xD0
BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0x00
BIND_SUBOPCODE_THREADED_APPLY = 0x01
)
const (
SymKindLocal = 0 + iota
SymKindExtdef
SymKindUndef
NumSymKind
)
const (
SUBBUCKETS = 16
SUBBUCKETSIZE = abi.FuncTabBucketSize / SUBBUCKETS
NOIDX = 0x7fffffff
)
const (
IMAGE_SCN_CNT_CODE = 0x00000020
IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040
IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080
IMAGE_SCN_LNK_OTHER = 0x00000100
IMAGE_SCN_LNK_INFO = 0x00000200
IMAGE_SCN_LNK_REMOVE = 0x00000800
IMAGE_SCN_LNK_COMDAT = 0x00001000
IMAGE_SCN_GPREL = 0x00008000
IMAGE_SCN_MEM_PURGEABLE = 0x00020000
IMAGE_SCN_MEM_16BIT = 0x00020000
IMAGE_SCN_MEM_LOCKED = 0x00040000
IMAGE_SCN_MEM_PRELOAD = 0x00080000
IMAGE_SCN_ALIGN_1BYTES = 0x00100000
IMAGE_SCN_ALIGN_2BYTES = 0x00200000
IMAGE_SCN_ALIGN_4BYTES = 0x00300000
IMAGE_SCN_ALIGN_8BYTES = 0x00400000
IMAGE_SCN_ALIGN_16BYTES = 0x00500000
IMAGE_SCN_ALIGN_32BYTES = 0x00600000
IMAGE_SCN_ALIGN_64BYTES = 0x00700000
IMAGE_SCN_ALIGN_128BYTES = 0x00800000
IMAGE_SCN_ALIGN_256BYTES = 0x00900000
IMAGE_SCN_ALIGN_512BYTES = 0x00A00000
IMAGE_SCN_ALIGN_1024BYTES = 0x00B00000
IMAGE_SCN_ALIGN_2048BYTES = 0x00C00000
IMAGE_SCN_ALIGN_4096BYTES = 0x00D00000
IMAGE_SCN_ALIGN_8192BYTES = 0x00E00000
IMAGE_SCN_LNK_NRELOC_OVFL = 0x01000000
IMAGE_SCN_MEM_DISCARDABLE = 0x02000000
IMAGE_SCN_MEM_NOT_CACHED = 0x04000000
IMAGE_SCN_MEM_NOT_PAGED = 0x08000000
IMAGE_SCN_MEM_SHARED = 0x10000000
IMAGE_SCN_MEM_EXECUTE = 0x20000000
IMAGE_SCN_MEM_READ = 0x40000000
IMAGE_SCN_MEM_WRITE = 0x80000000
)
See https://docs.microsoft.com/en-us/windows/win32/debug/pe-format. TODO(crawshaw): add these constants to debug/pe.
const (
IMAGE_SYM_TYPE_NULL = 0
IMAGE_SYM_TYPE_STRUCT = 8
IMAGE_SYM_DTYPE_FUNCTION = 2
IMAGE_SYM_DTYPE_ARRAY = 3
IMAGE_SYM_CLASS_EXTERNAL = 2
IMAGE_SYM_CLASS_STATIC = 3
IMAGE_REL_I386_DIR32 = 0x0006
IMAGE_REL_I386_DIR32NB = 0x0007
IMAGE_REL_I386_SECREL = 0x000B
IMAGE_REL_I386_REL32 = 0x0014
IMAGE_REL_AMD64_ADDR64 = 0x0001
IMAGE_REL_AMD64_ADDR32 = 0x0002
IMAGE_REL_AMD64_ADDR32NB = 0x0003
IMAGE_REL_AMD64_REL32 = 0x0004
IMAGE_REL_AMD64_SECREL = 0x000B
IMAGE_REL_ARM_ABSOLUTE = 0x0000
IMAGE_REL_ARM_ADDR32 = 0x0001
IMAGE_REL_ARM_ADDR32NB = 0x0002
IMAGE_REL_ARM_BRANCH24 = 0x0003
IMAGE_REL_ARM_BRANCH11 = 0x0004
IMAGE_REL_ARM_SECREL = 0x000F
IMAGE_REL_ARM64_ABSOLUTE = 0x0000
IMAGE_REL_ARM64_ADDR32 = 0x0001
IMAGE_REL_ARM64_ADDR32NB = 0x0002
IMAGE_REL_ARM64_BRANCH26 = 0x0003
IMAGE_REL_ARM64_PAGEBASE_REL21 = 0x0004
IMAGE_REL_ARM64_REL21 = 0x0005
IMAGE_REL_ARM64_PAGEOFFSET_12A = 0x0006
IMAGE_REL_ARM64_PAGEOFFSET_12L = 0x0007
IMAGE_REL_ARM64_SECREL = 0x0008
IMAGE_REL_ARM64_SECREL_LOW12A = 0x0009
IMAGE_REL_ARM64_SECREL_HIGH12A = 0x000A
IMAGE_REL_ARM64_SECREL_LOW12L = 0x000B
IMAGE_REL_ARM64_TOKEN = 0x000C
IMAGE_REL_ARM64_SECTION = 0x000D
IMAGE_REL_ARM64_ADDR64 = 0x000E
IMAGE_REL_ARM64_BRANCH19 = 0x000F
IMAGE_REL_ARM64_BRANCH14 = 0x0010
IMAGE_REL_ARM64_REL32 = 0x0011
IMAGE_REL_BASED_HIGHLOW = 3
IMAGE_REL_BASED_DIR64 = 10
)
const (
PeMinimumTargetMajorVersion = 6
PeMinimumTargetMinorVersion = 1
)
const (
// Total amount of space to reserve at the start of the file
// for File Header, Auxiliary Header, and Section Headers.
// May waste some.
XCOFFHDRRESERVE = FILHSZ_64 + AOUTHSZ_EXEC64 + SCNHSZ_64*23
// base on dump -o, then rounded from 32B to 64B to
// match worst case elf text section alignment on ppc64.
XCOFFSECTALIGN int64 = 64
// XCOFF binaries should normally have all its sections position-independent.
// However, this is not yet possible for .text because of some R_ADDR relocations
// inside RODATA symbols.
// .data and .bss are position-independent so their address start inside an unreachable
// segment during execution to force segfault if something is wrong.
XCOFFTEXTBASE = 0x100000000 // Start of text address
XCOFFDATABASE = 0x200000000 // Start of data address
)
Flags that describe the type of the object file.
const (
F_RELFLG = 0x0001
F_EXEC = 0x0002
F_LNNO = 0x0004
F_FDPR_PROF = 0x0010
F_FDPR_OPTI = 0x0020
F_DSA = 0x0040
F_VARPG = 0x0100
F_DYNLOAD = 0x1000
F_SHROBJ = 0x2000
F_LOADONLY = 0x4000
)
Flags defining the section type.
const (
STYP_DWARF = 0x0010
STYP_TEXT = 0x0020
STYP_DATA = 0x0040
STYP_BSS = 0x0080
STYP_EXCEPT = 0x0100
STYP_INFO = 0x0200
STYP_TDATA = 0x0400
STYP_TBSS = 0x0800
STYP_LOADER = 0x1000
STYP_DEBUG = 0x2000
STYP_TYPCHK = 0x4000
STYP_OVRFLO = 0x8000
)
const (
SSUBTYP_DWINFO = 0x10000 // DWARF info section
SSUBTYP_DWLINE = 0x20000 // DWARF line-number section
SSUBTYP_DWPBNMS = 0x30000 // DWARF public names section
SSUBTYP_DWPBTYP = 0x40000 // DWARF public types section
SSUBTYP_DWARNGE = 0x50000 // DWARF aranges section
SSUBTYP_DWABREV = 0x60000 // DWARF abbreviation section
SSUBTYP_DWSTR = 0x70000 // DWARF strings section
SSUBTYP_DWRNGES = 0x80000 // DWARF ranges section
SSUBTYP_DWLOC = 0x90000 // DWARF location lists section
SSUBTYP_DWFRAME = 0xA0000 // DWARF frames section
SSUBTYP_DWMAC = 0xB0000 // DWARF macros section
)
Headers size
const (
FILHSZ_32 = 20
FILHSZ_64 = 24
AOUTHSZ_EXEC32 = 72
AOUTHSZ_EXEC64 = 120
SCNHSZ_32 = 40
SCNHSZ_64 = 72
LDHDRSZ_32 = 32
LDHDRSZ_64 = 56
LDSYMSZ_64 = 24
RELSZ_64 = 14
)
const (
// Nscnum
N_DEBUG = -2
N_ABS = -1
N_UNDEF = 0
//Ntype
SYM_V_INTERNAL = 0x1000
SYM_V_HIDDEN = 0x2000
SYM_V_PROTECTED = 0x3000
SYM_V_EXPORTED = 0x4000
SYM_TYPE_FUNC = 0x0020 // is function
)
Storage Class.
const (
C_NULL = 0 // Symbol table entry marked for deletion
C_EXT = 2 // External symbol
C_STAT = 3 // Static symbol
C_BLOCK = 100 // Beginning or end of inner block
C_FCN = 101 // Beginning or end of function
C_FILE = 103 // Source file name and compiler information
C_HIDEXT = 107 // Unnamed external symbol
C_BINCL = 108 // Beginning of include file
C_EINCL = 109 // End of include file
C_WEAKEXT = 111 // Weak external symbol
C_DWARF = 112 // DWARF symbol
C_GSYM = 128 // Global variable
C_LSYM = 129 // Automatic variable allocated on stack
C_PSYM = 130 // Argument to subroutine allocated on stack
C_RSYM = 131 // Register variable
C_RPSYM = 132 // Argument to function or procedure stored in register
C_STSYM = 133 // Statically allocated symbol
C_BCOMM = 135 // Beginning of common block
C_ECOML = 136 // Local member of common block
C_ECOMM = 137 // End of common block
C_DECL = 140 // Declaration of object
C_ENTRY = 141 // Alternate entry
C_FUN = 142 // Function or procedure
C_BSTAT = 143 // Beginning of static block
C_ESTAT = 144 // End of static block
C_GTLS = 145 // Global thread-local variable
C_STTLS = 146 // Static thread-local variable
)
Xftype field
const (
XFT_FN = 0 // Source File Name
XFT_CT = 1 // Compile Time Stamp
XFT_CV = 2 // Compiler Version Number
XFT_CD = 128 // Compiler Defined Information/
)
Symbol type field.
const (
XTY_ER = 0 // External reference
XTY_SD = 1 // Section definition
XTY_LD = 2 // Label definition
XTY_CM = 3 // Common csect definition
XTY_WK = 0x8 // Weak symbol
XTY_EXP = 0x10 // Exported symbol
XTY_ENT = 0x20 // Entry point symbol
XTY_IMP = 0x40 // Imported symbol
)
Storage-mapping class.
const (
XMC_PR = 0 // Program code
XMC_RO = 1 // Read-only constant
XMC_DB = 2 // Debug dictionary table
XMC_TC = 3 // TOC entry
XMC_UA = 4 // Unclassified
XMC_RW = 5 // Read/Write data
XMC_GL = 6 // Global linkage
XMC_XO = 7 // Extended operation
XMC_SV = 8 // 32-bit supervisor call descriptor
XMC_BS = 9 // BSS class
XMC_DS = 10 // Function descriptor
XMC_UC = 11 // Unnamed FORTRAN common
XMC_TC0 = 15 // TOC anchor
XMC_TD = 16 // Scalar data entry in the TOC
XMC_SV64 = 17 // 64-bit supervisor call descriptor
XMC_SV3264 = 18 // Supervisor call descriptor for both 32-bit and 64-bit
XMC_TL = 20 // Read/Write thread-local data
XMC_UL = 21 // Read/Write thread-local data (.tbss)
XMC_TE = 22 // TOC entry
)
const (
XCOFF_R_POS = 0x00 // A(sym) Positive Relocation
XCOFF_R_NEG = 0x01 // -A(sym) Negative Relocation
XCOFF_R_REL = 0x02 // A(sym-*) Relative to self
XCOFF_R_TOC = 0x03 // A(sym-TOC) Relative to TOC
XCOFF_R_TRL = 0x12 // A(sym-TOC) TOC Relative indirect load.
XCOFF_R_TRLA = 0x13 // A(sym-TOC) TOC Rel load address. modifiable inst
XCOFF_R_GL = 0x05 // A(external TOC of sym) Global Linkage
XCOFF_R_TCL = 0x06 // A(local TOC of sym) Local object TOC address
XCOFF_R_RL = 0x0C // A(sym) Pos indirect load. modifiable instruction
XCOFF_R_RLA = 0x0D // A(sym) Pos Load Address. modifiable instruction
XCOFF_R_REF = 0x0F // AL0(sym) Non relocating ref. No garbage collect
XCOFF_R_BA = 0x08 // A(sym) Branch absolute. Cannot modify instruction
XCOFF_R_RBA = 0x18 // A(sym) Branch absolute. modifiable instruction
XCOFF_R_BR = 0x0A // A(sym-*) Branch rel to self. non modifiable
XCOFF_R_RBR = 0x1A // A(sym-*) Branch rel to self. modifiable instr
XCOFF_R_TLS = 0x20 // General-dynamic reference to TLS symbol
XCOFF_R_TLS_IE = 0x21 // Initial-exec reference to TLS symbol
XCOFF_R_TLS_LD = 0x22 // Local-dynamic reference to TLS symbol
XCOFF_R_TLS_LE = 0x23 // Local-exec reference to TLS symbol
XCOFF_R_TLSM = 0x24 // Module reference to TLS symbol
XCOFF_R_TLSML = 0x25 // Module reference to local (own) module
XCOFF_R_TOCU = 0x30 // Relative to TOC - high order bits
XCOFF_R_TOCL = 0x31 // Relative to TOC - low order bits
)
const (
ARMAG = "!<arch>\n"
)
* Relocation types.
const (
ARM_MAGIC_TRAMP_NUMBER = 0x5c000003
)
* Total amount of space to reserve at the start of the file * for Header, PHeaders, SHeaders, and interp. * May waste some. * On FreeBSD, cannot be larger than a page.
const (
ELFRESERVE = 4096
)
const ELF_NOTE_FREEBSD_NAME = "FreeBSD\x00"
* Total amount of space to reserve at the start of the file * for Header, PHeaders, and SHeaders. * May waste some.
const (
INITIAL_MACHO_HEADR = 4 * 1024
)
* We use the 64-bit data structures on both 32- and 64-bit machines * in order to write the code just once. The 64-bit data structure is * written in the 32-bit format on the 32-bit machines.
const (
NSECT = 400
)
const SYMESZ = 18
const (
U64_TOCMAGIC = 0767 // AIX 64-bit XCOFF
)
var (
Funcalign int
HEADR int32
)
var (
Segtext sym.Segment
Segrodata sym.Segment
Segrelrodata sym.Segment
Segdata sym.Segment
Segdwarf sym.Segment
Segpdata sym.Segment // windows-only
Segxdata sym.Segment // windows-only
Segments = []*sym.Segment{&Segtext, &Segrodata, &Segrelrodata, &Segdata, &Segdwarf, &Segpdata, &Segxdata}
)
Flags used by the linker. The exported flags are used by the architecture-specific packages.
var (
FlagC = flag.Bool("c", false, "dump call graph")
FlagD = flag.Bool("d", false, "disable dynamic executable")
FlagS = flag.Bool("s", false, "disable symbol table")
FlagDebugTramp = flag.Int("debugtramp", 0, "debug trampolines")
FlagDebugTextSize = flag.Int("debugtextsize", 0, "debug text section max size")
FlagStrictDups = flag.Int("strictdups", 0, "sanity check duplicate symbol contents during object file reading (1=warn 2=err).")
FlagRound = flag.Int64("R", -1, "set address rounding `quantum`")
FlagTextAddr = flag.Int64("T", -1, "set the start address of text symbols")
FlagFuncAlign = flag.Int("funcalign", 0, "set function align to `N` bytes")
FlagW = new(bool) // the -w flag, computed in main from flagW
)
var (
// PEBASE is the base address for the executable.
// It is small for 32-bit and large for 64-bit.
PEBASE int64
// SectionAlignment must be greater than or equal to FileAlignment.
// The default is the page size for the architecture.
PESECTALIGN int64 = 0x1000
// FileAlignment should be a power of 2 between 512 and 64 K, inclusive.
// The default is 512. If the SectionAlignment is less than
// the architecture's page size, then FileAlignment must match SectionAlignment.
PEFILEALIGN int64 = 2 << 8
)
var (
PESECTHEADR int32
PEFILEHEADR int32
)
CarrierSymByType tracks carrier symbols and their sizes.
var CarrierSymByType [sym.SXREF]struct { Sym loader.Sym Size int64 }
var ELF_NOTE_BUILDINFO_NAME = []byte("GNU\x00")
var ELF_NOTE_GO_NAME = []byte("Go\x00\x00")
var ELF_NOTE_NETBSD_NAME = []byte("NetBSD\x00")
var ELF_NOTE_OPENBSD_NAME = []byte("OpenBSD\x00")
var (
Nelfsym = 1
)
func AddGotSym(target *Target, ldr *loader.Loader, syms *ArchSyms, s loader.Sym, elfRelocTyp uint32)
func AddMachoSym(ldr *loader.Loader, s loader.Sym)
AddMachoSym adds s to Mach-O symbol table, used in GenSymLate. Currently only used on ARM64 when external linking.
func AddPELabelSym(ldr *loader.Loader, s loader.Sym)
func Adddynsym(ldr *loader.Loader, target *Target, syms *ArchSyms, s loader.Sym)
func Asmbelfsetup()
func AtExit(f func())
func CodeblkPad(ctxt *Link, out *OutBuf, addr int64, size int64, pad []byte)
func DatblkBytes(ctxt *Link, addr int64, size int64) []byte
Used only on Wasm for now.
func ElfSymForReloc(ctxt *Link, s loader.Sym) int32
func Elfinit(ctxt *Link)
Initialize the global variable that describes the ELF header. It will be updated as we write section and prog headers.
func Elfwritedynent(arch *sys.Arch, s *loader.SymbolBuilder, tag elf.DynTag, val uint64)
func Elfwritedynentsymplus(ctxt *Link, s *loader.SymbolBuilder, tag elf.DynTag, t loader.Sym, add int64)
func Entryvalue(ctxt *Link) int64
func Errorf(format string, args ...interface{})
Errorf logs an error message without a specific symbol for context. Use ctxt.Errorf when possible.
If more than 20 errors have been printed, exit with an error.
Logging an error means that on exit cmd/link will delete any output file and return a non-zero error code.
func Exit(code int)
Exit exits with code after executing all atExitFuncs.
func Exitf(format string, a ...interface{})
Exitf logs an error message then calls Exit(2).
func ExtrelocSimple(ldr *loader.Loader, r loader.Reloc) loader.ExtReloc
ExtrelocSimple creates a simple external relocation from r, with the same symbol and addend.
func ExtrelocViaOuterSym(ldr *loader.Loader, r loader.Reloc, s loader.Sym) loader.ExtReloc
ExtrelocViaOuterSym creates an external relocation from r targeting the outer symbol and folding the subsymbol's offset into the addend.
func FoldSubSymbolOffset(ldr *loader.Loader, s loader.Sym) (loader.Sym, int64)
FoldSubSymbolOffset computes the offset of symbol s to its top-level outer symbol. Returns the top-level symbol and the offset. This is used in generating external relocations.
func Lflag(ctxt *Link, arg string)
func Loaderblk(ctxt *Link, off uint64)
Create loader section and returns its size.
func MachoAddBind(off int64, targ loader.Sym)
func MachoAddRebase(s loader.Sym, off int64)
func Main(arch *sys.Arch, theArch Arch)
Main is the main entry point for the linker code.
func Peinit(ctxt *Link)
func PrepareAddmoduledata(ctxt *Link) (*loader.SymbolBuilder, loader.Sym)
PrepareAddmoduledata returns a symbol builder that target-specific code can use to build up the linker-generated go.link.addmoduledata function, along with the sym for runtime.addmoduledata itself. If this function is not needed (for example in cases where we're linking a module that contains the runtime) the returned builder will be nil.
func Rnd(v int64, r int64) int64
func Xcoffadddynrel(target *Target, ldr *loader.Loader, syms *ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool
Xcoffadddynrel adds a dynamic relocation in a XCOFF file. This relocation will be made by the loader.
func Xcoffinit(ctxt *Link)
Xcoffinit initialised some internal value and setups already known header information.
type ArHdr struct {
// contains filtered or unexported fields
}
type Arch struct {
Funcalign int
Maxalign int
Minalign int
Dwarfregsp int
Dwarfreglr int
// Threshold of total text size, used for trampoline insertion. If the total
// text size is smaller than TrampLimit, we won't need to insert trampolines.
// It is pretty close to the offset range of a direct CALL machine instruction.
// We leave some room for extra stuff like PLT stubs.
TrampLimit uint64
// Empty spaces between codeblocks will be padded with this value.
// For example an architecture might want to pad with a trap instruction to
// catch wayward programs. Architectures that do not define a padding value
// are padded with zeros.
CodePad []byte
// Plan 9 variables.
Plan9Magic uint32
Plan9_64Bit bool
Adddynrel func(*Target, *loader.Loader, *ArchSyms, loader.Sym, loader.Reloc, int) bool
Archinit func(*Link)
// Archreloc is an arch-specific hook that assists in relocation processing
// (invoked by 'relocsym'); it handles target-specific relocation tasks.
// Here "rel" is the current relocation being examined, "sym" is the symbol
// containing the chunk of data to which the relocation applies, and "off"
// is the contents of the to-be-relocated data item (from sym.P). Return
// value is the appropriately relocated value (to be written back to the
// same spot in sym.P), number of external _host_ relocations needed (i.e.
// ELF/Mach-O/etc. relocations, not Go relocations, this must match ELF.Reloc1,
// etc.), and a boolean indicating success/failure (a failing value indicates
// a fatal error).
Archreloc func(*Target, *loader.Loader, *ArchSyms, loader.Reloc, loader.Sym,
int64) (relocatedOffset int64, nExtReloc int, ok bool)
// Archrelocvariant is a second arch-specific hook used for
// relocation processing; it handles relocations where r.Type is
// insufficient to describe the relocation (r.Variant !=
// sym.RV_NONE). Here "rel" is the relocation being applied, "sym"
// is the symbol containing the chunk of data to which the
// relocation applies, and "off" is the contents of the
// to-be-relocated data item (from sym.P). Return is an updated
// offset value.
Archrelocvariant func(target *Target, ldr *loader.Loader, rel loader.Reloc,
rv sym.RelocVariant, sym loader.Sym, offset int64, data []byte) (relocatedOffset int64)
// Generate a trampoline for a call from s to rs if necessary. ri is
// index of the relocation.
Trampoline func(ctxt *Link, ldr *loader.Loader, ri int, rs, s loader.Sym)
// Assembling the binary breaks into two phases, writing the code/data/
// dwarf information (which is rather generic), and some more architecture
// specific work like setting up the elf headers/dynamic relocations, etc.
// The phases are called "Asmb" and "Asmb2". Asmb2 needs to be defined for
// every architecture, but only if architecture has an Asmb function will
// it be used for assembly. Otherwise a generic assembly Asmb function is
// used.
Asmb func(*Link, *loader.Loader)
Asmb2 func(*Link, *loader.Loader)
// Extreloc is an arch-specific hook that converts a Go relocation to an
// external relocation. Return the external relocation and whether it is
// needed.
Extreloc func(*Target, *loader.Loader, loader.Reloc, loader.Sym) (loader.ExtReloc, bool)
Gentext func(*Link, *loader.Loader) // Generate text before addressing has been performed.
Machoreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
MachorelocSize uint32 // size of an Mach-O relocation record, must match Machoreloc1.
PEreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
Xcoffreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
// Generate additional symbols for the native symbol table just prior to
// code generation.
GenSymsLate func(*Link, *loader.Loader)
// TLSIEtoLE converts a TLS Initial Executable relocation to
// a TLS Local Executable relocation.
//
// This is possible when a TLS IE relocation refers to a local
// symbol in an executable, which is typical when internally
// linking PIE binaries.
TLSIEtoLE func(P []byte, off, size int)
// optional override for assignAddress
AssignAddress func(ldr *loader.Loader, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64)
// ELF specific information.
ELF ELFArch
}
ArchSyms holds a number of architecture specific symbols used during relocation. Rather than allowing them universal access to all symbols, we keep a subset for relocation application.
type ArchSyms struct {
Rel loader.Sym
Rela loader.Sym
RelPLT loader.Sym
RelaPLT loader.Sym
LinkEditGOT loader.Sym
LinkEditPLT loader.Sym
TOC loader.Sym
DotTOC []loader.Sym // for each version
GOT loader.Sym
PLT loader.Sym
GOTPLT loader.Sym
Tlsg loader.Sym
Tlsoffset int
Dynamic loader.Sym
DynSym loader.Sym
DynStr loader.Sym
// contains filtered or unexported fields
}
A BuildMode indicates the sort of object we are building.
Possible build modes are the same as those for the -buildmode flag in cmd/go, and are documented in 'go help buildmode'.
type BuildMode uint8
const (
BuildModeUnset BuildMode = iota
BuildModeExe
BuildModePIE
BuildModeCArchive
BuildModePlugin
)
func (mode *BuildMode) Set(s string) error
Set implements flag.Value to set the build mode based on the argument to the -buildmode flag.
func (mode BuildMode) String() string
type Dll struct {
// contains filtered or unexported fields
}
ELFArch includes target-specific hooks for ELF targets. This is initialized by the target-specific Init function called by the linker's main function in cmd/link/main.go.
type ELFArch struct {
Androiddynld string
Linuxdynld string
LinuxdynldMusl string
Freebsddynld string
Netbsddynld string
Openbsddynld string
Dragonflydynld string
Solarisdynld string
Reloc1 func(*Link, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int, int64) bool
RelocSize uint32 // size of an ELF relocation record, must match Reloc1.
SetupPLT func(ctxt *Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym)
// DynamicReadOnly can be set to true to make the .dynamic
// section read-only. By default it is writable.
// This is used by MIPS targets.
DynamicReadOnly bool
}
* ELF header.
type ElfEhdr elf.Header64
* Program header.
type ElfPhdr elf.ProgHeader
* Section header.
type ElfShdr struct {
elf.Section64
// contains filtered or unexported fields
}
type Elfaux struct {
// contains filtered or unexported fields
}
type Elflib struct {
// contains filtered or unexported fields
}
type Elfstring struct {
// contains filtered or unexported fields
}
ErrorReporter is used to make error reporting thread safe.
type ErrorReporter struct {
loader.ErrorReporter
SymName symNameFn
// contains filtered or unexported fields
}
type GCProg struct {
// contains filtered or unexported fields
}
func (p *GCProg) AddSym(s loader.Sym)
func (p *GCProg) AddType(off int64, typ loader.Sym)
Add to the gc program the ptr bits for the type typ at byte offset off in the region being described. The type must have a pointer in it.
func (p *GCProg) End(size int64)
func (p *GCProg) Init(ctxt *Link, name string)
type Hostobj struct {
// contains filtered or unexported fields
}
type IMAGE_EXPORT_DIRECTORY struct {
Characteristics uint32
TimeDateStamp uint32
MajorVersion uint16
MinorVersion uint16
Name uint32
Base uint32
NumberOfFunctions uint32
NumberOfNames uint32
AddressOfFunctions uint32
AddressOfNames uint32
AddressOfNameOrdinals uint32
}
type IMAGE_IMPORT_DESCRIPTOR struct {
OriginalFirstThunk uint32
TimeDateStamp uint32
ForwarderChain uint32
Name uint32
FirstThunk uint32
}
type Imp struct {
// contains filtered or unexported fields
}
Link holds the context for writing object code from a compiler or for reading that input into the linker.
type Link struct {
Target
ErrorReporter
ArchSyms
Out *OutBuf
Debugvlog int
Bso *bufio.Writer
Loaded bool // set after all inputs have been loaded as symbols
Libdir []string
Library []*sym.Library
LibraryByPkg map[string]*sym.Library
Shlibs []Shlib
Textp []loader.Sym
Moduledata loader.Sym
PackageFile map[string]string
PackageShlib map[string]string
// contains filtered or unexported fields
}
func (ctxt *Link) AddTramp(s *loader.SymbolBuilder, typ sym.SymKind)
add a trampoline with symbol s (to be laid down after the current function)
func (ctxt *Link) CanUsePlugins() bool
CanUsePlugins reports whether a plugins can be used
func (ctxt *Link) DynlinkingGo() bool
DynlinkingGo reports whether we are producing Go code that can live in separate shared libraries linked together at runtime.
func (ctxt *Link) Errorf(s loader.Sym, format string, args ...interface{})
Errorf method logs an error message.
If more than 20 errors have been printed, exit with an error.
Logging an error means that on exit cmd/link will delete any output file and return a non-zero error code.
func (ctxt *Link) IncVersion() int
Allocate a new version (i.e. symbol namespace).
func (ctxt *Link) Logf(format string, args ...interface{})
func (ctxt *Link) MaxVersion() int
returns the maximum version number
func (ctxt *Link) NeedCodeSign() bool
NeedCodeSign reports whether we need to code-sign the output binary.
LinkMode indicates whether an external linker is used for the final link.
type LinkMode uint8
const (
LinkAuto LinkMode = iota
LinkInternal
LinkExternal
)
func (mode *LinkMode) Set(s string) error
func (mode *LinkMode) String() string
type MachoHdr struct {
// contains filtered or unexported fields
}
type MachoLoad struct {
// contains filtered or unexported fields
}
type MachoPlatform int
const (
PLATFORM_MACOS MachoPlatform = 1
PLATFORM_IOS MachoPlatform = 2
PLATFORM_TVOS MachoPlatform = 3
PLATFORM_WATCHOS MachoPlatform = 4
PLATFORM_BRIDGEOS MachoPlatform = 5
PLATFORM_MACCATALYST MachoPlatform = 6
)
MachoPlatformLoad represents a LC_VERSION_MIN_* or LC_BUILD_VERSION load command.
type MachoPlatformLoad struct {
// contains filtered or unexported fields
}
type MachoSect struct {
// contains filtered or unexported fields
}
type MachoSeg struct {
// contains filtered or unexported fields
}
OutBuf is a buffered file writer.
It is similar to the Writer in cmd/internal/bio with a few small differences.
First, it tracks the output architecture and uses it to provide endian helpers.
Second, it provides a very cheap offset counter that doesn't require any system calls to read the value.
Third, it also mmaps the output file (if available). The intended usage is:
And finally, it provides a mechanism by which you can multithread the writing of output files. This mechanism is accomplished by copying a OutBuf, and using it in the thread/goroutine.
Parallel OutBuf is intended to be used like:
func write(out *OutBuf) {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
view, err := out.View(start[i])
if err != nil {
// handle output
continue
}
go func(out *OutBuf, i int) {
// do output
wg.Done()
}(view, i)
}
wg.Wait()
}
type OutBuf struct {
// contains filtered or unexported fields
}
func NewOutBuf(arch *sys.Arch) *OutBuf
func (out *OutBuf) Close() error
func (out *OutBuf) Data() []byte
Data returns the whole written OutBuf as a byte slice.
func (out *OutBuf) ErrorClose()
ErrorClose closes the output file (if any). It is supposed to be called only at exit on error, so it doesn't do any clean up or buffer flushing, just closes the file.
func (out *OutBuf) Mmap(filesize uint64) (err error)
Mmap maps the output file with the given size. It unmaps the old mapping if it is already mapped. It also flushes any in-heap data to the new mapping.
func (out *OutBuf) Offset() int64
func (out *OutBuf) Open(name string) error
func (out *OutBuf) SeekSet(p int64)
func (out *OutBuf) View(start uint64) *OutBuf
func (out *OutBuf) Write(v []byte) (int, error)
Write writes the contents of v to the buffer.
func (out *OutBuf) Write16(v uint16)
func (out *OutBuf) Write32(v uint32)
func (out *OutBuf) Write32b(v uint32)
func (out *OutBuf) Write64(v uint64)
func (out *OutBuf) Write64b(v uint64)
func (out *OutBuf) Write8(v uint8)
func (out *OutBuf) WriteByte(v byte) error
WriteByte is an alias for Write8 to fulfill the io.ByteWriter interface.
func (out *OutBuf) WriteString(s string)
func (out *OutBuf) WriteStringN(s string, n int)
WriteStringN writes the first n bytes of s. If n is larger than len(s) then it is padded with zero bytes.
func (out *OutBuf) WriteStringPad(s string, n int, pad []byte)
WriteStringPad writes the first n bytes of s. If n is larger than len(s) then it is padded with the bytes in pad (repeated as needed).
func (out *OutBuf) WriteSym(ldr *loader.Loader, s loader.Sym) []byte
WriteSym writes the content of a Symbol, and returns the output buffer that we just wrote, so we can apply further edit to the symbol content. For generator symbols, it also sets the symbol's Data to the output buffer.
type Rpath struct {
// contains filtered or unexported fields
}
func (r *Rpath) Set(val string) error
func (r *Rpath) String() string
type Shlib struct {
Path string
Hash []byte
Deps []string
File *elf.File
// contains filtered or unexported fields
}
type SymbolType int8 // TODO: after genasmsym is gone, maybe rename to plan9typeChar or something
const (
// see also https://9p.io/magic/man2html/1/nm
TextSym SymbolType = 'T'
DataSym SymbolType = 'D'
BSSSym SymbolType = 'B'
UndefinedSym SymbolType = 'U'
TLSSym SymbolType = 't'
FrameSym SymbolType = 'm'
ParamSym SymbolType = 'p'
AutoSym SymbolType = 'a'
// Deleted auto (not a real sym, just placeholder for type)
DeletedAutoSym = 'x'
)
Target holds the configuration we're building for.
type Target struct {
Arch *sys.Arch
HeadType objabi.HeadType
LinkMode LinkMode
BuildMode BuildMode
IsELF bool
// contains filtered or unexported fields
}
func (t *Target) CanUsePlugins() bool
func (t *Target) Is386() bool
func (t *Target) IsAIX() bool
func (t *Target) IsAMD64() bool
func (t *Target) IsARM() bool
func (t *Target) IsARM64() bool
func (t *Target) IsBigEndian() bool
func (t *Target) IsDarwin() bool
func (t *Target) IsDynlinkingGo() bool
func (t *Target) IsElf() bool
func (t *Target) IsExe() bool
func (t *Target) IsExternal() bool
func (t *Target) IsFreebsd() bool
func (t *Target) IsInternal() bool
func (t *Target) IsLOONG64() bool
func (t *Target) IsLinux() bool
func (t *Target) IsMIPS() bool
func (t *Target) IsMIPS64() bool
func (t *Target) IsNetbsd() bool
func (t *Target) IsOpenbsd() bool
func (t *Target) IsPIE() bool
func (t *Target) IsPPC64() bool
func (t *Target) IsPlan9() bool
func (t *Target) IsPlugin() bool
func (t *Target) IsRISCV64() bool
func (t *Target) IsS390X() bool
func (t *Target) IsShared() bool
func (t *Target) IsSharedGoLink() bool
func (t *Target) IsSolaris() bool
func (t *Target) IsWasm() bool
func (t *Target) IsWindows() bool
func (t *Target) UseRelro() bool
UseRelro reports whether to make use of "read only relocations" aka relro.
func (t *Target) UsesLibc() bool
Auxiliary Header
type XcoffAoutHdr64 struct {
Omagic int16 // Flags - Ignored If Vstamp Is 1
Ovstamp int16 // Version
Odebugger uint32 // Reserved For Debugger
Otextstart uint64 // Virtual Address Of Text
Odatastart uint64 // Virtual Address Of Data
Otoc uint64 // Toc Address
Osnentry int16 // Section Number For Entry Point
Osntext int16 // Section Number For Text
Osndata int16 // Section Number For Data
Osntoc int16 // Section Number For Toc
Osnloader int16 // Section Number For Loader
Osnbss int16 // Section Number For Bss
Oalgntext int16 // Max Text Alignment
Oalgndata int16 // Max Data Alignment
Omodtype [2]byte // Module Type Field
Ocpuflag uint8 // Bit Flags - Cputypes Of Objects
Ocputype uint8 // Reserved for CPU type
Otextpsize uint8 // Requested text page size
Odatapsize uint8 // Requested data page size
Ostackpsize uint8 // Requested stack page size
Oflags uint8 // Flags And TLS Alignment
Otsize uint64 // Text Size In Bytes
Odsize uint64 // Data Size In Bytes
Obsize uint64 // Bss Size In Bytes
Oentry uint64 // Entry Point Address
Omaxstack uint64 // Max Stack Size Allowed
Omaxdata uint64 // Max Data Size Allowed
Osntdata int16 // Section Number For Tdata Section
Osntbss int16 // Section Number For Tbss Section
Ox64flags uint16 // Additional Flags For 64-Bit Objects
Oresv3a int16 // Reserved
Oresv3 [2]int32 // Reserved
}
csect Auxiliary Entry.
type XcoffAuxCSect64 struct {
Xscnlenlo uint32 // Lower 4 bytes of length or symbol table index
Xparmhash uint32 // Offset of parameter type-check string
Xsnhash uint16 // .typchk section number
Xsmtyp uint8 // Symbol alignment and type
Xsmclas uint8 // Storage-mapping class
Xscnlenhi uint32 // Upper 4 bytes of length or symbol table index
Xpad uint8 // Unused
Xauxtype uint8 // Type of auxiliary entry
}
DWARF Auxiliary Entry
type XcoffAuxDWARF64 struct {
Xscnlen uint64 // Length of this symbol section
X_pad [9]byte
Xauxtype uint8 // Type of auxiliary entry
}
Function Auxiliary Entry
type XcoffAuxFcn64 struct {
Xlnnoptr uint64 // File pointer to line number
Xfsize uint32 // Size of function in bytes
Xendndx uint32 // Symbol table index of next entry
Xpad uint8 // Unused
Xauxtype uint8 // Type of auxiliary entry
}
File Auxiliary Entry
type XcoffAuxFile64 struct {
Xzeroes uint32 // The name is always in the string table
Xoffset uint32 // Offset in the string table
X_pad1 [6]byte
Xftype uint8 // Source file string type
X_pad2 [2]byte
Xauxtype uint8 // Type of auxiliary entry
}
File Header
type XcoffFileHdr64 struct {
Fmagic uint16 // Target machine
Fnscns uint16 // Number of sections
Ftimedat int32 // Time and date of file creation
Fsymptr uint64 // Byte offset to symbol table start
Fopthdr uint16 // Number of bytes in optional header
Fflags uint16 // Flags
Fnsyms int32 // Number of entries in symbol table
}
Loader Header
type XcoffLdHdr64 struct {
Lversion int32 // Loader section version number
Lnsyms int32 // Number of symbol table entries
Lnreloc int32 // Number of relocation table entries
Listlen uint32 // Length of import file ID string table
Lnimpid int32 // Number of import file IDs
Lstlen uint32 // Length of string table
Limpoff uint64 // Offset to start of import file IDs
Lstoff uint64 // Offset to start of string table
Lsymoff uint64 // Offset to start of symbol table
Lrldoff uint64 // Offset to start of relocation entries
}
type XcoffLdImportFile64 struct {
Limpidpath string
Limpidbase string
Limpidmem string
}
type XcoffLdRel64 struct {
Lvaddr uint64 // Address Field
Lrtype uint16 // Relocation Size and Type
Lrsecnm int16 // Section Number being relocated
Lsymndx int32 // Loader-Section symbol table index
}
type XcoffLdStr64 struct {
// contains filtered or unexported fields
}
Loader Symbol
type XcoffLdSym64 struct {
Lvalue uint64 // Address field
Loffset uint32 // Byte offset into string table of symbol name
Lscnum int16 // Section number containing symbol
Lsmtype int8 // Symbol type, export, import flags
Lsmclas int8 // Symbol storage class
Lifile int32 // Import file ID; ordinal of import file IDs
Lparm uint32 // Parameter type-check field
}
Section Header
type XcoffScnHdr64 struct {
Sname [8]byte // Section Name
Spaddr uint64 // Physical Address
Svaddr uint64 // Virtual Address
Ssize uint64 // Section Size
Sscnptr uint64 // File Offset To Raw Data
Srelptr uint64 // File Offset To Relocation
Slnnoptr uint64 // File Offset To Line Numbers
Snreloc uint32 // Number Of Relocation Entries
Snlnno uint32 // Number Of Line Number Entries
Sflags uint32 // flags
}
Symbol Table Entry
type XcoffSymEnt64 struct {
Nvalue uint64 // Symbol value
Noffset uint32 // Offset of the name in string table or .debug section
Nscnum int16 // Section number of symbol
Ntype uint16 // Basic and derived type specification
Nsclass uint8 // Storage class of symbol
Nnumaux int8 // Number of auxiliary entries
}