summaryrefslogtreecommitdiff
path: root/devdocs/go/debug%2Fmacho%2Findex.html
diff options
context:
space:
mode:
Diffstat (limited to 'devdocs/go/debug%2Fmacho%2Findex.html')
-rw-r--r--devdocs/go/debug%2Fmacho%2Findex.html542
1 files changed, 542 insertions, 0 deletions
diff --git a/devdocs/go/debug%2Fmacho%2Findex.html b/devdocs/go/debug%2Fmacho%2Findex.html
new file mode 100644
index 00000000..2dadd0f1
--- /dev/null
+++ b/devdocs/go/debug%2Fmacho%2Findex.html
@@ -0,0 +1,542 @@
+<h1> Package macho </h1> <ul id="short-nav">
+<li><code>import "debug/macho"</code></li>
+<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
+<li><a href="#pkg-index" class="indexLink">Index</a></li>
+</ul> <h2 id="pkg-overview">Overview </h2> <p>Package macho implements access to Mach-O object files. </p>
+<h3 id="hdr-Security">Security</h3> <p>This package is not designed to be hardened against adversarial inputs, and is outside the scope of <a href="https://go.dev/security/policy">https://go.dev/security/policy</a>. In particular, only basic validation is done when parsing object files. As such, care should be taken when parsing untrusted inputs, as parsing malformed files may consume significant resources, or cause panics. </p> <h2 id="pkg-index">Index </h2> <ul id="manual-nav">
+<li><a href="#pkg-constants">Constants</a></li>
+<li><a href="#pkg-variables">Variables</a></li>
+<li><a href="#Cpu">type Cpu</a></li>
+<li> <a href="#Cpu.GoString">func (i Cpu) GoString() string</a>
+</li>
+<li> <a href="#Cpu.String">func (i Cpu) String() string</a>
+</li>
+<li><a href="#Dylib">type Dylib</a></li>
+<li><a href="#DylibCmd">type DylibCmd</a></li>
+<li><a href="#Dysymtab">type Dysymtab</a></li>
+<li><a href="#DysymtabCmd">type DysymtabCmd</a></li>
+<li><a href="#FatArch">type FatArch</a></li>
+<li><a href="#FatArchHeader">type FatArchHeader</a></li>
+<li><a href="#FatFile">type FatFile</a></li>
+<li> <a href="#NewFatFile">func NewFatFile(r io.ReaderAt) (*FatFile, error)</a>
+</li>
+<li> <a href="#OpenFat">func OpenFat(name string) (*FatFile, error)</a>
+</li>
+<li> <a href="#FatFile.Close">func (ff *FatFile) Close() error</a>
+</li>
+<li><a href="#File">type File</a></li>
+<li> <a href="#NewFile">func NewFile(r io.ReaderAt) (*File, error)</a>
+</li>
+<li> <a href="#Open">func Open(name string) (*File, error)</a>
+</li>
+<li> <a href="#File.Close">func (f *File) Close() error</a>
+</li>
+<li> <a href="#File.DWARF">func (f *File) DWARF() (*dwarf.Data, error)</a>
+</li>
+<li> <a href="#File.ImportedLibraries">func (f *File) ImportedLibraries() ([]string, error)</a>
+</li>
+<li> <a href="#File.ImportedSymbols">func (f *File) ImportedSymbols() ([]string, error)</a>
+</li>
+<li> <a href="#File.Section">func (f *File) Section(name string) *Section</a>
+</li>
+<li> <a href="#File.Segment">func (f *File) Segment(name string) *Segment</a>
+</li>
+<li><a href="#FileHeader">type FileHeader</a></li>
+<li><a href="#FormatError">type FormatError</a></li>
+<li> <a href="#FormatError.Error">func (e *FormatError) Error() string</a>
+</li>
+<li><a href="#Load">type Load</a></li>
+<li><a href="#LoadBytes">type LoadBytes</a></li>
+<li> <a href="#LoadBytes.Raw">func (b LoadBytes) Raw() []byte</a>
+</li>
+<li><a href="#LoadCmd">type LoadCmd</a></li>
+<li> <a href="#LoadCmd.GoString">func (i LoadCmd) GoString() string</a>
+</li>
+<li> <a href="#LoadCmd.String">func (i LoadCmd) String() string</a>
+</li>
+<li><a href="#Nlist32">type Nlist32</a></li>
+<li><a href="#Nlist64">type Nlist64</a></li>
+<li><a href="#Regs386">type Regs386</a></li>
+<li><a href="#RegsAMD64">type RegsAMD64</a></li>
+<li><a href="#Reloc">type Reloc</a></li>
+<li><a href="#RelocTypeARM">type RelocTypeARM</a></li>
+<li> <a href="#RelocTypeARM.GoString">func (r RelocTypeARM) GoString() string</a>
+</li>
+<li> <a href="#RelocTypeARM.String">func (i RelocTypeARM) String() string</a>
+</li>
+<li><a href="#RelocTypeARM64">type RelocTypeARM64</a></li>
+<li> <a href="#RelocTypeARM64.GoString">func (r RelocTypeARM64) GoString() string</a>
+</li>
+<li> <a href="#RelocTypeARM64.String">func (i RelocTypeARM64) String() string</a>
+</li>
+<li><a href="#RelocTypeGeneric">type RelocTypeGeneric</a></li>
+<li> <a href="#RelocTypeGeneric.GoString">func (r RelocTypeGeneric) GoString() string</a>
+</li>
+<li> <a href="#RelocTypeGeneric.String">func (i RelocTypeGeneric) String() string</a>
+</li>
+<li><a href="#RelocTypeX86_64">type RelocTypeX86_64</a></li>
+<li> <a href="#RelocTypeX86_64.GoString">func (r RelocTypeX86_64) GoString() string</a>
+</li>
+<li> <a href="#RelocTypeX86_64.String">func (i RelocTypeX86_64) String() string</a>
+</li>
+<li><a href="#Rpath">type Rpath</a></li>
+<li><a href="#RpathCmd">type RpathCmd</a></li>
+<li><a href="#Section">type Section</a></li>
+<li> <a href="#Section.Data">func (s *Section) Data() ([]byte, error)</a>
+</li>
+<li> <a href="#Section.Open">func (s *Section) Open() io.ReadSeeker</a>
+</li>
+<li><a href="#Section32">type Section32</a></li>
+<li><a href="#Section64">type Section64</a></li>
+<li><a href="#SectionHeader">type SectionHeader</a></li>
+<li><a href="#Segment">type Segment</a></li>
+<li> <a href="#Segment.Data">func (s *Segment) Data() ([]byte, error)</a>
+</li>
+<li> <a href="#Segment.Open">func (s *Segment) Open() io.ReadSeeker</a>
+</li>
+<li><a href="#Segment32">type Segment32</a></li>
+<li><a href="#Segment64">type Segment64</a></li>
+<li><a href="#SegmentHeader">type SegmentHeader</a></li>
+<li><a href="#Symbol">type Symbol</a></li>
+<li><a href="#Symtab">type Symtab</a></li>
+<li><a href="#SymtabCmd">type SymtabCmd</a></li>
+<li><a href="#Thread">type Thread</a></li>
+<li><a href="#Type">type Type</a></li>
+<li> <a href="#Type.GoString">func (t Type) GoString() string</a>
+</li>
+<li> <a href="#Type.String">func (t Type) String() string</a>
+</li>
+</ul> <h3>Package files</h3> <p> <span>fat.go</span> <span>file.go</span> <span>macho.go</span> <span>reloctype.go</span> <span>reloctype_string.go</span> </p> <h2 id="pkg-constants">Constants</h2> <pre data-language="go">const (
+ Magic32 uint32 = 0xfeedface
+ Magic64 uint32 = 0xfeedfacf
+ MagicFat uint32 = 0xcafebabe
+)</pre> <pre data-language="go">const (
+ FlagNoUndefs uint32 = 0x1
+ FlagIncrLink uint32 = 0x2
+ FlagDyldLink uint32 = 0x4
+ FlagBindAtLoad uint32 = 0x8
+ FlagPrebound uint32 = 0x10
+ FlagSplitSegs uint32 = 0x20
+ FlagLazyInit uint32 = 0x40
+ FlagTwoLevel uint32 = 0x80
+ FlagForceFlat uint32 = 0x100
+ FlagNoMultiDefs uint32 = 0x200
+ FlagNoFixPrebinding uint32 = 0x400
+ FlagPrebindable uint32 = 0x800
+ FlagAllModsBound uint32 = 0x1000
+ FlagSubsectionsViaSymbols uint32 = 0x2000
+ FlagCanonical uint32 = 0x4000
+ FlagWeakDefines uint32 = 0x8000
+ FlagBindsToWeak uint32 = 0x10000
+ FlagAllowStackExecution uint32 = 0x20000
+ FlagRootSafe uint32 = 0x40000
+ FlagSetuidSafe uint32 = 0x80000
+ FlagNoReexportedDylibs uint32 = 0x100000
+ FlagPIE uint32 = 0x200000
+ FlagDeadStrippableDylib uint32 = 0x400000
+ FlagHasTLVDescriptors uint32 = 0x800000
+ FlagNoHeapExecution uint32 = 0x1000000
+ FlagAppExtensionSafe uint32 = 0x2000000
+)</pre> <h2 id="pkg-variables">Variables</h2> <p>ErrNotFat is returned from <a href="#NewFatFile">NewFatFile</a> or <a href="#OpenFat">OpenFat</a> when the file is not a universal binary but may be a thin binary, based on its magic number. </p>
+<pre data-language="go">var ErrNotFat = &amp;FormatError{0, "not a fat Mach-O file", nil}</pre> <h2 id="Cpu">type <span>Cpu</span> </h2> <p>A Cpu is a Mach-O cpu type. </p>
+<pre data-language="go">type Cpu uint32</pre> <pre data-language="go">const (
+ Cpu386 Cpu = 7
+ CpuAmd64 Cpu = Cpu386 | cpuArch64
+ CpuArm Cpu = 12
+ CpuArm64 Cpu = CpuArm | cpuArch64
+ CpuPpc Cpu = 18
+ CpuPpc64 Cpu = CpuPpc | cpuArch64
+)</pre> <h3 id="Cpu.GoString">func (Cpu) <span>GoString</span> </h3> <pre data-language="go">func (i Cpu) GoString() string</pre> <h3 id="Cpu.String">func (Cpu) <span>String</span> </h3> <pre data-language="go">func (i Cpu) String() string</pre> <h2 id="Dylib">type <span>Dylib</span> </h2> <p>A Dylib represents a Mach-O load dynamic library command. </p>
+<pre data-language="go">type Dylib struct {
+ LoadBytes
+ Name string
+ Time uint32
+ CurrentVersion uint32
+ CompatVersion uint32
+}
+</pre> <h2 id="DylibCmd">type <span>DylibCmd</span> </h2> <p>A DylibCmd is a Mach-O load dynamic library command. </p>
+<pre data-language="go">type DylibCmd struct {
+ Cmd LoadCmd
+ Len uint32
+ Name uint32
+ Time uint32
+ CurrentVersion uint32
+ CompatVersion uint32
+}
+</pre> <h2 id="Dysymtab">type <span>Dysymtab</span> </h2> <p>A Dysymtab represents a Mach-O dynamic symbol table command. </p>
+<pre data-language="go">type Dysymtab struct {
+ LoadBytes
+ DysymtabCmd
+ IndirectSyms []uint32 // indices into Symtab.Syms
+}
+</pre> <h2 id="DysymtabCmd">type <span>DysymtabCmd</span> </h2> <p>A DysymtabCmd is a Mach-O dynamic symbol table command. </p>
+<pre data-language="go">type DysymtabCmd struct {
+ Cmd LoadCmd
+ Len uint32
+ Ilocalsym uint32
+ Nlocalsym uint32
+ Iextdefsym uint32
+ Nextdefsym uint32
+ Iundefsym uint32
+ Nundefsym uint32
+ Tocoffset uint32
+ Ntoc uint32
+ Modtaboff uint32
+ Nmodtab uint32
+ Extrefsymoff uint32
+ Nextrefsyms uint32
+ Indirectsymoff uint32
+ Nindirectsyms uint32
+ Extreloff uint32
+ Nextrel uint32
+ Locreloff uint32
+ Nlocrel uint32
+}
+</pre> <h2 id="FatArch">type <span>FatArch</span> <span title="Added in Go 1.3">1.3</span> </h2> <p>A FatArch is a Mach-O File inside a FatFile. </p>
+<pre data-language="go">type FatArch struct {
+ FatArchHeader
+ *File
+}
+</pre> <h2 id="FatArchHeader">type <span>FatArchHeader</span> <span title="Added in Go 1.3">1.3</span> </h2> <p>A FatArchHeader represents a fat header for a specific image architecture. </p>
+<pre data-language="go">type FatArchHeader struct {
+ Cpu Cpu
+ SubCpu uint32
+ Offset uint32
+ Size uint32
+ Align uint32
+}
+</pre> <h2 id="FatFile">type <span>FatFile</span> <span title="Added in Go 1.3">1.3</span> </h2> <p>A FatFile is a Mach-O universal binary that contains at least one architecture. </p>
+<pre data-language="go">type FatFile struct {
+ Magic uint32
+ Arches []FatArch
+ // contains filtered or unexported fields
+}
+</pre> <h3 id="NewFatFile">func <span>NewFatFile</span> <span title="Added in Go 1.3">1.3</span> </h3> <pre data-language="go">func NewFatFile(r io.ReaderAt) (*FatFile, error)</pre> <p>NewFatFile creates a new <a href="#FatFile">FatFile</a> for accessing all the Mach-O images in a universal binary. The Mach-O binary is expected to start at position 0 in the ReaderAt. </p>
+<h3 id="OpenFat">func <span>OpenFat</span> <span title="Added in Go 1.3">1.3</span> </h3> <pre data-language="go">func OpenFat(name string) (*FatFile, error)</pre> <p>OpenFat opens the named file using <span>os.Open</span> and prepares it for use as a Mach-O universal binary. </p>
+<h3 id="FatFile.Close">func (*FatFile) <span>Close</span> <span title="Added in Go 1.3">1.3</span> </h3> <pre data-language="go">func (ff *FatFile) Close() error</pre> <h2 id="File">type <span>File</span> </h2> <p>A File represents an open Mach-O file. </p>
+<pre data-language="go">type File struct {
+ FileHeader
+ ByteOrder binary.ByteOrder
+ Loads []Load
+ Sections []*Section
+
+ Symtab *Symtab
+ Dysymtab *Dysymtab
+ // contains filtered or unexported fields
+}
+</pre> <h3 id="NewFile">func <span>NewFile</span> </h3> <pre data-language="go">func NewFile(r io.ReaderAt) (*File, error)</pre> <p>NewFile creates a new <a href="#File">File</a> for accessing a Mach-O binary in an underlying reader. The Mach-O binary is expected to start at position 0 in the ReaderAt. </p>
+<h3 id="Open">func <span>Open</span> </h3> <pre data-language="go">func Open(name string) (*File, error)</pre> <p>Open opens the named file using <span>os.Open</span> and prepares it for use as a Mach-O binary. </p>
+<h3 id="File.Close">func (*File) <span>Close</span> </h3> <pre data-language="go">func (f *File) Close() error</pre> <p>Close closes the <a href="#File">File</a>. If the <a href="#File">File</a> was created using <a href="#NewFile">NewFile</a> directly instead of <a href="#Open">Open</a>, Close has no effect. </p>
+<h3 id="File.DWARF">func (*File) <span>DWARF</span> </h3> <pre data-language="go">func (f *File) DWARF() (*dwarf.Data, error)</pre> <p>DWARF returns the DWARF debug information for the Mach-O file. </p>
+<h3 id="File.ImportedLibraries">func (*File) <span>ImportedLibraries</span> </h3> <pre data-language="go">func (f *File) ImportedLibraries() ([]string, error)</pre> <p>ImportedLibraries returns the paths of all libraries referred to by the binary f that are expected to be linked with the binary at dynamic link time. </p>
+<h3 id="File.ImportedSymbols">func (*File) <span>ImportedSymbols</span> </h3> <pre data-language="go">func (f *File) ImportedSymbols() ([]string, error)</pre> <p>ImportedSymbols returns the names of all symbols referred to by the binary f that are expected to be satisfied by other libraries at dynamic load time. </p>
+<h3 id="File.Section">func (*File) <span>Section</span> </h3> <pre data-language="go">func (f *File) Section(name string) *Section</pre> <p>Section returns the first section with the given name, or nil if no such section exists. </p>
+<h3 id="File.Segment">func (*File) <span>Segment</span> </h3> <pre data-language="go">func (f *File) Segment(name string) *Segment</pre> <p>Segment returns the first Segment with the given name, or nil if no such segment exists. </p>
+<h2 id="FileHeader">type <span>FileHeader</span> </h2> <p>A FileHeader represents a Mach-O file header. </p>
+<pre data-language="go">type FileHeader struct {
+ Magic uint32
+ Cpu Cpu
+ SubCpu uint32
+ Type Type
+ Ncmd uint32
+ Cmdsz uint32
+ Flags uint32
+}
+</pre> <h2 id="FormatError">type <span>FormatError</span> </h2> <p>FormatError is returned by some operations if the data does not have the correct format for an object file. </p>
+<pre data-language="go">type FormatError struct {
+ // contains filtered or unexported fields
+}
+</pre> <h3 id="FormatError.Error">func (*FormatError) <span>Error</span> </h3> <pre data-language="go">func (e *FormatError) Error() string</pre> <h2 id="Load">type <span>Load</span> </h2> <p>A Load represents any Mach-O load command. </p>
+<pre data-language="go">type Load interface {
+ Raw() []byte
+}</pre> <h2 id="LoadBytes">type <span>LoadBytes</span> </h2> <p>A LoadBytes is the uninterpreted bytes of a Mach-O load command. </p>
+<pre data-language="go">type LoadBytes []byte</pre> <h3 id="LoadBytes.Raw">func (LoadBytes) <span>Raw</span> </h3> <pre data-language="go">func (b LoadBytes) Raw() []byte</pre> <h2 id="LoadCmd">type <span>LoadCmd</span> </h2> <p>A LoadCmd is a Mach-O load command. </p>
+<pre data-language="go">type LoadCmd uint32</pre> <pre data-language="go">const (
+ LoadCmdSegment LoadCmd = 0x1
+ LoadCmdSymtab LoadCmd = 0x2
+ LoadCmdThread LoadCmd = 0x4
+ LoadCmdUnixThread LoadCmd = 0x5 // thread+stack
+ LoadCmdDysymtab LoadCmd = 0xb
+ LoadCmdDylib LoadCmd = 0xc // load dylib command
+ LoadCmdDylinker LoadCmd = 0xf // id dylinker command (not load dylinker command)
+ LoadCmdSegment64 LoadCmd = 0x19
+ LoadCmdRpath LoadCmd = 0x8000001c
+)</pre> <h3 id="LoadCmd.GoString">func (LoadCmd) <span>GoString</span> </h3> <pre data-language="go">func (i LoadCmd) GoString() string</pre> <h3 id="LoadCmd.String">func (LoadCmd) <span>String</span> </h3> <pre data-language="go">func (i LoadCmd) String() string</pre> <h2 id="Nlist32">type <span>Nlist32</span> </h2> <p>An Nlist32 is a Mach-O 32-bit symbol table entry. </p>
+<pre data-language="go">type Nlist32 struct {
+ Name uint32
+ Type uint8
+ Sect uint8
+ Desc uint16
+ Value uint32
+}
+</pre> <h2 id="Nlist64">type <span>Nlist64</span> </h2> <p>An Nlist64 is a Mach-O 64-bit symbol table entry. </p>
+<pre data-language="go">type Nlist64 struct {
+ Name uint32
+ Type uint8
+ Sect uint8
+ Desc uint16
+ Value uint64
+}
+</pre> <h2 id="Regs386">type <span>Regs386</span> </h2> <p>Regs386 is the Mach-O 386 register structure. </p>
+<pre data-language="go">type Regs386 struct {
+ AX uint32
+ BX uint32
+ CX uint32
+ DX uint32
+ DI uint32
+ SI uint32
+ BP uint32
+ SP uint32
+ SS uint32
+ FLAGS uint32
+ IP uint32
+ CS uint32
+ DS uint32
+ ES uint32
+ FS uint32
+ GS uint32
+}
+</pre> <h2 id="RegsAMD64">type <span>RegsAMD64</span> </h2> <p>RegsAMD64 is the Mach-O AMD64 register structure. </p>
+<pre data-language="go">type RegsAMD64 struct {
+ AX uint64
+ BX uint64
+ CX uint64
+ DX uint64
+ DI uint64
+ SI uint64
+ BP uint64
+ SP uint64
+ R8 uint64
+ R9 uint64
+ R10 uint64
+ R11 uint64
+ R12 uint64
+ R13 uint64
+ R14 uint64
+ R15 uint64
+ IP uint64
+ FLAGS uint64
+ CS uint64
+ FS uint64
+ GS uint64
+}
+</pre> <h2 id="Reloc">type <span>Reloc</span> <span title="Added in Go 1.10">1.10</span> </h2> <p>A Reloc represents a Mach-O relocation. </p>
+<pre data-language="go">type Reloc struct {
+ Addr uint32
+ Value uint32
+ // when Scattered == false &amp;&amp; Extern == true, Value is the symbol number.
+ // when Scattered == false &amp;&amp; Extern == false, Value is the section number.
+ // when Scattered == true, Value is the value that this reloc refers to.
+ Type uint8
+ Len uint8 // 0=byte, 1=word, 2=long, 3=quad
+ Pcrel bool
+ Extern bool // valid if Scattered == false
+ Scattered bool
+}
+</pre> <h2 id="RelocTypeARM">type <span>RelocTypeARM</span> <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">type RelocTypeARM int</pre> <pre data-language="go">const (
+ ARM_RELOC_VANILLA RelocTypeARM = 0
+ ARM_RELOC_PAIR RelocTypeARM = 1
+ ARM_RELOC_SECTDIFF RelocTypeARM = 2
+ ARM_RELOC_LOCAL_SECTDIFF RelocTypeARM = 3
+ ARM_RELOC_PB_LA_PTR RelocTypeARM = 4
+ ARM_RELOC_BR24 RelocTypeARM = 5
+ ARM_THUMB_RELOC_BR22 RelocTypeARM = 6
+ ARM_THUMB_32BIT_BRANCH RelocTypeARM = 7
+ ARM_RELOC_HALF RelocTypeARM = 8
+ ARM_RELOC_HALF_SECTDIFF RelocTypeARM = 9
+)</pre> <h3 id="RelocTypeARM.GoString">func (RelocTypeARM) <span>GoString</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (r RelocTypeARM) GoString() string</pre> <h3 id="RelocTypeARM.String">func (RelocTypeARM) <span>String</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (i RelocTypeARM) String() string</pre> <h2 id="RelocTypeARM64">type <span>RelocTypeARM64</span> <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">type RelocTypeARM64 int</pre> <pre data-language="go">const (
+ ARM64_RELOC_UNSIGNED RelocTypeARM64 = 0
+ ARM64_RELOC_SUBTRACTOR RelocTypeARM64 = 1
+ ARM64_RELOC_BRANCH26 RelocTypeARM64 = 2
+ ARM64_RELOC_PAGE21 RelocTypeARM64 = 3
+ ARM64_RELOC_PAGEOFF12 RelocTypeARM64 = 4
+ ARM64_RELOC_GOT_LOAD_PAGE21 RelocTypeARM64 = 5
+ ARM64_RELOC_GOT_LOAD_PAGEOFF12 RelocTypeARM64 = 6
+ ARM64_RELOC_POINTER_TO_GOT RelocTypeARM64 = 7
+ ARM64_RELOC_TLVP_LOAD_PAGE21 RelocTypeARM64 = 8
+ ARM64_RELOC_TLVP_LOAD_PAGEOFF12 RelocTypeARM64 = 9
+ ARM64_RELOC_ADDEND RelocTypeARM64 = 10
+)</pre> <h3 id="RelocTypeARM64.GoString">func (RelocTypeARM64) <span>GoString</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (r RelocTypeARM64) GoString() string</pre> <h3 id="RelocTypeARM64.String">func (RelocTypeARM64) <span>String</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (i RelocTypeARM64) String() string</pre> <h2 id="RelocTypeGeneric">type <span>RelocTypeGeneric</span> <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">type RelocTypeGeneric int</pre> <pre data-language="go">const (
+ GENERIC_RELOC_VANILLA RelocTypeGeneric = 0
+ GENERIC_RELOC_PAIR RelocTypeGeneric = 1
+ GENERIC_RELOC_SECTDIFF RelocTypeGeneric = 2
+ GENERIC_RELOC_PB_LA_PTR RelocTypeGeneric = 3
+ GENERIC_RELOC_LOCAL_SECTDIFF RelocTypeGeneric = 4
+ GENERIC_RELOC_TLV RelocTypeGeneric = 5
+)</pre> <h3 id="RelocTypeGeneric.GoString">func (RelocTypeGeneric) <span>GoString</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (r RelocTypeGeneric) GoString() string</pre> <h3 id="RelocTypeGeneric.String">func (RelocTypeGeneric) <span>String</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (i RelocTypeGeneric) String() string</pre> <h2 id="RelocTypeX86_64">type <span>RelocTypeX86_64</span> <span title="Added in Go 1.10">1.10</span> </h2> <pre data-language="go">type RelocTypeX86_64 int</pre> <pre data-language="go">const (
+ X86_64_RELOC_UNSIGNED RelocTypeX86_64 = 0
+ X86_64_RELOC_SIGNED RelocTypeX86_64 = 1
+ X86_64_RELOC_BRANCH RelocTypeX86_64 = 2
+ X86_64_RELOC_GOT_LOAD RelocTypeX86_64 = 3
+ X86_64_RELOC_GOT RelocTypeX86_64 = 4
+ X86_64_RELOC_SUBTRACTOR RelocTypeX86_64 = 5
+ X86_64_RELOC_SIGNED_1 RelocTypeX86_64 = 6
+ X86_64_RELOC_SIGNED_2 RelocTypeX86_64 = 7
+ X86_64_RELOC_SIGNED_4 RelocTypeX86_64 = 8
+ X86_64_RELOC_TLV RelocTypeX86_64 = 9
+)</pre> <h3 id="RelocTypeX86_64.GoString">func (RelocTypeX86_64) <span>GoString</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (r RelocTypeX86_64) GoString() string</pre> <h3 id="RelocTypeX86_64.String">func (RelocTypeX86_64) <span>String</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (i RelocTypeX86_64) String() string</pre> <h2 id="Rpath">type <span>Rpath</span> <span title="Added in Go 1.10">1.10</span> </h2> <p>A Rpath represents a Mach-O rpath command. </p>
+<pre data-language="go">type Rpath struct {
+ LoadBytes
+ Path string
+}
+</pre> <h2 id="RpathCmd">type <span>RpathCmd</span> <span title="Added in Go 1.10">1.10</span> </h2> <p>A RpathCmd is a Mach-O rpath command. </p>
+<pre data-language="go">type RpathCmd struct {
+ Cmd LoadCmd
+ Len uint32
+ Path uint32
+}
+</pre> <h2 id="Section">type <span>Section</span> </h2> <pre data-language="go">type Section struct {
+ SectionHeader
+ Relocs []Reloc // Go 1.10
+
+ // Embed ReaderAt for ReadAt method.
+ // Do not embed SectionReader directly
+ // to avoid having Read and Seek.
+ // If a client wants Read and Seek it must use
+ // Open() to avoid fighting over the seek offset
+ // with other clients.
+ io.ReaderAt
+ // contains filtered or unexported fields
+}
+</pre> <h3 id="Section.Data">func (*Section) <span>Data</span> </h3> <pre data-language="go">func (s *Section) Data() ([]byte, error)</pre> <p>Data reads and returns the contents of the Mach-O section. </p>
+<h3 id="Section.Open">func (*Section) <span>Open</span> </h3> <pre data-language="go">func (s *Section) Open() io.ReadSeeker</pre> <p>Open returns a new ReadSeeker reading the Mach-O section. </p>
+<h2 id="Section32">type <span>Section32</span> </h2> <p>A Section32 is a 32-bit Mach-O section header. </p>
+<pre data-language="go">type Section32 struct {
+ Name [16]byte
+ Seg [16]byte
+ Addr uint32
+ Size uint32
+ Offset uint32
+ Align uint32
+ Reloff uint32
+ Nreloc uint32
+ Flags uint32
+ Reserve1 uint32
+ Reserve2 uint32
+}
+</pre> <h2 id="Section64">type <span>Section64</span> </h2> <p>A Section64 is a 64-bit Mach-O section header. </p>
+<pre data-language="go">type Section64 struct {
+ Name [16]byte
+ Seg [16]byte
+ Addr uint64
+ Size uint64
+ Offset uint32
+ Align uint32
+ Reloff uint32
+ Nreloc uint32
+ Flags uint32
+ Reserve1 uint32
+ Reserve2 uint32
+ Reserve3 uint32
+}
+</pre> <h2 id="SectionHeader">type <span>SectionHeader</span> </h2> <pre data-language="go">type SectionHeader struct {
+ Name string
+ Seg string
+ Addr uint64
+ Size uint64
+ Offset uint32
+ Align uint32
+ Reloff uint32
+ Nreloc uint32
+ Flags uint32
+}
+</pre> <h2 id="Segment">type <span>Segment</span> </h2> <p>A Segment represents a Mach-O 32-bit or 64-bit load segment command. </p>
+<pre data-language="go">type Segment struct {
+ LoadBytes
+ SegmentHeader
+
+ // Embed ReaderAt for ReadAt method.
+ // Do not embed SectionReader directly
+ // to avoid having Read and Seek.
+ // If a client wants Read and Seek it must use
+ // Open() to avoid fighting over the seek offset
+ // with other clients.
+ io.ReaderAt
+ // contains filtered or unexported fields
+}
+</pre> <h3 id="Segment.Data">func (*Segment) <span>Data</span> </h3> <pre data-language="go">func (s *Segment) Data() ([]byte, error)</pre> <p>Data reads and returns the contents of the segment. </p>
+<h3 id="Segment.Open">func (*Segment) <span>Open</span> </h3> <pre data-language="go">func (s *Segment) Open() io.ReadSeeker</pre> <p>Open returns a new ReadSeeker reading the segment. </p>
+<h2 id="Segment32">type <span>Segment32</span> </h2> <p>A Segment32 is a 32-bit Mach-O segment load command. </p>
+<pre data-language="go">type Segment32 struct {
+ Cmd LoadCmd
+ Len uint32
+ Name [16]byte
+ Addr uint32
+ Memsz uint32
+ Offset uint32
+ Filesz uint32
+ Maxprot uint32
+ Prot uint32
+ Nsect uint32
+ Flag uint32
+}
+</pre> <h2 id="Segment64">type <span>Segment64</span> </h2> <p>A Segment64 is a 64-bit Mach-O segment load command. </p>
+<pre data-language="go">type Segment64 struct {
+ Cmd LoadCmd
+ Len uint32
+ Name [16]byte
+ Addr uint64
+ Memsz uint64
+ Offset uint64
+ Filesz uint64
+ Maxprot uint32
+ Prot uint32
+ Nsect uint32
+ Flag uint32
+}
+</pre> <h2 id="SegmentHeader">type <span>SegmentHeader</span> </h2> <p>A SegmentHeader is the header for a Mach-O 32-bit or 64-bit load segment command. </p>
+<pre data-language="go">type SegmentHeader struct {
+ Cmd LoadCmd
+ Len uint32
+ Name string
+ Addr uint64
+ Memsz uint64
+ Offset uint64
+ Filesz uint64
+ Maxprot uint32
+ Prot uint32
+ Nsect uint32
+ Flag uint32
+}
+</pre> <h2 id="Symbol">type <span>Symbol</span> </h2> <p>A Symbol is a Mach-O 32-bit or 64-bit symbol table entry. </p>
+<pre data-language="go">type Symbol struct {
+ Name string
+ Type uint8
+ Sect uint8
+ Desc uint16
+ Value uint64
+}
+</pre> <h2 id="Symtab">type <span>Symtab</span> </h2> <p>A Symtab represents a Mach-O symbol table command. </p>
+<pre data-language="go">type Symtab struct {
+ LoadBytes
+ SymtabCmd
+ Syms []Symbol
+}
+</pre> <h2 id="SymtabCmd">type <span>SymtabCmd</span> </h2> <p>A SymtabCmd is a Mach-O symbol table command. </p>
+<pre data-language="go">type SymtabCmd struct {
+ Cmd LoadCmd
+ Len uint32
+ Symoff uint32
+ Nsyms uint32
+ Stroff uint32
+ Strsize uint32
+}
+</pre> <h2 id="Thread">type <span>Thread</span> </h2> <p>A Thread is a Mach-O thread state command. </p>
+<pre data-language="go">type Thread struct {
+ Cmd LoadCmd
+ Len uint32
+ Type uint32
+ Data []uint32
+}
+</pre> <h2 id="Type">type <span>Type</span> </h2> <p>A Type is the Mach-O file type, e.g. an object file, executable, or dynamic library. </p>
+<pre data-language="go">type Type uint32</pre> <pre data-language="go">const (
+ TypeObj Type = 1
+ TypeExec Type = 2
+ TypeDylib Type = 6
+ TypeBundle Type = 8
+)</pre> <h3 id="Type.GoString">func (Type) <span>GoString</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (t Type) GoString() string</pre> <h3 id="Type.String">func (Type) <span>String</span> <span title="Added in Go 1.10">1.10</span> </h3> <pre data-language="go">func (t Type) String() string</pre><div class="_attribution">
+ <p class="_attribution-p">
+ &copy; Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
+ <a href="http://golang.org/pkg/debug/macho/" class="_attribution-link">http://golang.org/pkg/debug/macho/</a>
+ </p>
+</div>
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-27 01:45:50 +0000