cybercyst/go
1
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-05-07 08:32:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

splitdwarf: initial working commit

Browse Source 
splitdwarf osxMachoFile [ osxDsymFile ]

splitdwarf takes an executable produced by go build as input,
and uncompresses and copies the DWARF segment into a separate
file in the way that is expected by OSX-hosted tools
(lldb and ports of gdb).
If osxDsymFile is not named explicitly, the default of
"<osxMachoFile>.dSYM/Contents/Resources/DWARF/<osxMachoFile>"
is used instead, with directories created as needed.

If the input file contains no UUID, then one is created by
hashing non-DWARF segment contents, and added to the
executable. This is necessary because gdb and lldb both
expect matching UUIDs to be present in the executable
and its debugging symbols.

Includes a modified version of debug/macho, with additional
definitions and the ability to write segments, sections, and
some MachO load commands added.

Change-Id: Ia5b0e289260f72bbca392cdf2c7c0a75e3ca40e5
Reviewed-on: https://go-review.googlesource.com/c/143357
Reviewed-by: Austin Clements <austin@google.com>
This commit is contained in:
David Chase 2018-10-05 18:08:29 -04:00
parent d674b4ad67
commit d30e00c240
6 changed files with 1433 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
cmd/splitdwarf/doc.go Normal file
View File

@ -0,0 +1,19 @@
// Copyright 2018 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.
/*
Splitdwarf uncompresses and copies the DWARF segment of a Mach-O
executable into the "dSYM" file expected by lldb and ports of gdb
on OSX.
Usage: splitdwarf osxMachoFile [ osxDsymFile ]
Unless a dSYM file name is provided on the command line,
splitdwarf will place it where the OSX tools expect it, in
"<osxMachoFile>.dSYM/Contents/Resources/DWARF/<osxMachoFile>",
creating directories as necessary.
*/
package main // import "golang.org/x/tools/cmd/splitdwarf"

27
cmd/splitdwarf/internal/macho/fat.go
View File

@ -6,7 +6,6 @@ package macho
import ( import (
"encoding/binary" "encoding/binary"
"fmt"
"io" "io"
"os" "os"
) )
@ -35,10 +34,6 @@ type FatArch struct {
*File *File
} }
// ErrNotFat is returned from NewFatFile or OpenFat when the file is not a
// universal binary but may be a thin binary, based on its magic number.
var ErrNotFat = &FormatError{0, "not a fat Mach-O file", nil}
// NewFatFile creates a new FatFile for accessing all the Mach-O images in a // NewFatFile creates a new FatFile for accessing all the Mach-O images in a
// universal binary. The Mach-O binary is expected to start at position 0 in // universal binary. The Mach-O binary is expected to start at position 0 in
// the ReaderAt. // the ReaderAt.
@ -50,7 +45,7 @@ func NewFatFile(r io.ReaderAt) (*FatFile, error) {
// Start with the magic number. // Start with the magic number.
err := binary.Read(sr, binary.BigEndian, &ff.Magic) err := binary.Read(sr, binary.BigEndian, &ff.Magic)
if err != nil { if err != nil {
return nil, &FormatError{0, "error reading magic number", nil} return nil, formatError(0, "error reading magic number, %v", err)
} else if ff.Magic != MagicFat { } else if ff.Magic != MagicFat {
// See if this is a Mach-O file via its magic number. The magic // See if this is a Mach-O file via its magic number. The magic
// must be converted to little endian first though. // must be converted to little endian first though.
@ -58,9 +53,9 @@ func NewFatFile(r io.ReaderAt) (*FatFile, error) {
binary.BigEndian.PutUint32(buf[:], ff.Magic) binary.BigEndian.PutUint32(buf[:], ff.Magic)
leMagic := binary.LittleEndian.Uint32(buf[:]) leMagic := binary.LittleEndian.Uint32(buf[:])
if leMagic == Magic32 || leMagic == Magic64 { if leMagic == Magic32 || leMagic == Magic64 {
return nil, ErrNotFat return nil, formatError(0, "not a fat Mach-O file, leMagic=0x%x", leMagic)
} else { } else {
return nil, &FormatError{0, "invalid magic number", nil} return nil, formatError(0, "invalid magic number, leMagic=0x%x", leMagic)
} }
} }
offset := int64(4) offset := int64(4)
@ -69,19 +64,19 @@ func NewFatFile(r io.ReaderAt) (*FatFile, error) {
var narch uint32 var narch uint32
err = binary.Read(sr, binary.BigEndian, &narch) err = binary.Read(sr, binary.BigEndian, &narch)
if err != nil { if err != nil {
return nil, &FormatError{offset, "invalid fat_header", nil} return nil, formatError(offset, "invalid fat_header %v", err)
} }
offset += 4 offset += 4
if narch < 1 { if narch < 1 {
return nil, &FormatError{offset, "file contains no images", nil} return nil, formatError(offset, "file contains no images, narch=%d", narch)
} }
// Combine the Cpu and SubCpu (both uint32) into a uint64 to make sure // Combine the Cpu and SubCpu (both uint32) into a uint64 to make sure
// there are not duplicate architectures. // there are not duplicate architectures.
seenArches := make(map[uint64]bool, narch) seenArches := make(map[uint64]bool, narch)
// Make sure that all images are for the same MH_ type. // Make sure that all images are for the same MH_ type.
var machoType Type var machoType HdrType
// Following the fat_header comes narch fat_arch structs that index // Following the fat_header comes narch fat_arch structs that index
// Mach-O images further in the file. // Mach-O images further in the file.
@ -90,7 +85,7 @@ func NewFatFile(r io.ReaderAt) (*FatFile, error) {
fa := &ff.Arches[i] fa := &ff.Arches[i]
err = binary.Read(sr, binary.BigEndian, &fa.FatArchHeader) err = binary.Read(sr, binary.BigEndian, &fa.FatArchHeader)
if err != nil { if err != nil {
return nil, &FormatError{offset, "invalid fat_arch header", nil} return nil, formatError(offset, "invalid fat_arch header, %v", err)
} }
offset += fatArchHeaderSize offset += fatArchHeaderSize
@ -103,16 +98,16 @@ func NewFatFile(r io.ReaderAt) (*FatFile, error) {
// Make sure the architecture for this image is not duplicate. // Make sure the architecture for this image is not duplicate.
seenArch := (uint64(fa.Cpu) << 32) | uint64(fa.SubCpu) seenArch := (uint64(fa.Cpu) << 32) | uint64(fa.SubCpu)
if o, k := seenArches[seenArch]; o || k { if o, k := seenArches[seenArch]; o || k {
return nil, &FormatError{offset, fmt.Sprintf("duplicate architecture cpu=%v, subcpu=%#x", fa.Cpu, fa.SubCpu), nil} return nil, formatError(offset, "duplicate architecture cpu=%v, subcpu=%#x", fa.Cpu, fa.SubCpu)
} }
seenArches[seenArch] = true seenArches[seenArch] = true
// Make sure the Mach-O type matches that of the first image. // Make sure the Mach-O type matches that of the first image.
if i == 0 { if i == 0 {
machoType = fa.Type machoType = HdrType(fa.Type)
} else { } else {
if fa.Type != machoType { if HdrType(fa.Type) != machoType {
return nil, &FormatError{offset, fmt.Sprintf("Mach-O type for architecture #%d (type=%#x) does not match first (type=%#x)", i, fa.Type, machoType), nil} return nil, formatError(offset, "Mach-O type for architecture #%d (type=%#x) does not match first (type=%#x)", i, fa.Type, machoType)
} }
} }
} }

809
cmd/splitdwarf/internal/macho/file.go
View File

File diff suppressed because it is too large Load Diff

146
cmd/splitdwarf/internal/macho/file_test.go
View File

@ -6,6 +6,7 @@ package macho
import ( import (
"reflect" "reflect"
"strings"
"testing" "testing"
) )
@ -22,25 +23,25 @@ var fileTests = []fileTest{
"testdata/gcc-386-darwin-exec", "testdata/gcc-386-darwin-exec",
FileHeader{0xfeedface, Cpu386, 0x3, 0x2, 0xc, 0x3c0, 0x85}, FileHeader{0xfeedface, Cpu386, 0x3, 0x2, 0xc, 0x3c0, 0x85},
[]interface{}{ []interface{}{
&SegmentHeader{LoadCmdSegment, 0x38, "__PAGEZERO", 0x0, 0x1000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, &SegmentHeader{LcSegment, 0x38, "__PAGEZERO", 0x0, 0x1000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0},
&SegmentHeader{LoadCmdSegment, 0xc0, "__TEXT", 0x1000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x2, 0x0}, &SegmentHeader{LcSegment, 0xc0, "__TEXT", 0x1000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x2, 0x0, 0},
&SegmentHeader{LoadCmdSegment, 0xc0, "__DATA", 0x2000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x2, 0x0}, &SegmentHeader{LcSegment, 0xc0, "__DATA", 0x2000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x2, 0x0, 2},
&SegmentHeader{LoadCmdSegment, 0x7c, "__IMPORT", 0x3000, 0x1000, 0x2000, 0x1000, 0x7, 0x7, 0x1, 0x0}, &SegmentHeader{LcSegment, 0x7c, "__IMPORT", 0x3000, 0x1000, 0x2000, 0x1000, 0x7, 0x7, 0x1, 0x0, 4},
&SegmentHeader{LoadCmdSegment, 0x38, "__LINKEDIT", 0x4000, 0x1000, 0x3000, 0x12c, 0x7, 0x1, 0x0, 0x0}, &SegmentHeader{LcSegment, 0x38, "__LINKEDIT", 0x4000, 0x1000, 0x3000, 0x12c, 0x7, 0x1, 0x0, 0x0, 5},
nil, // LC_SYMTAB nil, // LC_SYMTAB
nil, // LC_DYSYMTAB nil, // LC_DYSYMTAB
nil, // LC_LOAD_DYLINKER nil, // LC_LOAD_DYLINKER
nil, // LC_UUID nil, // LC_UUID
nil, // LC_UNIXTHREAD nil, // LC_UNIXTHREAD
&Dylib{nil, "/usr/lib/libgcc_s.1.dylib", 0x2, 0x10000, 0x10000}, &Dylib{DylibCmd{}, "/usr/lib/libgcc_s.1.dylib", 0x2, 0x10000, 0x10000},
&Dylib{nil, "/usr/lib/libSystem.B.dylib", 0x2, 0x6f0104, 0x10000}, &Dylib{DylibCmd{}, "/usr/lib/libSystem.B.dylib", 0x2, 0x6f0104, 0x10000},
}, },
[]*SectionHeader{ []*SectionHeader{
{"__text", "__TEXT", 0x1f68, 0x88, 0xf68, 0x2, 0x0, 0x0, 0x80000400}, {"__text", "__TEXT", 0x1f68, 0x88, 0xf68, 0x2, 0x0, 0x0, 0x80000400, 0, 0, 0},
{"__cstring", "__TEXT", 0x1ff0, 0xd, 0xff0, 0x0, 0x0, 0x0, 0x2}, {"__cstring", "__TEXT", 0x1ff0, 0xd, 0xff0, 0x0, 0x0, 0x0, 0x2, 0, 0, 0},
{"__data", "__DATA", 0x2000, 0x14, 0x1000, 0x2, 0x0, 0x0, 0x0}, {"__data", "__DATA", 0x2000, 0x14, 0x1000, 0x2, 0x0, 0x0, 0x0, 0, 0, 0},
{"__dyld", "__DATA", 0x2014, 0x1c, 0x1014, 0x2, 0x0, 0x0, 0x0}, {"__dyld", "__DATA", 0x2014, 0x1c, 0x1014, 0x2, 0x0, 0x0, 0x0, 0, 0, 0},
{"__jump_table", "__IMPORT", 0x3000, 0xa, 0x2000, 0x6, 0x0, 0x0, 0x4000008}, {"__jump_table", "__IMPORT", 0x3000, 0xa, 0x2000, 0x6, 0x0, 0x0, 0x4000008, 0, 5, 0},
}, },
nil, nil,
}, },
@ -48,27 +49,27 @@ var fileTests = []fileTest{
"testdata/gcc-amd64-darwin-exec", "testdata/gcc-amd64-darwin-exec",
FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0x2, 0xb, 0x568, 0x85}, FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0x2, 0xb, 0x568, 0x85},
[]interface{}{ []interface{}{
&SegmentHeader{LoadCmdSegment64, 0x48, "__PAGEZERO", 0x0, 0x100000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, &SegmentHeader{LcSegment64, 0x48, "__PAGEZERO", 0x0, 0x100000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0},
&SegmentHeader{LoadCmdSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x5, 0x0}, &SegmentHeader{LcSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x5, 0x0, 0},
&SegmentHeader{LoadCmdSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x3, 0x0}, &SegmentHeader{LcSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x3, 0x0, 5},
&SegmentHeader{LoadCmdSegment64, 0x48, "__LINKEDIT", 0x100002000, 0x1000, 0x2000, 0x140, 0x7, 0x1, 0x0, 0x0}, &SegmentHeader{LcSegment64, 0x48, "__LINKEDIT", 0x100002000, 0x1000, 0x2000, 0x140, 0x7, 0x1, 0x0, 0x0, 8},
nil, // LC_SYMTAB nil, // LC_SYMTAB
nil, // LC_DYSYMTAB nil, // LC_DYSYMTAB
nil, // LC_LOAD_DYLINKER nil, // LC_LOAD_DYLINKER
nil, // LC_UUID nil, // LC_UUID
nil, // LC_UNIXTHREAD nil, // LC_UNIXTHREAD
&Dylib{nil, "/usr/lib/libgcc_s.1.dylib", 0x2, 0x10000, 0x10000}, &Dylib{DylibCmd{}, "/usr/lib/libgcc_s.1.dylib", 0x2, 0x10000, 0x10000},
&Dylib{nil, "/usr/lib/libSystem.B.dylib", 0x2, 0x6f0104, 0x10000}, &Dylib{DylibCmd{}, "/usr/lib/libSystem.B.dylib", 0x2, 0x6f0104, 0x10000},
}, },
[]*SectionHeader{ []*SectionHeader{
{"__text", "__TEXT", 0x100000f14, 0x6d, 0xf14, 0x2, 0x0, 0x0, 0x80000400}, {"__text", "__TEXT", 0x100000f14, 0x6d, 0xf14, 0x2, 0x0, 0x0, 0x80000400, 0, 0, 0},
{"__symbol_stub1", "__TEXT", 0x100000f81, 0xc, 0xf81, 0x0, 0x0, 0x0, 0x80000408}, {"__symbol_stub1", "__TEXT", 0x100000f81, 0xc, 0xf81, 0x0, 0x0, 0x0, 0x80000408, 0, 6, 0},
{"__stub_helper", "__TEXT", 0x100000f90, 0x18, 0xf90, 0x2, 0x0, 0x0, 0x0}, {"__stub_helper", "__TEXT", 0x100000f90, 0x18, 0xf90, 0x2, 0x0, 0x0, 0x0, 0, 0, 0},
{"__cstring", "__TEXT", 0x100000fa8, 0xd, 0xfa8, 0x0, 0x0, 0x0, 0x2}, {"__cstring", "__TEXT", 0x100000fa8, 0xd, 0xfa8, 0x0, 0x0, 0x0, 0x2, 0, 0, 0},
{"__eh_frame", "__TEXT", 0x100000fb8, 0x48, 0xfb8, 0x3, 0x0, 0x0, 0x6000000b}, {"__eh_frame", "__TEXT", 0x100000fb8, 0x48, 0xfb8, 0x3, 0x0, 0x0, 0x6000000b, 0, 0, 0},
{"__data", "__DATA", 0x100001000, 0x1c, 0x1000, 0x3, 0x0, 0x0, 0x0}, {"__data", "__DATA", 0x100001000, 0x1c, 0x1000, 0x3, 0x0, 0x0, 0x0, 0, 0, 0},
{"__dyld", "__DATA", 0x100001020, 0x38, 0x1020, 0x3, 0x0, 0x0, 0x0}, {"__dyld", "__DATA", 0x100001020, 0x38, 0x1020, 0x3, 0x0, 0x0, 0x0, 0, 0, 0},
{"__la_symbol_ptr", "__DATA", 0x100001058, 0x10, 0x1058, 0x2, 0x0, 0x0, 0x7}, {"__la_symbol_ptr", "__DATA", 0x100001058, 0x10, 0x1058, 0x2, 0x0, 0x0, 0x7, 2, 0, 0},
}, },
nil, nil,
}, },
@ -77,26 +78,26 @@ var fileTests = []fileTest{
FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0xa, 0x4, 0x5a0, 0}, FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0xa, 0x4, 0x5a0, 0},
[]interface{}{ []interface{}{
nil, // LC_UUID nil, // LC_UUID
&SegmentHeader{LoadCmdSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x0, 0x7, 0x5, 0x5, 0x0}, &SegmentHeader{LcSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x0, 0x7, 0x5, 0x5, 0x0, 0},
&SegmentHeader{LoadCmdSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x0, 0x0, 0x7, 0x3, 0x3, 0x0}, &SegmentHeader{LcSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x0, 0x0, 0x7, 0x3, 0x3, 0x0, 5},
&SegmentHeader{LoadCmdSegment64, 0x278, "__DWARF", 0x100002000, 0x1000, 0x1000, 0x1bc, 0x7, 0x3, 0x7, 0x0}, &SegmentHeader{LcSegment64, 0x278, "__DWARF", 0x100002000, 0x1000, 0x1000, 0x1bc, 0x7, 0x3, 0x7, 0x0, 8},
}, },
[]*SectionHeader{ []*SectionHeader{
{"__text", "__TEXT", 0x100000f14, 0x0, 0x0, 0x2, 0x0, 0x0, 0x80000400}, {"__text", "__TEXT", 0x100000f14, 0x0, 0x0, 0x2, 0x0, 0x0, 0x80000400, 0, 0, 0},
{"__symbol_stub1", "__TEXT", 0x100000f81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80000408}, {"__symbol_stub1", "__TEXT", 0x100000f81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80000408, 0, 6, 0},
{"__stub_helper", "__TEXT", 0x100000f90, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0}, {"__stub_helper", "__TEXT", 0x100000f90, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0, 0, 0},
{"__cstring", "__TEXT", 0x100000fa8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2}, {"__cstring", "__TEXT", 0x100000fa8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0, 0, 0},
{"__eh_frame", "__TEXT", 0x100000fb8, 0x0, 0x0, 0x3, 0x0, 0x0, 0x6000000b}, {"__eh_frame", "__TEXT", 0x100000fb8, 0x0, 0x0, 0x3, 0x0, 0x0, 0x6000000b, 0, 0, 0},
{"__data", "__DATA", 0x100001000, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0}, {"__data", "__DATA", 0x100001000, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0, 0, 0},
{"__dyld", "__DATA", 0x100001020, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0}, {"__dyld", "__DATA", 0x100001020, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0, 0, 0},
{"__la_symbol_ptr", "__DATA", 0x100001058, 0x0, 0x0, 0x2, 0x0, 0x0, 0x7}, {"__la_symbol_ptr", "__DATA", 0x100001058, 0x0, 0x0, 0x2, 0x0, 0x0, 0x7, 2, 0, 0},
{"__debug_abbrev", "__DWARF", 0x100002000, 0x36, 0x1000, 0x0, 0x0, 0x0, 0x0}, {"__debug_abbrev", "__DWARF", 0x100002000, 0x36, 0x1000, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_aranges", "__DWARF", 0x100002036, 0x30, 0x1036, 0x0, 0x0, 0x0, 0x0}, {"__debug_aranges", "__DWARF", 0x100002036, 0x30, 0x1036, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_frame", "__DWARF", 0x100002066, 0x40, 0x1066, 0x0, 0x0, 0x0, 0x0}, {"__debug_frame", "__DWARF", 0x100002066, 0x40, 0x1066, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_info", "__DWARF", 0x1000020a6, 0x54, 0x10a6, 0x0, 0x0, 0x0, 0x0}, {"__debug_info", "__DWARF", 0x1000020a6, 0x54, 0x10a6, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_line", "__DWARF", 0x1000020fa, 0x47, 0x10fa, 0x0, 0x0, 0x0, 0x0}, {"__debug_line", "__DWARF", 0x1000020fa, 0x47, 0x10fa, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_pubnames", "__DWARF", 0x100002141, 0x1b, 0x1141, 0x0, 0x0, 0x0, 0x0}, {"__debug_pubnames", "__DWARF", 0x100002141, 0x1b, 0x1141, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
{"__debug_str", "__DWARF", 0x10000215c, 0x60, 0x115c, 0x0, 0x0, 0x0, 0x0}, {"__debug_str", "__DWARF", 0x10000215c, 0x60, 0x115c, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
}, },
nil, nil,
}, },
@ -117,7 +118,7 @@ var fileTests = []fileTest{
nil, // LC_SOURCE_VERSION nil, // LC_SOURCE_VERSION
nil, // LC_MAIN nil, // LC_MAIN
nil, // LC_LOAD_DYLIB nil, // LC_LOAD_DYLIB
&Rpath{nil, "/my/rpath"}, &Rpath{LcRpath, "/my/rpath"},
nil, // LC_FUNCTION_STARTS nil, // LC_FUNCTION_STARTS
nil, // LC_DATA_IN_CODE nil, // LC_DATA_IN_CODE
}, },
@ -141,7 +142,7 @@ var fileTests = []fileTest{
nil, // LC_SOURCE_VERSION nil, // LC_SOURCE_VERSION
nil, // LC_MAIN nil, // LC_MAIN
nil, // LC_LOAD_DYLIB nil, // LC_LOAD_DYLIB
&Rpath{nil, "/my/rpath"}, &Rpath{LcRpath, "/my/rpath"},
nil, // LC_FUNCTION_STARTS nil, // LC_FUNCTION_STARTS
nil, // LC_DATA_IN_CODE nil, // LC_DATA_IN_CODE
}, },
@ -234,11 +235,11 @@ func TestOpen(t *testing.T) {
t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr) t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr)
continue continue
} }
for i, l := range f.Loads { // for i, l := range f.Loads {
if len(l.Raw()) < 8 { // if len(l.Raw()) < 8 {
t.Errorf("open %s, command %d:\n\tload command %T don't have enough data\n", tt.file, i, l) // t.Errorf("open %s, command %d:\n\tload command %T don't have enough data\n", tt.file, i, l)
} // }
} // }
if tt.loads != nil { if tt.loads != nil {
for i, l := range f.Loads { for i, l := range f.Loads {
if i >= len(tt.loads) { if i >= len(tt.loads) {
@ -254,20 +255,20 @@ func TestOpen(t *testing.T) {
case *Segment: case *Segment:
have := &l.SegmentHeader have := &l.SegmentHeader
if !reflect.DeepEqual(have, want) { if !reflect.DeepEqual(have, want) {
t.Errorf("open %s, command %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want) t.Errorf("open %s, command %d:\n\thave %s\n\twant %s\n", tt.file, i, have.String(), want.(*SegmentHeader).String())
} }
case *Dylib: case *Dylib:
have := l // have := l
have.LoadBytes = nil // have.LoadBytes = nil
if !reflect.DeepEqual(have, want) { // if !reflect.DeepEqual(have, want) {
t.Errorf("open %s, command %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want) // t.Errorf("open %s, command %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want)
} // }
case *Rpath: case *Rpath:
have := l // have := l
have.LoadBytes = nil // have.LoadBytes = nil
if !reflect.DeepEqual(have, want) { // if !reflect.DeepEqual(have, want) {
t.Errorf("open %s, command %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want) // t.Errorf("open %s, command %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want)
} // }
default: default:
t.Errorf("open %s, command %d: unknown load command\n\thave %#v\n\twant %#v\n", tt.file, i, l, want) t.Errorf("open %s, command %d: unknown load command\n\thave %#v\n\twant %#v\n", tt.file, i, l, want)
} }
@ -352,9 +353,18 @@ func TestOpenFatFailure(t *testing.T) {
filename = "testdata/gcc-386-darwin-exec" // not a fat Mach-O filename = "testdata/gcc-386-darwin-exec" // not a fat Mach-O
ff, err := OpenFat(filename) ff, err := OpenFat(filename)
if err != ErrNotFat { if err == nil {
t.Errorf("OpenFat %s: got %v, want ErrNotFat", filename, err) t.Errorf("OpenFat %s: expected error, got nil", filename)
} }
if _, ok := err.(*FormatError); !ok {
t.Errorf("OpenFat %s: expected FormatError, got %v", filename, err)
}
ferr := err.(*FormatError)
if !strings.Contains(ferr.String(), "not a fat") {
t.Errorf("OpenFat %s: expected error containing 'not a fat', got %s", filename, ferr.String())
}
if ff != nil { if ff != nil {
t.Errorf("OpenFat %s: got %v, want nil", filename, ff) t.Errorf("OpenFat %s: got %v, want nil", filename, ff)
} }
@ -370,10 +380,10 @@ func TestRelocTypeString(t *testing.T) {
} }
func TestTypeString(t *testing.T) { func TestTypeString(t *testing.T) {
if TypeExec.String() != "Exec" { if MhExecute.String() != "Exec" {
t.Errorf("got %v, want %v", TypeExec.String(), "Exec") t.Errorf("got %v, want %v", MhExecute.String(), "Exec")
} }
if TypeExec.GoString() != "macho.Exec" { if MhExecute.GoString() != "macho.Exec" {
t.Errorf("got %v, want %v", TypeExec.GoString(), "macho.Exec") t.Errorf("got %v, want %v", MhExecute.GoString(), "macho.Exec")
} }
} }

276
cmd/splitdwarf/internal/macho/macho.go
View File

@ -7,17 +7,35 @@
package macho package macho
import "strconv" import (
"encoding/binary"
"strconv"
)
// A FileHeader represents a Mach-O file header. // A FileHeader represents a Mach-O file header.
type FileHeader struct { type FileHeader struct {
Magic uint32 Magic uint32
Cpu Cpu Cpu Cpu
SubCpu uint32 SubCpu uint32
Type Type Type HdrType
Ncmd uint32 NCommands uint32 // number of load commands
Cmdsz uint32 SizeCommands uint32 // size of all the load commands, not including this header.
Flags uint32 Flags HdrFlags
}
func (h *FileHeader) Put(b []byte, o binary.ByteOrder) int {
o.PutUint32(b[0:], h.Magic)
o.PutUint32(b[4:], uint32(h.Cpu))
o.PutUint32(b[8:], h.SubCpu)
o.PutUint32(b[12:], uint32(h.Type))
o.PutUint32(b[16:], h.NCommands)
o.PutUint32(b[20:], h.SizeCommands)
o.PutUint32(b[24:], uint32(h.Flags))
if h.Magic == Magic32 {
return 28
}
o.PutUint32(b[28:], 0)
return 32
} }
const ( const (
@ -31,25 +49,32 @@ const (
MagicFat uint32 = 0xcafebabe MagicFat uint32 = 0xcafebabe
) )
// A Type is the Mach-O file type, e.g. an object file, executable, or dynamic library. type HdrFlags uint32
type Type uint32 type SegFlags uint32
type SecFlags uint32
const ( // A HdrType is the Mach-O file type, e.g. an object file, executable, or dynamic library.
TypeObj Type = 1 type HdrType uint32
TypeExec Type = 2
TypeDylib Type = 6 const ( // SNAKE_CASE to CamelCase translation from C names
TypeBundle Type = 8 MhObject HdrType = 1
MhExecute HdrType = 2
MhCore HdrType = 4
MhDylib HdrType = 6
MhBundle HdrType = 8
MhDsym HdrType = 0xa
) )
var typeStrings = []intName{ var typeStrings = []intName{
{uint32(TypeObj), "Obj"}, {uint32(MhObject), "Obj"},
{uint32(TypeExec), "Exec"}, {uint32(MhExecute), "Exec"},
{uint32(TypeDylib), "Dylib"}, {uint32(MhDylib), "Dylib"},
{uint32(TypeBundle), "Bundle"}, {uint32(MhBundle), "Bundle"},
{uint32(MhDsym), "Dsym"},
} }
func (t Type) String() string { return stringName(uint32(t), typeStrings, false) } func (t HdrType) String() string { return stringName(uint32(t), typeStrings, false) }
func (t Type) GoString() string { return stringName(uint32(t), typeStrings, true) } func (t HdrType) GoString() string { return stringName(uint32(t), typeStrings, true) }
// A Cpu is a Mach-O cpu type. // A Cpu is a Mach-O cpu type.
type Cpu uint32 type Cpu uint32
@ -80,25 +105,59 @@ func (i Cpu) GoString() string { return stringName(uint32(i), cpuStrings, true)
// A LoadCmd is a Mach-O load command. // A LoadCmd is a Mach-O load command.
type LoadCmd uint32 type LoadCmd uint32
const ( func (c LoadCmd) Command() LoadCmd { return c }
LoadCmdSegment LoadCmd = 0x1
LoadCmdSymtab LoadCmd = 0x2 const ( // SNAKE_CASE to CamelCase translation from C names
LoadCmdThread LoadCmd = 0x4 // Note 3 and 8 are obsolete
LoadCmdUnixThread LoadCmd = 0x5 // thread+stack LcSegment LoadCmd = 0x1
LoadCmdDysymtab LoadCmd = 0xb LcSymtab LoadCmd = 0x2
LoadCmdDylib LoadCmd = 0xc // load dylib command LcThread LoadCmd = 0x4
LoadCmdDylinker LoadCmd = 0xf // id dylinker command (not load dylinker command) LcUnixthread LoadCmd = 0x5 // thread+stack
LoadCmdSegment64 LoadCmd = 0x19 LcDysymtab LoadCmd = 0xb
LoadCmdRpath LoadCmd = 0x8000001c LcDylib LoadCmd = 0xc // load dylib command
LcIdDylib LoadCmd = 0xd // dynamically linked shared lib ident
LcLoadDylinker LoadCmd = 0xe // load a dynamic linker
LcIdDylinker LoadCmd = 0xf // id dylinker command (not load dylinker command)
LcSegment64 LoadCmd = 0x19
LcUuid LoadCmd = 0x1b
LcCodeSignature LoadCmd = 0x1d
LcSegmentSplitInfo LoadCmd = 0x1e
LcRpath LoadCmd = 0x8000001c
LcEncryptionInfo LoadCmd = 0x21
LcDyldInfo LoadCmd = 0x22
LcDyldInfoOnly LoadCmd = 0x80000022
LcVersionMinMacosx LoadCmd = 0x24
LcVersionMinIphoneos LoadCmd = 0x25
LcFunctionStarts LoadCmd = 0x26
LcDyldEnvironment LoadCmd = 0x27
LcMain LoadCmd = 0x80000028 // replacement for UnixThread
LcDataInCode LoadCmd = 0x29 // There are non-instructions in text
LcSourceVersion LoadCmd = 0x2a // Source version used to build binary
LcDylibCodeSignDrs LoadCmd = 0x2b
LcEncryptionInfo64 LoadCmd = 0x2c
LcVersionMinTvos LoadCmd = 0x2f
LcVersionMinWatchos LoadCmd = 0x30
) )
var cmdStrings = []intName{ var cmdStrings = []intName{
{uint32(LoadCmdSegment), "LoadCmdSegment"}, {uint32(LcSegment), "LoadCmdSegment"},
{uint32(LoadCmdThread), "LoadCmdThread"}, {uint32(LcThread), "LoadCmdThread"},
{uint32(LoadCmdUnixThread), "LoadCmdUnixThread"}, {uint32(LcUnixthread), "LoadCmdUnixThread"},
{uint32(LoadCmdDylib), "LoadCmdDylib"}, {uint32(LcDylib), "LoadCmdDylib"},
{uint32(LoadCmdSegment64), "LoadCmdSegment64"}, {uint32(LcIdDylib), "LoadCmdIdDylib"},
{uint32(LoadCmdRpath), "LoadCmdRpath"}, {uint32(LcLoadDylinker), "LoadCmdLoadDylinker"},
{uint32(LcIdDylinker), "LoadCmdIdDylinker"},
{uint32(LcSegment64), "LoadCmdSegment64"},
{uint32(LcUuid), "LoadCmdUuid"},
{uint32(LcRpath), "LoadCmdRpath"},
{uint32(LcDyldEnvironment), "LoadCmdDyldEnv"},
{uint32(LcMain), "LoadCmdMain"},
{uint32(LcDataInCode), "LoadCmdDataInCode"},
{uint32(LcSourceVersion), "LoadCmdSourceVersion"},
{uint32(LcDyldInfo), "LoadCmdDyldInfo"},
{uint32(LcDyldInfoOnly), "LoadCmdDyldInfoOnly"},
{uint32(LcVersionMinMacosx), "LoadCmdMinOsx"},
{uint32(LcFunctionStarts), "LoadCmdFunctionStarts"},
} }
func (i LoadCmd) String() string { return stringName(uint32(i), cmdStrings, false) } func (i LoadCmd) String() string { return stringName(uint32(i), cmdStrings, false) }
@ -107,7 +166,7 @@ func (i LoadCmd) GoString() string { return stringName(uint32(i), cmdStrings, tr
type ( type (
// A Segment32 is a 32-bit Mach-O segment load command. // A Segment32 is a 32-bit Mach-O segment load command.
Segment32 struct { Segment32 struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Name [16]byte Name [16]byte
Addr uint32 Addr uint32
@ -117,12 +176,12 @@ type (
Maxprot uint32 Maxprot uint32
Prot uint32 Prot uint32
Nsect uint32 Nsect uint32
Flag uint32 Flag SegFlags
} }
// A Segment64 is a 64-bit Mach-O segment load command. // A Segment64 is a 64-bit Mach-O segment load command.
Segment64 struct { Segment64 struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Name [16]byte Name [16]byte
Addr uint64 Addr uint64
@ -132,12 +191,12 @@ type (
Maxprot uint32 Maxprot uint32
Prot uint32 Prot uint32
Nsect uint32 Nsect uint32
Flag uint32 Flag SegFlags
} }
// A SymtabCmd is a Mach-O symbol table command. // A SymtabCmd is a Mach-O symbol table command.
SymtabCmd struct { SymtabCmd struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Symoff uint32 Symoff uint32
Nsyms uint32 Nsyms uint32
@ -147,7 +206,7 @@ type (
// A DysymtabCmd is a Mach-O dynamic symbol table command. // A DysymtabCmd is a Mach-O dynamic symbol table command.
DysymtabCmd struct { DysymtabCmd struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Ilocalsym uint32 Ilocalsym uint32
Nlocalsym uint32 Nlocalsym uint32
@ -171,7 +230,7 @@ type (
// A DylibCmd is a Mach-O load dynamic library command. // A DylibCmd is a Mach-O load dynamic library command.
DylibCmd struct { DylibCmd struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Name uint32 Name uint32
Time uint32 Time uint32
@ -179,49 +238,104 @@ type (
CompatVersion uint32 CompatVersion uint32
} }
// A DylinkerCmd is a Mach-O load dynamic linker or environment command.
DylinkerCmd struct {
LoadCmd
Len uint32
Name uint32
}
// A RpathCmd is a Mach-O rpath command. // A RpathCmd is a Mach-O rpath command.
RpathCmd struct { RpathCmd struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Path uint32 Path uint32
} }
// A Thread is a Mach-O thread state command. // A Thread is a Mach-O thread state command.
Thread struct { Thread struct {
Cmd LoadCmd LoadCmd
Len uint32 Len uint32
Type uint32 Type uint32
Data []uint32 Data []uint32
} }
// LC_DYLD_INFO, LC_DYLD_INFO_ONLY
DyldInfoCmd struct {
LoadCmd
Len uint32
RebaseOff, RebaseLen uint32 // file offset and length; data contains segment indices
BindOff, BindLen uint32 // file offset and length; data contains segment indices
WeakBindOff, WeakBindLen uint32 // file offset and length
LazyBindOff, LazyBindLen uint32 // file offset and length
ExportOff, ExportLen uint32 // file offset and length
}
// LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS
LinkEditDataCmd struct {
LoadCmd
Len uint32
DataOff, DataLen uint32 // file offset and length
}
// LC_ENCRYPTION_INFO, LC_ENCRYPTION_INFO_64
EncryptionInfoCmd struct {
LoadCmd
Len uint32
CryptOff, CryptLen uint32 // file offset and length
CryptId uint32
}
UuidCmd struct {
LoadCmd
Len uint32
Id [16]byte
}
// TODO Commands below not fully supported yet.
EntryPointCmd struct {
LoadCmd
Len uint32
EntryOff uint64 // file offset
StackSize uint64 // if not zero, initial stack size
}
NoteCmd struct {
LoadCmd
Len uint32
Name [16]byte
Offset, Filesz uint64 // file offset and length
}
) )
const ( const (
FlagNoUndefs uint32 = 0x1 FlagNoUndefs HdrFlags = 0x1
FlagIncrLink uint32 = 0x2 FlagIncrLink HdrFlags = 0x2
FlagDyldLink uint32 = 0x4 FlagDyldLink HdrFlags = 0x4
FlagBindAtLoad uint32 = 0x8 FlagBindAtLoad HdrFlags = 0x8
FlagPrebound uint32 = 0x10 FlagPrebound HdrFlags = 0x10
FlagSplitSegs uint32 = 0x20 FlagSplitSegs HdrFlags = 0x20
FlagLazyInit uint32 = 0x40 FlagLazyInit HdrFlags = 0x40
FlagTwoLevel uint32 = 0x80 FlagTwoLevel HdrFlags = 0x80
FlagForceFlat uint32 = 0x100 FlagForceFlat HdrFlags = 0x100
FlagNoMultiDefs uint32 = 0x200 FlagNoMultiDefs HdrFlags = 0x200
FlagNoFixPrebinding uint32 = 0x400 FlagNoFixPrebinding HdrFlags = 0x400
FlagPrebindable uint32 = 0x800 FlagPrebindable HdrFlags = 0x800
FlagAllModsBound uint32 = 0x1000 FlagAllModsBound HdrFlags = 0x1000
FlagSubsectionsViaSymbols uint32 = 0x2000 FlagSubsectionsViaSymbols HdrFlags = 0x2000
FlagCanonical uint32 = 0x4000 FlagCanonical HdrFlags = 0x4000
FlagWeakDefines uint32 = 0x8000 FlagWeakDefines HdrFlags = 0x8000
FlagBindsToWeak uint32 = 0x10000 FlagBindsToWeak HdrFlags = 0x10000
FlagAllowStackExecution uint32 = 0x20000 FlagAllowStackExecution HdrFlags = 0x20000
FlagRootSafe uint32 = 0x40000 FlagRootSafe HdrFlags = 0x40000
FlagSetuidSafe uint32 = 0x80000 FlagSetuidSafe HdrFlags = 0x80000
FlagNoReexportedDylibs uint32 = 0x100000 FlagNoReexportedDylibs HdrFlags = 0x100000
FlagPIE uint32 = 0x200000 FlagPIE HdrFlags = 0x200000
FlagDeadStrippableDylib uint32 = 0x400000 FlagDeadStrippableDylib HdrFlags = 0x400000
FlagHasTLVDescriptors uint32 = 0x800000 FlagHasTLVDescriptors HdrFlags = 0x800000
FlagNoHeapExecution uint32 = 0x1000000 FlagNoHeapExecution HdrFlags = 0x1000000
FlagAppExtensionSafe uint32 = 0x2000000 FlagAppExtensionSafe HdrFlags = 0x2000000
) )
// A Section32 is a 32-bit Mach-O section header. // A Section32 is a 32-bit Mach-O section header.
@ -234,7 +348,7 @@ type Section32 struct {
Align uint32 Align uint32
Reloff uint32 Reloff uint32
Nreloc uint32 Nreloc uint32
Flags uint32 Flags SecFlags
Reserve1 uint32 Reserve1 uint32
Reserve2 uint32 Reserve2 uint32
} }
@ -249,7 +363,7 @@ type Section64 struct {
Align uint32 Align uint32
Reloff uint32 Reloff uint32
Nreloc uint32 Nreloc uint32
Flags uint32 Flags SecFlags
Reserve1 uint32 Reserve1 uint32
Reserve2 uint32 Reserve2 uint32
Reserve3 uint32 Reserve3 uint32
@ -273,6 +387,24 @@ type Nlist64 struct {
Value uint64 Value uint64
} }
func (n *Nlist64) Put64(b []byte, o binary.ByteOrder) uint32 {
o.PutUint32(b[0:], n.Name)
b[4] = byte(n.Type)
b[5] = byte(n.Sect)
o.PutUint16(b[6:], n.Desc)
o.PutUint64(b[8:], n.Value)
return 8 + 8
}
func (n *Nlist64) Put32(b []byte, o binary.ByteOrder) uint32 {
o.PutUint32(b[0:], n.Name)
b[4] = byte(n.Type)
b[5] = byte(n.Sect)
o.PutUint16(b[6:], n.Desc)
o.PutUint32(b[8:], uint32(n.Value))
return 8 + 4
}
// Regs386 is the Mach-O 386 register structure. // Regs386 is the Mach-O 386 register structure.
type Regs386 struct { type Regs386 struct {
AX uint32 AX uint32
@ -332,5 +464,5 @@ func stringName(i uint32, names []intName, goSyntax bool) string {
return n.s return n.s
} }
} }
return strconv.FormatUint(uint64(i), 10) return "0x" + strconv.FormatUint(uint64(i), 16)
} }

394
cmd/splitdwarf/splitdwarf.go Normal file
View File

@ -0,0 +1,394 @@
// Copyright 2018 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.
// +build !js,!nacl,!plan9,!solaris,!windows
package main
import (
"crypto/sha256"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"syscall"
"golang.org/x/tools/cmd/splitdwarf/internal/macho"
)
const (
pageAlign = 12 // 4096 = 1 << 12
)
func note(format string, why ...interface{}) {
fmt.Fprintf(os.Stderr, format+"\n", why...)
}
func fail(format string, why ...interface{}) {
note(format, why...)
os.Exit(1)
}
// splitdwarf inputexe [ outputdwarf ]
func main() {
if len(os.Args) < 2 || len(os.Args) > 3 {
fmt.Printf(`
Usage: %s input_exe [ output_dsym ]
Reads the executable input_exe, uncompresses and copies debugging
information into output_dsym. If output_dsym is not specified,
the path
input_exe.dSYM/Contents/Resources/DWARF/input_exe
is used instead. That is the path that gdb and lldb expect
on OSX. Input_exe needs a UUID segment; if that is missing,
then one is created and added. In that case, the permissions
for input_exe need to allow writing.
`, os.Args[0])
return
}
// Read input, find DWARF, be sure it looks right
inputExe := os.Args[1]
exeFile, err := os.Open(inputExe)
if err != nil {
fail("%v", err)
}
exeMacho, err := macho.NewFile(exeFile)
if err != nil {
fail("(internal) Couldn't create macho, %v", err)
}
// Postpone dealing with output till input is known-good
// describe(&exeMacho.FileTOC)
// Offsets into __LINKEDIT:
//
// Command LC_SYMTAB =
// (1) number of symbols at file offset (within link edit section) of 16-byte symbol table entries
// struct {
// StringTableIndex uint32
// Type, SectionIndex uint8
// Description uint16
// Value uint64
// }
//
// (2) string table offset and size. Strings are zero-byte terminated. First must be " ".
//
// Command LC_DYSYMTAB = indices within symtab (above), except for IndSym
// IndSym Offset = file offset (within link edit section) of 4-byte indices within symtab.
//
// Section __TEXT.__symbol_stub1.
// Offset and size (Reserved2) locate and describe a table for thios section.
// Symbols beginning at IndirectSymIndex (Reserved1) (see LC_DYSYMTAB.IndSymOffset) refer to this table.
// (These table entries are apparently PLTs [Procedure Linkage Table/Trampoline])
//
// Section __DATA.__nl_symbol_ptr.
// Reserved1 seems to be an index within the Indirect symbols (see LC_DYSYMTAB.IndSymOffset)
// Some of these symbols appear to be duplicates of other indirect symbols appearing early
//
// Section __DATA.__la_symbol_ptr.
// Reserved1 seems to be an index within the Indirect symbols (see LC_DYSYMTAB.IndSymOffset)
// Some of these symbols appear to be duplicates of other indirect symbols appearing early
//
// Create a File for the output dwarf.
// Copy header, file type is MH_DSYM
// Copy the relevant load commands
// LoadCmdUuid
// Symtab -- very abbreviated (Use DYSYMTAB Iextdefsym, Nextdefsym to identify these).
// Segment __PAGEZERO
// Segment __TEXT (zero the size, zero the offset of each section)
// Segment __DATA (zero the size, zero the offset of each section)
// Segment __LINKEDIT (contains the symbols and strings from Symtab)
// Segment __DWARF (uncompressed)
var uuid *macho.Uuid
for _, l := range exeMacho.Loads {
switch l.Command() {
case macho.LcUuid:
uuid = l.(*macho.Uuid)
}
}
// Ensure a given load is not nil
nonnilC := func(l macho.Load, s string) {
if l == nil {
fail("input file %s lacks load command %s", inputExe, s)
}
}
// Find a segment by name and ensure it is not nil
nonnilS := func(s string) *macho.Segment {
l := exeMacho.Segment(s)
if l == nil {
fail("input file %s lacks segment %s", inputExe, s)
}
return l
}
newtoc := exeMacho.FileTOC.DerivedCopy(macho.MhDsym, 0)
symtab := exeMacho.Symtab
dysymtab := exeMacho.Dysymtab // Not appearing in output, but necessary to construct output
nonnilC(symtab, "symtab")
nonnilC(dysymtab, "dysymtab")
text := nonnilS("__TEXT")
data := nonnilS("__DATA")
linkedit := nonnilS("__LINKEDIT")
pagezero := nonnilS("__PAGEZERO")
newtext := text.CopyZeroed()
newdata := data.CopyZeroed()
newsymtab := symtab.Copy()
// Linkedit segment contain symbols and strings;
// Symtab refers to offsets into linkedit.
// This next bit initializes newsymtab and sets up data structures for the linkedit segment
linkeditsyms := []macho.Nlist64{}
linkeditstrings := []string{}
// Linkedit will begin at the second page, i.e., offset is one page from beginning
// Symbols come first
linkeditsymbase := uint32(1) << pageAlign
// Strings come second, offset by the number of symbols times their size.
// Only those symbols from dysymtab.defsym are written into the debugging information.
linkeditstringbase := linkeditsymbase + exeMacho.FileTOC.SymbolSize()*dysymtab.Nextdefsym
// The first two bytes of the strings are reserved for space, null (' ', \000)
linkeditstringcur := uint32(2)
newsymtab.Syms = newsymtab.Syms[:0]
newsymtab.Symoff = linkeditsymbase
newsymtab.Stroff = linkeditstringbase
newsymtab.Nsyms = dysymtab.Nextdefsym
for i := uint32(0); i < dysymtab.Nextdefsym; i++ {
ii := i + dysymtab.Iextdefsym
oldsym := symtab.Syms[ii]
newsymtab.Syms = append(newsymtab.Syms, oldsym)
linkeditsyms = append(linkeditsyms, macho.Nlist64{Name: uint32(linkeditstringcur),
Type: oldsym.Type, Sect: oldsym.Sect, Desc: oldsym.Desc, Value: oldsym.Value})
linkeditstringcur += uint32(len(oldsym.Name)) + 1
linkeditstrings = append(linkeditstrings, oldsym.Name)
}
newsymtab.Strsize = linkeditstringcur
exeNeedsUuid := uuid == nil
if exeNeedsUuid {
uuid = &macho.Uuid{macho.UuidCmd{LoadCmd: macho.LcUuid}}
uuid.Len = uuid.LoadSize(newtoc)
copy(uuid.Id[0:], contentuuid(&exeMacho.FileTOC)[0:16])
uuid.Id[6] = uuid.Id[6]&^0xf0 | 0x40 // version 4 (pseudo-random); see section 4.1.3
uuid.Id[8] = uuid.Id[8]&^0xc0 | 0x80 // variant bits; see section 4.1.1
}
newtoc.AddLoad(uuid)
// For the specified segment (assumed to be in exeMacho) make a copy of its
// sections with appropriate fields zeroed out, and append them to the
// currently-last segment in newtoc.
copyZOdSections := func(g *macho.Segment) {
for i := g.Firstsect; i < g.Firstsect+g.Nsect; i++ {
s := exeMacho.Sections[i].Copy()
s.Offset = 0
s.Reloff = 0
s.Nreloc = 0
newtoc.AddSection(s)
}
}
newtoc.AddLoad(newsymtab)
newtoc.AddSegment(pagezero)
newtoc.AddSegment(newtext)
copyZOdSections(text)
newtoc.AddSegment(newdata)
copyZOdSections(data)
newlinkedit := linkedit.Copy()
newlinkedit.Offset = uint64(linkeditsymbase)
newlinkedit.Filesz = uint64(linkeditstringcur)
newlinkedit.Addr = macho.RoundUp(newdata.Addr+newdata.Memsz, 1<<pageAlign) // Follows data sections in file
newlinkedit.Memsz = macho.RoundUp(newlinkedit.Filesz, 1<<pageAlign)
// The rest should copy over fine.
newtoc.AddSegment(newlinkedit)
dwarf := nonnilS("__DWARF")
newdwarf := dwarf.CopyZeroed()
newdwarf.Offset = macho.RoundUp(newlinkedit.Offset+newlinkedit.Filesz, 1<<pageAlign)
newdwarf.Filesz = dwarf.UncompressedSize(&exeMacho.FileTOC, 1)
newdwarf.Addr = newlinkedit.Addr + newlinkedit.Memsz // Follows linkedit sections in file.
newdwarf.Memsz = macho.RoundUp(newdwarf.Filesz, 1<<pageAlign)
newtoc.AddSegment(newdwarf)
// Map out Dwarf sections (that is, this is section descriptors, not their contents).
offset := uint32(newdwarf.Offset)
for i := dwarf.Firstsect; i < dwarf.Firstsect+dwarf.Nsect; i++ {
o := exeMacho.Sections[i]
s := o.Copy()
s.Offset = offset
us := o.UncompressedSize()
if s.Size < us {
s.Size = uint64(us)
s.Align = 0 // This is apparently true for debugging sections; not sure if it generalizes.
}
offset += uint32(us)
if strings.HasPrefix(s.Name, "__z") {
s.Name = "__" + s.Name[3:] // remove "z"
}
s.Reloff = 0
s.Nreloc = 0
newtoc.AddSection(s)
}
// Write segments/sections.
// Only dwarf and linkedit contain anything interesting.
// Memory map the output file to get the buffer directly.
outDwarf := inputExe + ".dSYM/Contents/Resources/DWARF"
if len(os.Args) > 2 {
outDwarf = os.Args[2]
} else {
err := os.MkdirAll(outDwarf, 0755)
if err != nil {
fail("%v", err)
}
outDwarf = filepath.Join(outDwarf, filepath.Base(inputExe))
}
dwarfFile, buffer := CreateMmapFile(outDwarf, int64(newtoc.FileSize()))
// (1) Linkedit segment
// Symbol table
offset = uint32(newlinkedit.Offset)
for i := range linkeditsyms {
if exeMacho.Magic == macho.Magic64 {
offset += linkeditsyms[i].Put64(buffer[offset:], newtoc.ByteOrder)
} else {
offset += linkeditsyms[i].Put32(buffer[offset:], newtoc.ByteOrder)
}
}
// Initial two bytes of string table, followed by actual zero-terminated strings.
buffer[linkeditstringbase] = ' '
buffer[linkeditstringbase+1] = 0
offset = linkeditstringbase + 2
for _, str := range linkeditstrings {
for i := 0; i < len(str); i++ {
buffer[offset] = str[i]
offset++
}
buffer[offset] = 0
offset++
}
// (2) DWARF segment
ioff := newdwarf.Firstsect - dwarf.Firstsect
for i := dwarf.Firstsect; i < dwarf.Firstsect+dwarf.Nsect; i++ {
s := exeMacho.Sections[i]
j := i + ioff
s.PutUncompressedData(buffer[newtoc.Sections[j].Offset:])
}
// Because "text" overlaps the header and the loads, write them afterwards, just in case.
// Write header.
newtoc.Put(buffer)
err = syscall.Munmap(buffer)
if err != nil {
fail("Munmap %s for dwarf output failed, %v", outDwarf, err)
}
err = dwarfFile.Close()
if err != nil {
fail("Close %s for dwarf output after mmap/munmap failed, %v", outDwarf, err)
}
if exeNeedsUuid { // Map the original exe, modify the header, and write the UUID command
hdr := exeMacho.FileTOC.FileHeader
oldCommandEnd := hdr.SizeCommands + newtoc.HdrSize()
hdr.NCommands += 1
hdr.SizeCommands += uuid.LoadSize(newtoc)
mapf, err := os.OpenFile(inputExe, os.O_RDWR, 0)
if err != nil {
fail("Updating UUID in binary failed, %v", err)
}
exebuf, err := syscall.Mmap(int(mapf.Fd()), 0, int(macho.RoundUp(uint64(hdr.SizeCommands), 1<<pageAlign)),
syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_FILE|syscall.MAP_SHARED)
if err != nil {
fail("Mmap of %s for UUID update failed, %v", inputExe, err)
}
_ = hdr.Put(exebuf, newtoc.ByteOrder)
_ = uuid.Put(exebuf[oldCommandEnd:], newtoc.ByteOrder)
err = syscall.Munmap(exebuf)
if err != nil {
fail("Munmap of %s for UUID update failed, %v", inputExe, err)
}
}
}
// CreateMmapFile creates the file 'outDwarf' of the specified size, mmaps that file,
// and returns the file descriptor and mapped buffer.
func CreateMmapFile(outDwarf string, size int64) (*os.File, []byte) {
dwarfFile, err := os.OpenFile(outDwarf, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
fail("Open for mmap failed, %v", err)
}
err = os.Truncate(outDwarf, size)
if err != nil {
fail("Truncate/extend of %s to %d bytes failed, %v", dwarfFile, size, err)
}
buffer, err := syscall.Mmap(int(dwarfFile.Fd()), 0, int(size), syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_FILE|syscall.MAP_SHARED)
if err != nil {
fail("Mmap %s for dwarf output update failed, %v", outDwarf, err)
}
return dwarfFile, buffer
}
func describe(exem *macho.FileTOC) {
note("Type = %s, Flags=0x%x", exem.Type, uint32(exem.Flags))
for i, l := range exem.Loads {
if s, ok := l.(*macho.Segment); ok {
fmt.Printf("Load %d is Segment %s, offset=0x%x, filesz=%d, addr=0x%x, memsz=%d, nsect=%d\n", i, s.Name,
s.Offset, s.Filesz, s.Addr, s.Memsz, s.Nsect)
for j := uint32(0); j < s.Nsect; j++ {
c := exem.Sections[j+s.Firstsect]
fmt.Printf(" Section %s, offset=0x%x, size=%d, addr=0x%x, flags=0x%x, nreloc=%d, res1=%d, res2=%d, res3=%d\n", c.Name, c.Offset, c.Size, c.Addr, c.Flags, c.Nreloc, c.Reserved1, c.Reserved2, c.Reserved3)
}
} else {
fmt.Printf("Load %d is %v\n", i, l)
}
}
if exem.SizeCommands != exem.LoadSize() {
fail("recorded command size %d does not equal computed command size %d", exem.SizeCommands, exem.LoadSize())
} else {
note("recorded command size %d, computed command size %d", exem.SizeCommands, exem.LoadSize())
}
note("File size is %d", exem.FileSize())
}
// contentuuid returns a UUID derived from (some of) the content of an executable.
// specifically included are the non-DWARF sections, specifically excluded are things
// that surely depend on the presence or absence of DWARF sections (e.g., section
// numbers, positions with file, number of load commands).
// (It was considered desirable if this was insensitive to the presence of the
// __DWARF segment, however because it is not last, it moves other segments,
// whose contents appear to contain file offset references.)
func contentuuid(exem *macho.FileTOC) []byte {
h := sha256.New()
for _, l := range exem.Loads {
if l.Command() == macho.LcUuid {
continue
}
if s, ok := l.(*macho.Segment); ok {
if s.Name == "__DWARF" || s.Name == "__PAGEZERO" {
continue
}
for j := uint32(0); j < s.Nsect; j++ {
c := exem.Sections[j+s.Firstsect]
io.Copy(h, c.Open())
}
} // Getting dependence on other load commands right is fiddly.
}
return h.Sum(nil)
}