// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package macho implements access to Mach-O object files. package macho // High level access to low level data structures. import ( "bytes" "debug/dwarf" "encoding/binary" "fmt" "io" "os" ) // A File represents an open Mach-O file. type File struct { FileHeader ByteOrder binary.ByteOrder Loads []Load Sections []*Section Symtab *Symtab Dysymtab *Dysymtab closer io.Closer } // A Load represents any Mach-O load command. type Load interface { Raw() []byte } // A LoadBytes is the uninterpreted bytes of a Mach-O load command. type LoadBytes []byte func (b LoadBytes) Raw() []byte { return b } // A SegmentHeader is the header for a Mach-O 32-bit or 64-bit load segment command. 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 } // A Segment represents a Mach-O 32-bit or 64-bit load segment command. 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 sr *io.SectionReader } // Data reads and returns the contents of the segment. func (s *Segment) Data() ([]byte, error) { dat := make([]byte, s.sr.Size()) n, err := s.sr.ReadAt(dat, 0) if n == len(dat) { err = nil } return dat[0:n], err } // Open returns a new ReadSeeker reading the segment. func (s *Segment) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } type SectionHeader struct { Name string Seg string Addr uint64 Size uint64 Offset uint32 Align uint32 Reloff uint32 Nreloc uint32 Flags uint32 } // A Reloc represents a Mach-O relocation. type Reloc struct { Addr uint32 Value uint32 // when Scattered == false && Extern == true, Value is the symbol number. // when Scattered == false && 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 } type Section struct { SectionHeader Relocs []Reloc // 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 sr *io.SectionReader } // Data reads and returns the contents of the Mach-O section. func (s *Section) Data() ([]byte, error) { dat := make([]byte, s.sr.Size()) n, err := s.sr.ReadAt(dat, 0) if n == len(dat) { err = nil } return dat[0:n], err } // Open returns a new ReadSeeker reading the Mach-O section. func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } // A Dylib represents a Mach-O load dynamic library command. type Dylib struct { LoadBytes Name string Time uint32 CurrentVersion uint32 CompatVersion uint32 } // A Symtab represents a Mach-O symbol table command. type Symtab struct { LoadBytes SymtabCmd Syms []Symbol } // A Dysymtab represents a Mach-O dynamic symbol table command. type Dysymtab struct { LoadBytes DysymtabCmd IndirectSyms []uint32 // indices into Symtab.Syms } // A Rpath represents a Mach-O rpath command. type Rpath struct { LoadBytes Path string } // A Symbol is a Mach-O 32-bit or 64-bit symbol table entry. type Symbol struct { Name string Type uint8 Sect uint8 Desc uint16 Value uint64 } /* * Mach-O reader */ // FormatError is returned by some operations if the data does // not have the correct format for an object file. type FormatError struct { off int64 msg string val interface{} } func (e *FormatError) Error() string { msg := e.msg if e.val != nil { msg += fmt.Sprintf(" '%v'", e.val) } msg += fmt.Sprintf(" in record at byte %#x", e.off) return msg } // Open opens the named file using os.Open and prepares it for use as a Mach-O binary. func Open(name string) (*File, error) { f, err := os.Open(name) if err != nil { return nil, err } ff, err := NewFile(f) if err != nil { f.Close() return nil, err } ff.closer = f return ff, nil } // Close closes the File. // If the File was created using NewFile directly instead of Open, // Close has no effect. func (f *File) Close() error { var err error if f.closer != nil { err = f.closer.Close() f.closer = nil } return err } // NewFile creates a new File for accessing a Mach-O binary in an underlying reader. // The Mach-O binary is expected to start at position 0 in the ReaderAt. func NewFile(r io.ReaderAt) (*File, error) { f := new(File) sr := io.NewSectionReader(r, 0, 1<<63-1) // Read and decode Mach magic to determine byte order, size. // Magic32 and Magic64 differ only in the bottom bit. var ident [4]byte if _, err := r.ReadAt(ident[0:], 0); err != nil { return nil, err } be := binary.BigEndian.Uint32(ident[0:]) le := binary.LittleEndian.Uint32(ident[0:]) switch Magic32 &^ 1 { case be &^ 1: f.ByteOrder = binary.BigEndian f.Magic = be case le &^ 1: f.ByteOrder = binary.LittleEndian f.Magic = le default: return nil, &FormatError{0, "invalid magic number", nil} } // Read entire file header. if err := binary.Read(sr, f.ByteOrder, &f.FileHeader); err != nil { return nil, err } // Then load commands. offset := int64(fileHeaderSize32) if f.Magic == Magic64 { offset = fileHeaderSize64 } dat := make([]byte, f.Cmdsz) if _, err := r.ReadAt(dat, offset); err != nil { return nil, err } f.Loads = make([]Load, f.Ncmd) bo := f.ByteOrder for i := range f.Loads { // Each load command begins with uint32 command and length. if len(dat) < 8 { return nil, &FormatError{offset, "command block too small", nil} } cmd, siz := LoadCmd(bo.Uint32(dat[0:4])), bo.Uint32(dat[4:8]) if siz < 8 || siz > uint32(len(dat)) { return nil, &FormatError{offset, "invalid command block size", nil} } var cmddat []byte cmddat, dat = dat[0:siz], dat[siz:] offset += int64(siz) var s *Segment switch cmd { default: f.Loads[i] = LoadBytes(cmddat) case LoadCmdRpath: var hdr RpathCmd b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &hdr); err != nil { return nil, err } l := new(Rpath) if hdr.Path >= uint32(len(cmddat)) { return nil, &FormatError{offset, "invalid path in rpath command", hdr.Path} } l.Path = cstring(cmddat[hdr.Path:]) l.LoadBytes = LoadBytes(cmddat) f.Loads[i] = l case LoadCmdDylib: var hdr DylibCmd b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &hdr); err != nil { return nil, err } l := new(Dylib) if hdr.Name >= uint32(len(cmddat)) { return nil, &FormatError{offset, "invalid name in dynamic library command", hdr.Name} } l.Name = cstring(cmddat[hdr.Name:]) l.Time = hdr.Time l.CurrentVersion = hdr.CurrentVersion l.CompatVersion = hdr.CompatVersion l.LoadBytes = LoadBytes(cmddat) f.Loads[i] = l case LoadCmdSymtab: var hdr SymtabCmd b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &hdr); err != nil { return nil, err } strtab := make([]byte, hdr.Strsize) if _, err := r.ReadAt(strtab, int64(hdr.Stroff)); err != nil { return nil, err } var symsz int if f.Magic == Magic64 { symsz = 16 } else { symsz = 12 } symdat := make([]byte, int(hdr.Nsyms)*symsz) if _, err := r.ReadAt(symdat, int64(hdr.Symoff)); err != nil { return nil, err } st, err := f.parseSymtab(symdat, strtab, cmddat, &hdr, offset) if err != nil { return nil, err } f.Loads[i] = st f.Symtab = st case LoadCmdDysymtab: var hdr DysymtabCmd b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &hdr); err != nil { return nil, err } dat := make([]byte, hdr.Nindirectsyms*4) if _, err := r.ReadAt(dat, int64(hdr.Indirectsymoff)); err != nil { return nil, err } x := make([]uint32, hdr.Nindirectsyms) if err := binary.Read(bytes.NewReader(dat), bo, x); err != nil { return nil, err } st := new(Dysymtab) st.LoadBytes = LoadBytes(cmddat) st.DysymtabCmd = hdr st.IndirectSyms = x f.Loads[i] = st f.Dysymtab = st case LoadCmdSegment: var seg32 Segment32 b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &seg32); err != nil { return nil, err } s = new(Segment) s.LoadBytes = cmddat s.Cmd = cmd s.Len = siz s.Name = cstring(seg32.Name[0:]) s.Addr = uint64(seg32.Addr) s.Memsz = uint64(seg32.Memsz) s.Offset = uint64(seg32.Offset) s.Filesz = uint64(seg32.Filesz) s.Maxprot = seg32.Maxprot s.Prot = seg32.Prot s.Nsect = seg32.Nsect s.Flag = seg32.Flag f.Loads[i] = s for i := 0; i < int(s.Nsect); i++ { var sh32 Section32 if err := binary.Read(b, bo, &sh32); err != nil { return nil, err } sh := new(Section) sh.Name = cstring(sh32.Name[0:]) sh.Seg = cstring(sh32.Seg[0:]) sh.Addr = uint64(sh32.Addr) sh.Size = uint64(sh32.Size) sh.Offset = sh32.Offset sh.Align = sh32.Align sh.Reloff = sh32.Reloff sh.Nreloc = sh32.Nreloc sh.Flags = sh32.Flags if err := f.pushSection(sh, r); err != nil { return nil, err } } case LoadCmdSegment64: var seg64 Segment64 b := bytes.NewReader(cmddat) if err := binary.Read(b, bo, &seg64); err != nil { return nil, err } s = new(Segment) s.LoadBytes = cmddat s.Cmd = cmd s.Len = siz s.Name = cstring(seg64.Name[0:]) s.Addr = seg64.Addr s.Memsz = seg64.Memsz s.Offset = seg64.Offset s.Filesz = seg64.Filesz s.Maxprot = seg64.Maxprot s.Prot = seg64.Prot s.Nsect = seg64.Nsect s.Flag = seg64.Flag f.Loads[i] = s for i := 0; i < int(s.Nsect); i++ { var sh64 Section64 if err := binary.Read(b, bo, &sh64); err != nil { return nil, err } sh := new(Section) sh.Name = cstring(sh64.Name[0:]) sh.Seg = cstring(sh64.Seg[0:]) sh.Addr = sh64.Addr sh.Size = sh64.Size sh.Offset = sh64.Offset sh.Align = sh64.Align sh.Reloff = sh64.Reloff sh.Nreloc = sh64.Nreloc sh.Flags = sh64.Flags if err := f.pushSection(sh, r); err != nil { return nil, err } } } if s != nil { s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Filesz)) s.ReaderAt = s.sr } } return f, nil } func (f *File) parseSymtab(symdat, strtab, cmddat []byte, hdr *SymtabCmd, offset int64) (*Symtab, error) { bo := f.ByteOrder symtab := make([]Symbol, hdr.Nsyms) b := bytes.NewReader(symdat) for i := range symtab { var n Nlist64 if f.Magic == Magic64 { if err := binary.Read(b, bo, &n); err != nil { return nil, err } } else { var n32 Nlist32 if err := binary.Read(b, bo, &n32); err != nil { return nil, err } n.Name = n32.Name n.Type = n32.Type n.Sect = n32.Sect n.Desc = n32.Desc n.Value = uint64(n32.Value) } sym := &symtab[i] if n.Name >= uint32(len(strtab)) { return nil, &FormatError{offset, "invalid name in symbol table", n.Name} } sym.Name = cstring(strtab[n.Name:]) sym.Type = n.Type sym.Sect = n.Sect sym.Desc = n.Desc sym.Value = n.Value } st := new(Symtab) st.LoadBytes = LoadBytes(cmddat) st.Syms = symtab return st, nil } type relocInfo struct { Addr uint32 Symnum uint32 } func (f *File) pushSection(sh *Section, r io.ReaderAt) error { f.Sections = append(f.Sections, sh) sh.sr = io.NewSectionReader(r, int64(sh.Offset), int64(sh.Size)) sh.ReaderAt = sh.sr if sh.Nreloc > 0 { reldat := make([]byte, int(sh.Nreloc)*8) if _, err := r.ReadAt(reldat, int64(sh.Reloff)); err != nil { return err } b := bytes.NewReader(reldat) bo := f.ByteOrder sh.Relocs = make([]Reloc, sh.Nreloc) for i := range sh.Relocs { rel := &sh.Relocs[i] var ri relocInfo if err := binary.Read(b, bo, &ri); err != nil { return err } if ri.Addr&(1<<31) != 0 { // scattered rel.Addr = ri.Addr & (1<<24 - 1) rel.Type = uint8((ri.Addr >> 24) & (1<<4 - 1)) rel.Len = uint8((ri.Addr >> 28) & (1<<2 - 1)) rel.Pcrel = ri.Addr&(1<<30) != 0 rel.Value = ri.Symnum rel.Scattered = true } else { switch bo { case binary.LittleEndian: rel.Addr = ri.Addr rel.Value = ri.Symnum & (1<<24 - 1) rel.Pcrel = ri.Symnum&(1<<24) != 0 rel.Len = uint8((ri.Symnum >> 25) & (1<<2 - 1)) rel.Extern = ri.Symnum&(1<<27) != 0 rel.Type = uint8((ri.Symnum >> 28) & (1<<4 - 1)) case binary.BigEndian: rel.Addr = ri.Addr rel.Value = ri.Symnum >> 8 rel.Pcrel = ri.Symnum&(1<<7) != 0 rel.Len = uint8((ri.Symnum >> 5) & (1<<2 - 1)) rel.Extern = ri.Symnum&(1<<4) != 0 rel.Type = uint8(ri.Symnum & (1<<4 - 1)) default: panic("unreachable") } } } } return nil } func cstring(b []byte) string { var i int for i = 0; i < len(b) && b[i] != 0; i++ { } return string(b[0:i]) } // Segment returns the first Segment with the given name, or nil if no such segment exists. func (f *File) Segment(name string) *Segment { for _, l := range f.Loads { if s, ok := l.(*Segment); ok && s.Name == name { return s } } return nil } // Section returns the first section with the given name, or nil if no such // section exists. func (f *File) Section(name string) *Section { for _, s := range f.Sections { if s.Name == name { return s } } return nil } // DWARF returns the DWARF debug information for the Mach-O file. func (f *File) DWARF() (*dwarf.Data, error) { // There are many other DWARF sections, but these // are the ones the debug/dwarf package uses. // Don't bother loading others. var names = [...]string{"abbrev", "info", "line", "ranges", "str"} var dat [len(names)][]byte for i, name := range names { name = "__debug_" + name s := f.Section(name) if s == nil { continue } b, err := s.Data() if err != nil && uint64(len(b)) < s.Size { return nil, err } dat[i] = b } abbrev, info, line, ranges, str := dat[0], dat[1], dat[2], dat[3], dat[4] return dwarf.New(abbrev, nil, nil, info, line, nil, ranges, str) } // 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. func (f *File) ImportedSymbols() ([]string, error) { if f.Dysymtab == nil || f.Symtab == nil { return nil, &FormatError{0, "missing symbol table", nil} } st := f.Symtab dt := f.Dysymtab var all []string for _, s := range st.Syms[dt.Iundefsym : dt.Iundefsym+dt.Nundefsym] { all = append(all, s.Name) } return all, nil } // 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. func (f *File) ImportedLibraries() ([]string, error) { var all []string for _, l := range f.Loads { if lib, ok := l.(*Dylib); ok { all = append(all, lib.Name) } } return all, nil }