-
Notifications
You must be signed in to change notification settings - Fork 2.2k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
The splitdwarf command will need a modified version of debug/macho. This is a verbatim copy from std as of Go 1.11, which we'll modify in the next CL. Change-Id: Ia9ded870d1ba91dad21f9f6dc5bb38f9f6cc0e80 Reviewed-on: https://go-review.googlesource.com/c/152240 Run-TryBot: David Chase <drchase@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> Reviewed-by: David Chase <drchase@google.com>
- Loading branch information
Showing
15 changed files
with
1,678 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,146 @@ | ||
// Copyright 2014 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 | ||
|
||
import ( | ||
"encoding/binary" | ||
"fmt" | ||
"io" | ||
"os" | ||
) | ||
|
||
// A FatFile is a Mach-O universal binary that contains at least one architecture. | ||
type FatFile struct { | ||
Magic uint32 | ||
Arches []FatArch | ||
closer io.Closer | ||
} | ||
|
||
// A FatArchHeader represents a fat header for a specific image architecture. | ||
type FatArchHeader struct { | ||
Cpu Cpu | ||
SubCpu uint32 | ||
Offset uint32 | ||
Size uint32 | ||
Align uint32 | ||
} | ||
|
||
const fatArchHeaderSize = 5 * 4 | ||
|
||
// A FatArch is a Mach-O File inside a FatFile. | ||
type FatArch struct { | ||
FatArchHeader | ||
*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 | ||
// universal binary. The Mach-O binary is expected to start at position 0 in | ||
// the ReaderAt. | ||
func NewFatFile(r io.ReaderAt) (*FatFile, error) { | ||
var ff FatFile | ||
sr := io.NewSectionReader(r, 0, 1<<63-1) | ||
|
||
// Read the fat_header struct, which is always in big endian. | ||
// Start with the magic number. | ||
err := binary.Read(sr, binary.BigEndian, &ff.Magic) | ||
if err != nil { | ||
return nil, &FormatError{0, "error reading magic number", nil} | ||
} else if ff.Magic != MagicFat { | ||
// See if this is a Mach-O file via its magic number. The magic | ||
// must be converted to little endian first though. | ||
var buf [4]byte | ||
binary.BigEndian.PutUint32(buf[:], ff.Magic) | ||
leMagic := binary.LittleEndian.Uint32(buf[:]) | ||
if leMagic == Magic32 || leMagic == Magic64 { | ||
return nil, ErrNotFat | ||
} else { | ||
return nil, &FormatError{0, "invalid magic number", nil} | ||
} | ||
} | ||
offset := int64(4) | ||
|
||
// Read the number of FatArchHeaders that come after the fat_header. | ||
var narch uint32 | ||
err = binary.Read(sr, binary.BigEndian, &narch) | ||
if err != nil { | ||
return nil, &FormatError{offset, "invalid fat_header", nil} | ||
} | ||
offset += 4 | ||
|
||
if narch < 1 { | ||
return nil, &FormatError{offset, "file contains no images", nil} | ||
} | ||
|
||
// Combine the Cpu and SubCpu (both uint32) into a uint64 to make sure | ||
// there are not duplicate architectures. | ||
seenArches := make(map[uint64]bool, narch) | ||
// Make sure that all images are for the same MH_ type. | ||
var machoType Type | ||
|
||
// Following the fat_header comes narch fat_arch structs that index | ||
// Mach-O images further in the file. | ||
ff.Arches = make([]FatArch, narch) | ||
for i := uint32(0); i < narch; i++ { | ||
fa := &ff.Arches[i] | ||
err = binary.Read(sr, binary.BigEndian, &fa.FatArchHeader) | ||
if err != nil { | ||
return nil, &FormatError{offset, "invalid fat_arch header", nil} | ||
} | ||
offset += fatArchHeaderSize | ||
|
||
fr := io.NewSectionReader(r, int64(fa.Offset), int64(fa.Size)) | ||
fa.File, err = NewFile(fr) | ||
if err != nil { | ||
return nil, err | ||
} | ||
|
||
// Make sure the architecture for this image is not duplicate. | ||
seenArch := (uint64(fa.Cpu) << 32) | uint64(fa.SubCpu) | ||
if o, k := seenArches[seenArch]; o || k { | ||
return nil, &FormatError{offset, fmt.Sprintf("duplicate architecture cpu=%v, subcpu=%#x", fa.Cpu, fa.SubCpu), nil} | ||
} | ||
seenArches[seenArch] = true | ||
|
||
// Make sure the Mach-O type matches that of the first image. | ||
if i == 0 { | ||
machoType = fa.Type | ||
} else { | ||
if 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 &ff, nil | ||
} | ||
|
||
// OpenFat opens the named file using os.Open and prepares it for use as a Mach-O | ||
// universal binary. | ||
func OpenFat(name string) (*FatFile, error) { | ||
f, err := os.Open(name) | ||
if err != nil { | ||
return nil, err | ||
} | ||
ff, err := NewFatFile(f) | ||
if err != nil { | ||
f.Close() | ||
return nil, err | ||
} | ||
ff.closer = f | ||
return ff, nil | ||
} | ||
|
||
func (ff *FatFile) Close() error { | ||
var err error | ||
if ff.closer != nil { | ||
err = ff.closer.Close() | ||
ff.closer = nil | ||
} | ||
return err | ||
} |
Oops, something went wrong.