Add support for fat Mach-O files (#411)

Add support for fat Mach-O files

Fixes #1033. Note that this does not do the "correct" thing, of checking the main executable to see what architecture it is and trying to match that. Or maybe checking the architecture in the profile file if it is present.

Instead it just uses the host architecture to decide which subfile of the fat archive to open.

internal/binutils/binutils.go

 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"runtime"
 	"strings"
 	"sync"
 
 
 	f, err := os.Open(name)
 	if err != nil {
-		return nil, fmt.Errorf("error opening %s: %s", name, err)
+		return nil, fmt.Errorf("error opening %s: %v", name, err)
 	}
 	defer f.Close()
 
 	var header [4]byte
 	if _, err = io.ReadFull(f, header[:]); err != nil {
-		return nil, fmt.Errorf("error reading magic number from %s: %s", name, err)
+		return nil, fmt.Errorf("error reading magic number from %s: %v", name, err)
 	}
 
 	elfMagic := string(header[:])
 	if elfMagic == elf.ELFMAG {
 		f, err := b.openELF(name, start, limit, offset)
 		if err != nil {
-			return nil, fmt.Errorf("error reading ELF file %s: %s", name, err)
+			return nil, fmt.Errorf("error reading ELF file %s: %v", name, err)
 		}
 		return f, nil
 	}
 		machoMagicBig == macho.Magic32 || machoMagicBig == macho.Magic64 {
 		f, err := b.openMachO(name, start, limit, offset)
 		if err != nil {
-			return nil, fmt.Errorf("error reading Mach-O file %s: %s", name, err)
+			return nil, fmt.Errorf("error reading Mach-O file %s: %v", name, err)
 		}
 		return f, nil
 	}
 	if machoMagicLittle == macho.MagicFat || machoMagicBig == macho.MagicFat {
-		// TODO: #1033
-		return nil, fmt.Errorf("fat Mach-O archives are currently unsupported")
+		f, err := b.openFatMachO(name, start, limit, offset)
+		if err != nil {
+			return nil, fmt.Errorf("error reading fat Mach-O file %s: %v", name, err)
+		}
+		return f, nil
 	}
 
 	return nil, fmt.Errorf("unrecognized binary format: %s", name)
 }
 
-func (b *binrep) openMachO(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
-	of, err := macho.Open(name)
-	if err != nil {
-		return nil, fmt.Errorf("error parsing %s: %v", name, err)
-	}
-	defer of.Close()
+func (b *binrep) openMachOCommon(name string, of *macho.File, start, limit, offset uint64) (plugin.ObjFile, error) {
 
 	// Subtract the load address of the __TEXT section. Usually 0 for shared
 	// libraries or 0x100000000 for executables. You can check this value by
 	return &fileAddr2Line{file: file{b: b, name: name, base: base}}, nil
 }
 
+func (b *binrep) openFatMachO(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	of, err := macho.OpenFat(name)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing %s: %v", name, err)
+	}
+	defer of.Close()
+
+	if len(of.Arches) == 0 {
+		return nil, fmt.Errorf("empty fat Mach-O file: %s", name)
+	}
+
+	var arch macho.Cpu
+	// Use the host architecture.
+	// TODO: This is not ideal because the host architecture may not be the one
+	// that was profiled. E.g. an amd64 host can profile a 386 program.
+	switch runtime.GOARCH {
+	case "386":
+		arch = macho.Cpu386
+	case "amd64", "amd64p32":
+		arch = macho.CpuAmd64
+	case "arm", "armbe", "arm64", "arm64be":
+		arch = macho.CpuArm
+	case "ppc":
+		arch = macho.CpuPpc
+	case "ppc64", "ppc64le":
+		arch = macho.CpuPpc64
+	default:
+		return nil, fmt.Errorf("unsupported host architecture for %s: %s", name, runtime.GOARCH)
+	}
+	for i := range of.Arches {
+		if of.Arches[i].Cpu == arch {
+			return b.openMachOCommon(name, of.Arches[i].File, start, limit, offset)
+		}
+	}
+	return nil, fmt.Errorf("architecture not found in %s: %s", name, runtime.GOARCH)
+}
+
+func (b *binrep) openMachO(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	of, err := macho.Open(name)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing %s: %v", name, err)
+	}
+	defer of.Close()
+
+	return b.openMachOCommon(name, of, start, limit, offset)
+}
+
 func (b *binrep) openELF(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
 	ef, err := elf.Open(name)
 	if err != nil {