// 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.

// Mach-O header data structures
// http://developer.apple.com/mac/library/documentation/DeveloperTools/Conceptual/MachORuntime/Reference/reference.html

package macho

import "strconv"

// A FileHeader represents a Mach-O file header.
type FileHeader struct {
	Magic	uint32;
	Cpu	Cpu;
	SubCpu	uint32;
	Type	Type;
	Ncmd	uint32;
	Cmdsz	uint32;
	Flags	uint32;
}
const (
	fileHeaderSize32 = 7*4;
	fileHeaderSize64 = 8*4;
)

const (
	Magic32 uint32 = 0xfeedface;
	Magic64 uint32 = 0xfeedfacf;
)

// A Type is a Mach-O file type, either an object or an executable.
type Type uint32
const (
	TypeObj Type = 1;
	TypeExec Type = 2;
)

// A Cpu is a Mach-O cpu type.
type Cpu uint32
const (
	Cpu386 Cpu = 7;
	CpuAmd64 Cpu = Cpu386 + 1<<24;
)

var cpuStrings = []intName {
	intName{ uint32(Cpu386), "Cpu386" },
	intName{ uint32(CpuAmd64), "CpuAmd64" },
}
func (i Cpu) String() string {
	return stringName(uint32(i), cpuStrings, false)
}
func (i Cpu) GoString() string {
	return stringName(uint32(i), cpuStrings, true)
}

// A LoadCmd is a Mach-O load command.
type LoadCmd uint32;
const (
	LoadCmdSegment LoadCmd = 1;
	LoadCmdSegment64 LoadCmd = 25;
	LoadCmdThread LoadCmd = 4;
	LoadCmdUnixThread LoadCmd = 5;	// thread+stack
)
var cmdStrings = []intName {
	intName{ uint32(LoadCmdSegment), "LoadCmdSegment" },
	intName{ uint32(LoadCmdSegment64), "LoadCmdSegment64" },
	intName{ uint32(LoadCmdThread), "LoadCmdThread" },
	intName{ uint32(LoadCmdUnixThread), "LoadCmdUnixThread" },
}
func (i LoadCmd) String() string {
	return stringName(uint32(i), cmdStrings, false)
}
func (i LoadCmd) GoString() string {
	return stringName(uint32(i), cmdStrings, true)
}

// A Segment64 is a 64-bit Mach-O segment load command.
type Segment64 struct {
	Cmd	LoadCmd;
	Len	uint32;
	Name	[16]byte;
	Addr	uint64;
	Memsz	uint64;
	Offset	uint64;
	Filesz	uint64;
	Maxprot	uint32;
	Prot	uint32;
	Nsect	uint32;
	Flag	uint32;
}

// A Segment32 is a 32-bit Mach-O segment load command.
type Segment32 struct {
	Cmd	LoadCmd;
	Len	uint32;
	Name	[16]byte;
	Addr	uint32;
	Memsz	uint32;
	Offset	uint32;
	Filesz	uint32;
	Maxprot	uint32;
	Prot	uint32;
	Nsect	uint32;
	Flag	uint32;
}

// A Section32 is a 32-bit Mach-O section header.
type Section32 struct {
	Name	[16]byte;
	Seg		[16]byte;
	Addr	uint32;
	Size	uint32;
	Offset	uint32;
	Align	uint32;
	Reloff	uint32;
	Nreloc	uint32;
	Flags	uint32;
	Reserve1	uint32;
	Reserve2	uint32;
}

// A Section32 is a 64-bit Mach-O section header.
type Section64 struct {
	Name	[16]byte;
	Seg		[16]byte;
	Addr	uint64;
	Size	uint64;
	Offset	uint32;
	Align	uint32;
	Reloff	uint32;
	Nreloc	uint32;
	Flags	uint32;
	Reserve1	uint32;
	Reserve2	uint32;
	Reserve3	uint32;
}

// A Thread is a Mach-O thread state command.
type Thread struct {
	Cmd	LoadCmd;
	Len	uint32;
	Type	uint32;
	Data	[]uint32;
}

// Regs386 is the Mach-O 386 register structure.
type Regs386 struct {
	AX	uint32;
	BX	uint32;
	CX	uint32;
	DX	uint32;
	DI	uint32;
	SI	uint32;
	BP	uint32;
	SP	uint32;
	SS	uint32;
	FLAGS	uint32;
	IP	uint32;
	CS	uint32;
	DS	uint32;
	ES	uint32;
	FS	uint32;
	GS	uint32;
}

// RegsAMD64 is the Mach-O AMD64 register structure.
type RegsAMD64 struct {
	AX	uint64;
	BX	uint64;
	CX	uint64;
	DX	uint64;
	DI	uint64;
	SI	uint64;
	BP	uint64;
	SP	uint64;
	R8	uint64;
	R9	uint64;
	R10	uint64;
	R11	uint64;
	R12	uint64;
	R13	uint64;
	R14	uint64;
	R15	uint64;
	IP	uint64;
	FLAGS	uint64;
	CS	uint64;
	FS	uint64;
	GS	uint64;
}

type intName struct {
	i uint32;
	s string;
}

func stringName(i uint32, names []intName, goSyntax bool) string {
	for _, n := range names {
		if n.i == i {
			if goSyntax {
				return "macho." + n.s
			}
			return n.s
		}
	}
	return strconv.Uitoa64(uint64(i))
}

func flagName(i uint32, names []intName, goSyntax bool) string {
	s := "";
	for _, n := range names {
		if n.i & i == n.i {
			if len(s) > 0 {
				s += "+";
			}
			if goSyntax {
				s += "macho.";
			}
			s += n.s;
			i -= n.i;
		}
	}
	if len(s) == 0 {
		return "0x" + strconv.Uitob64(uint64(i), 16)
	}
	if i != 0 {
		s += "+0x" + strconv.Uitob64(uint64(i), 16)
	}
	return s
}