Source file src/debug/macho/macho.go

Documentation: debug/macho

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Mach-O header data structures
     6  // Originally at:
     7  // http://developer.apple.com/mac/library/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html (since deleted by Apply)
     8  // Archived copy at:
     9  // https://web.archive.org/web/20090819232456/http://developer.apple.com/documentation/DeveloperTools/Conceptual/MachORuntime/index.html
    10  // For cloned PDF see:
    11  // https://github.com/aidansteele/osx-abi-macho-file-format-reference
    12  
    13  package macho
    14  
    15  import "strconv"
    16  
    17  // A FileHeader represents a Mach-O file header.
    18  type FileHeader struct {
    19  	Magic  uint32
    20  	Cpu    Cpu
    21  	SubCpu uint32
    22  	Type   Type
    23  	Ncmd   uint32
    24  	Cmdsz  uint32
    25  	Flags  uint32
    26  }
    27  
    28  const (
    29  	fileHeaderSize32 = 7 * 4
    30  	fileHeaderSize64 = 8 * 4
    31  )
    32  
    33  const (
    34  	Magic32  uint32 = 0xfeedface
    35  	Magic64  uint32 = 0xfeedfacf
    36  	MagicFat uint32 = 0xcafebabe
    37  )
    38  
    39  // A Type is the Mach-O file type, e.g. an object file, executable, or dynamic library.
    40  type Type uint32
    41  
    42  const (
    43  	TypeObj    Type = 1
    44  	TypeExec   Type = 2
    45  	TypeDylib  Type = 6
    46  	TypeBundle Type = 8
    47  )
    48  
    49  var typeStrings = []intName{
    50  	{uint32(TypeObj), "Obj"},
    51  	{uint32(TypeExec), "Exec"},
    52  	{uint32(TypeDylib), "Dylib"},
    53  	{uint32(TypeBundle), "Bundle"},
    54  }
    55  
    56  func (t Type) String() string   { return stringName(uint32(t), typeStrings, false) }
    57  func (t Type) GoString() string { return stringName(uint32(t), typeStrings, true) }
    58  
    59  // A Cpu is a Mach-O cpu type.
    60  type Cpu uint32
    61  
    62  const cpuArch64 = 0x01000000
    63  
    64  const (
    65  	Cpu386   Cpu = 7
    66  	CpuAmd64 Cpu = Cpu386 | cpuArch64
    67  	CpuArm   Cpu = 12
    68  	CpuArm64 Cpu = CpuArm | cpuArch64
    69  	CpuPpc   Cpu = 18
    70  	CpuPpc64 Cpu = CpuPpc | cpuArch64
    71  )
    72  
    73  var cpuStrings = []intName{
    74  	{uint32(Cpu386), "Cpu386"},
    75  	{uint32(CpuAmd64), "CpuAmd64"},
    76  	{uint32(CpuArm), "CpuArm"},
    77  	{uint32(CpuArm64), "CpuArm64"},
    78  	{uint32(CpuPpc), "CpuPpc"},
    79  	{uint32(CpuPpc64), "CpuPpc64"},
    80  }
    81  
    82  func (i Cpu) String() string   { return stringName(uint32(i), cpuStrings, false) }
    83  func (i Cpu) GoString() string { return stringName(uint32(i), cpuStrings, true) }
    84  
    85  // A LoadCmd is a Mach-O load command.
    86  type LoadCmd uint32
    87  
    88  const (
    89  	LoadCmdSegment    LoadCmd = 0x1
    90  	LoadCmdSymtab     LoadCmd = 0x2
    91  	LoadCmdThread     LoadCmd = 0x4
    92  	LoadCmdUnixThread LoadCmd = 0x5 // thread+stack
    93  	LoadCmdDysymtab   LoadCmd = 0xb
    94  	LoadCmdDylib      LoadCmd = 0xc // load dylib command
    95  	LoadCmdDylinker   LoadCmd = 0xf // id dylinker command (not load dylinker command)
    96  	LoadCmdSegment64  LoadCmd = 0x19
    97  	LoadCmdRpath      LoadCmd = 0x8000001c
    98  )
    99  
   100  var cmdStrings = []intName{
   101  	{uint32(LoadCmdSegment), "LoadCmdSegment"},
   102  	{uint32(LoadCmdThread), "LoadCmdThread"},
   103  	{uint32(LoadCmdUnixThread), "LoadCmdUnixThread"},
   104  	{uint32(LoadCmdDylib), "LoadCmdDylib"},
   105  	{uint32(LoadCmdSegment64), "LoadCmdSegment64"},
   106  	{uint32(LoadCmdRpath), "LoadCmdRpath"},
   107  }
   108  
   109  func (i LoadCmd) String() string   { return stringName(uint32(i), cmdStrings, false) }
   110  func (i LoadCmd) GoString() string { return stringName(uint32(i), cmdStrings, true) }
   111  
   112  type (
   113  	// A Segment32 is a 32-bit Mach-O segment load command.
   114  	Segment32 struct {
   115  		Cmd     LoadCmd
   116  		Len     uint32
   117  		Name    [16]byte
   118  		Addr    uint32
   119  		Memsz   uint32
   120  		Offset  uint32
   121  		Filesz  uint32
   122  		Maxprot uint32
   123  		Prot    uint32
   124  		Nsect   uint32
   125  		Flag    uint32
   126  	}
   127  
   128  	// A Segment64 is a 64-bit Mach-O segment load command.
   129  	Segment64 struct {
   130  		Cmd     LoadCmd
   131  		Len     uint32
   132  		Name    [16]byte
   133  		Addr    uint64
   134  		Memsz   uint64
   135  		Offset  uint64
   136  		Filesz  uint64
   137  		Maxprot uint32
   138  		Prot    uint32
   139  		Nsect   uint32
   140  		Flag    uint32
   141  	}
   142  
   143  	// A SymtabCmd is a Mach-O symbol table command.
   144  	SymtabCmd struct {
   145  		Cmd     LoadCmd
   146  		Len     uint32
   147  		Symoff  uint32
   148  		Nsyms   uint32
   149  		Stroff  uint32
   150  		Strsize uint32
   151  	}
   152  
   153  	// A DysymtabCmd is a Mach-O dynamic symbol table command.
   154  	DysymtabCmd struct {
   155  		Cmd            LoadCmd
   156  		Len            uint32
   157  		Ilocalsym      uint32
   158  		Nlocalsym      uint32
   159  		Iextdefsym     uint32
   160  		Nextdefsym     uint32
   161  		Iundefsym      uint32
   162  		Nundefsym      uint32
   163  		Tocoffset      uint32
   164  		Ntoc           uint32
   165  		Modtaboff      uint32
   166  		Nmodtab        uint32
   167  		Extrefsymoff   uint32
   168  		Nextrefsyms    uint32
   169  		Indirectsymoff uint32
   170  		Nindirectsyms  uint32
   171  		Extreloff      uint32
   172  		Nextrel        uint32
   173  		Locreloff      uint32
   174  		Nlocrel        uint32
   175  	}
   176  
   177  	// A DylibCmd is a Mach-O load dynamic library command.
   178  	DylibCmd struct {
   179  		Cmd            LoadCmd
   180  		Len            uint32
   181  		Name           uint32
   182  		Time           uint32
   183  		CurrentVersion uint32
   184  		CompatVersion  uint32
   185  	}
   186  
   187  	// A RpathCmd is a Mach-O rpath command.
   188  	RpathCmd struct {
   189  		Cmd  LoadCmd
   190  		Len  uint32
   191  		Path uint32
   192  	}
   193  
   194  	// A Thread is a Mach-O thread state command.
   195  	Thread struct {
   196  		Cmd  LoadCmd
   197  		Len  uint32
   198  		Type uint32
   199  		Data []uint32
   200  	}
   201  )
   202  
   203  const (
   204  	FlagNoUndefs              uint32 = 0x1
   205  	FlagIncrLink              uint32 = 0x2
   206  	FlagDyldLink              uint32 = 0x4
   207  	FlagBindAtLoad            uint32 = 0x8
   208  	FlagPrebound              uint32 = 0x10
   209  	FlagSplitSegs             uint32 = 0x20
   210  	FlagLazyInit              uint32 = 0x40
   211  	FlagTwoLevel              uint32 = 0x80
   212  	FlagForceFlat             uint32 = 0x100
   213  	FlagNoMultiDefs           uint32 = 0x200
   214  	FlagNoFixPrebinding       uint32 = 0x400
   215  	FlagPrebindable           uint32 = 0x800
   216  	FlagAllModsBound          uint32 = 0x1000
   217  	FlagSubsectionsViaSymbols uint32 = 0x2000
   218  	FlagCanonical             uint32 = 0x4000
   219  	FlagWeakDefines           uint32 = 0x8000
   220  	FlagBindsToWeak           uint32 = 0x10000
   221  	FlagAllowStackExecution   uint32 = 0x20000
   222  	FlagRootSafe              uint32 = 0x40000
   223  	FlagSetuidSafe            uint32 = 0x80000
   224  	FlagNoReexportedDylibs    uint32 = 0x100000
   225  	FlagPIE                   uint32 = 0x200000
   226  	FlagDeadStrippableDylib   uint32 = 0x400000
   227  	FlagHasTLVDescriptors     uint32 = 0x800000
   228  	FlagNoHeapExecution       uint32 = 0x1000000
   229  	FlagAppExtensionSafe      uint32 = 0x2000000
   230  )
   231  
   232  // A Section32 is a 32-bit Mach-O section header.
   233  type Section32 struct {
   234  	Name     [16]byte
   235  	Seg      [16]byte
   236  	Addr     uint32
   237  	Size     uint32
   238  	Offset   uint32
   239  	Align    uint32
   240  	Reloff   uint32
   241  	Nreloc   uint32
   242  	Flags    uint32
   243  	Reserve1 uint32
   244  	Reserve2 uint32
   245  }
   246  
   247  // A Section64 is a 64-bit Mach-O section header.
   248  type Section64 struct {
   249  	Name     [16]byte
   250  	Seg      [16]byte
   251  	Addr     uint64
   252  	Size     uint64
   253  	Offset   uint32
   254  	Align    uint32
   255  	Reloff   uint32
   256  	Nreloc   uint32
   257  	Flags    uint32
   258  	Reserve1 uint32
   259  	Reserve2 uint32
   260  	Reserve3 uint32
   261  }
   262  
   263  // An Nlist32 is a Mach-O 32-bit symbol table entry.
   264  type Nlist32 struct {
   265  	Name  uint32
   266  	Type  uint8
   267  	Sect  uint8
   268  	Desc  uint16
   269  	Value uint32
   270  }
   271  
   272  // An Nlist64 is a Mach-O 64-bit symbol table entry.
   273  type Nlist64 struct {
   274  	Name  uint32
   275  	Type  uint8
   276  	Sect  uint8
   277  	Desc  uint16
   278  	Value uint64
   279  }
   280  
   281  // Regs386 is the Mach-O 386 register structure.
   282  type Regs386 struct {
   283  	AX    uint32
   284  	BX    uint32
   285  	CX    uint32
   286  	DX    uint32
   287  	DI    uint32
   288  	SI    uint32
   289  	BP    uint32
   290  	SP    uint32
   291  	SS    uint32
   292  	FLAGS uint32
   293  	IP    uint32
   294  	CS    uint32
   295  	DS    uint32
   296  	ES    uint32
   297  	FS    uint32
   298  	GS    uint32
   299  }
   300  
   301  // RegsAMD64 is the Mach-O AMD64 register structure.
   302  type RegsAMD64 struct {
   303  	AX    uint64
   304  	BX    uint64
   305  	CX    uint64
   306  	DX    uint64
   307  	DI    uint64
   308  	SI    uint64
   309  	BP    uint64
   310  	SP    uint64
   311  	R8    uint64
   312  	R9    uint64
   313  	R10   uint64
   314  	R11   uint64
   315  	R12   uint64
   316  	R13   uint64
   317  	R14   uint64
   318  	R15   uint64
   319  	IP    uint64
   320  	FLAGS uint64
   321  	CS    uint64
   322  	FS    uint64
   323  	GS    uint64
   324  }
   325  
   326  type intName struct {
   327  	i uint32
   328  	s string
   329  }
   330  
   331  func stringName(i uint32, names []intName, goSyntax bool) string {
   332  	for _, n := range names {
   333  		if n.i == i {
   334  			if goSyntax {
   335  				return "macho." + n.s
   336  			}
   337  			return n.s
   338  		}
   339  	}
   340  	return strconv.FormatUint(uint64(i), 10)
   341  }
   342  

View as plain text