Source file src/debug/macho/fat.go

Documentation: debug/macho

     1  // Copyright 2014 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  package macho
     6  
     7  import (
     8  	"encoding/binary"
     9  	"fmt"
    10  	"io"
    11  	"os"
    12  )
    13  
    14  // A FatFile is a Mach-O universal binary that contains at least one architecture.
    15  type FatFile struct {
    16  	Magic  uint32
    17  	Arches []FatArch
    18  	closer io.Closer
    19  }
    20  
    21  // A FatArchHeader represents a fat header for a specific image architecture.
    22  type FatArchHeader struct {
    23  	Cpu    Cpu
    24  	SubCpu uint32
    25  	Offset uint32
    26  	Size   uint32
    27  	Align  uint32
    28  }
    29  
    30  const fatArchHeaderSize = 5 * 4
    31  
    32  // A FatArch is a Mach-O File inside a FatFile.
    33  type FatArch struct {
    34  	FatArchHeader
    35  	*File
    36  }
    37  
    38  // ErrNotFat is returned from NewFatFile or OpenFat when the file is not a
    39  // universal binary but may be a thin binary, based on its magic number.
    40  var ErrNotFat = &FormatError{0, "not a fat Mach-O file", nil}
    41  
    42  // NewFatFile creates a new FatFile for accessing all the Mach-O images in a
    43  // universal binary. The Mach-O binary is expected to start at position 0 in
    44  // the ReaderAt.
    45  func NewFatFile(r io.ReaderAt) (*FatFile, error) {
    46  	var ff FatFile
    47  	sr := io.NewSectionReader(r, 0, 1<<63-1)
    48  
    49  	// Read the fat_header struct, which is always in big endian.
    50  	// Start with the magic number.
    51  	err := binary.Read(sr, binary.BigEndian, &ff.Magic)
    52  	if err != nil {
    53  		return nil, &FormatError{0, "error reading magic number", nil}
    54  	} else if ff.Magic != MagicFat {
    55  		// See if this is a Mach-O file via its magic number. The magic
    56  		// must be converted to little endian first though.
    57  		var buf [4]byte
    58  		binary.BigEndian.PutUint32(buf[:], ff.Magic)
    59  		leMagic := binary.LittleEndian.Uint32(buf[:])
    60  		if leMagic == Magic32 || leMagic == Magic64 {
    61  			return nil, ErrNotFat
    62  		} else {
    63  			return nil, &FormatError{0, "invalid magic number", nil}
    64  		}
    65  	}
    66  	offset := int64(4)
    67  
    68  	// Read the number of FatArchHeaders that come after the fat_header.
    69  	var narch uint32
    70  	err = binary.Read(sr, binary.BigEndian, &narch)
    71  	if err != nil {
    72  		return nil, &FormatError{offset, "invalid fat_header", nil}
    73  	}
    74  	offset += 4
    75  
    76  	if narch < 1 {
    77  		return nil, &FormatError{offset, "file contains no images", nil}
    78  	}
    79  
    80  	// Combine the Cpu and SubCpu (both uint32) into a uint64 to make sure
    81  	// there are not duplicate architectures.
    82  	seenArches := make(map[uint64]bool, narch)
    83  	// Make sure that all images are for the same MH_ type.
    84  	var machoType Type
    85  
    86  	// Following the fat_header comes narch fat_arch structs that index
    87  	// Mach-O images further in the file.
    88  	ff.Arches = make([]FatArch, narch)
    89  	for i := uint32(0); i < narch; i++ {
    90  		fa := &ff.Arches[i]
    91  		err = binary.Read(sr, binary.BigEndian, &fa.FatArchHeader)
    92  		if err != nil {
    93  			return nil, &FormatError{offset, "invalid fat_arch header", nil}
    94  		}
    95  		offset += fatArchHeaderSize
    96  
    97  		fr := io.NewSectionReader(r, int64(fa.Offset), int64(fa.Size))
    98  		fa.File, err = NewFile(fr)
    99  		if err != nil {
   100  			return nil, err
   101  		}
   102  
   103  		// Make sure the architecture for this image is not duplicate.
   104  		seenArch := (uint64(fa.Cpu) << 32) | uint64(fa.SubCpu)
   105  		if o, k := seenArches[seenArch]; o || k {
   106  			return nil, &FormatError{offset, fmt.Sprintf("duplicate architecture cpu=%v, subcpu=%#x", fa.Cpu, fa.SubCpu), nil}
   107  		}
   108  		seenArches[seenArch] = true
   109  
   110  		// Make sure the Mach-O type matches that of the first image.
   111  		if i == 0 {
   112  			machoType = fa.Type
   113  		} else {
   114  			if fa.Type != machoType {
   115  				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}
   116  			}
   117  		}
   118  	}
   119  
   120  	return &ff, nil
   121  }
   122  
   123  // OpenFat opens the named file using os.Open and prepares it for use as a Mach-O
   124  // universal binary.
   125  func OpenFat(name string) (*FatFile, error) {
   126  	f, err := os.Open(name)
   127  	if err != nil {
   128  		return nil, err
   129  	}
   130  	ff, err := NewFatFile(f)
   131  	if err != nil {
   132  		f.Close()
   133  		return nil, err
   134  	}
   135  	ff.closer = f
   136  	return ff, nil
   137  }
   138  
   139  func (ff *FatFile) Close() error {
   140  	var err error
   141  	if ff.closer != nil {
   142  		err = ff.closer.Close()
   143  		ff.closer = nil
   144  	}
   145  	return err
   146  }
   147  

View as plain text