/**
 * Copyright: Copyright (c) 2009 Jacob Carlborg.
 * Authors: Jacob Carlborg
 * Version: Initial created: Jul 21, 2009 
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
 */
module dstep.coreservices.carboncore.PEFBinaryFormat;

//import dstep.AvailabilityMacros;
import dstep.coreservices.carboncore.MacTypes;
import dstep.internal.Types;
import dstep.objc.bridge.TypeEncoding;

alias ushort PEFRelocChunk;
alias PEFExportedSymbolHashSlot XLibExportedSymbolHashSlot;
alias PEFExportedSymbolKey XLibExportedSymbolKey;

struct PEFContainerHeader
{
	uint tag1;
	uint tag2;
	uint architecture;
	uint formatVersion;
	uint dateTimeStamp;
	uint oldDefVersion;
	uint oldImpVersion;
	uint currentVersion;
	ushort sectionCount;
	ushort instSectionCount;
	uint reservedA;
}

// This is needed otherwise the enums will fail compiling with gdc
version (GNU)
{
	private
	{
		const __kPEFTag1 = getOSType!("Joy!");
		const __kPEFTag2 = getOSType!("peff");
	}
}

// This is needed otherwise the enums will fail compiling with gdc
version (GNU)
{
	private
	{
		const __kVLibTag2 = getOSType!("VLib");
		const __kBLibTag2 = getOSType!("BLib");
	}
}

enum
{
	kPEFTag1 = getOSType!("Joy!"),
	kPEFTag2 = getOSType!("peff"),
	kPEFVersion = 0x00000001
}

enum
{
	kPEFFirstSectionHeaderOffset = PEFContainerHeader.sizeof
}

enum
{
	kPEFCodeSection = 0,
	kPEFUnpackedDataSection = 1,
	kPEFPackedDataSection = 2,
	kPEFConstantSection = 3,
	kPEFExecDataSection = 6,
	kPEFLoaderSection = 4,
	kPEFDebugSection = 5,
	kPEFExceptionSection = 7,
	kPEFTracebackSection = 8
}

enum
{
	kPEFProcessShare = 1,
	kPEFGlobalShare = 4,
	kPEFProtectedShare = 5
}

enum
{
	kPEFPkDataZero = 0,
	kPEFPkDataBlock = 1,
	kPEFPkDataRepeat = 2,
	kPEFPkDataRepeatBlock = 3,
	kPEFPkDataRepeatZero = 4
}

enum
{
	kPEFPkDataOpcodeShift = 5,
	kPEFPkDataCount5Mask = 0x1F,
	kPEFPkDataMaxCount5 = 31,
	kPEFPkDataVCountShift = 7,
	kPEFPkDataVCountMask = 0x7F,
	kPEFPkDataVCountEndMask = 0x80
}

enum
{
	kPEFWeakImportLibMask = 0x40,
	kPEFInitLibBeforeMask = 0x80
}

enum
{
	kPEFImpSymClassShift = 24,
	kPEFImpSymNameOffsetMask = 0x00FFFFFF,
	kPEFImpSymMaxNameOffset = 0x00FFFFFF
}

enum
{
	kPEFCodeSymbol = 0x00,
	kPEFDataSymbol = 0x01,
	kPEFTVectorSymbol = 0x02,
	kPEFTOCSymbol = 0x03,
	kPEFGlueSymbol = 0x04,
	kPEFUndefinedSymbol = 0x0F,
	kPEFWeakImportSymMask = 0x80
}

enum
{
	kPEFHashSlotSymCountShift = 18,
	kPEFHashSlotFirstKeyMask = 0x0003FFFF,
	kPEFHashSlotMaxSymbolCount = 0x00003FFF,
	kPEFHashSlotMaxKeyIndex = 0x0003FFFF
}

enum
{
	kPEFHashLengthShift = 16,
	kPEFHashValueMask = 0x0000FFFF,
	kPEFHashMaxLength = 0x0000FFFF
}

enum
{
	kPEFExpSymClassShift = 24,
	kPEFExpSymNameOffsetMask = 0x00FFFFFF,
	kPEFExpSymMaxNameOffset = 0x00FFFFFF
}

enum
{
	kPEFAbsoluteExport = -2,
	kPEFReexportedImport = -3
}

enum
{
	kPEFRelocBasicOpcodeRange = 128
}

enum
{
	kPEFRelocBySectDWithSkip = 0x00,
	kPEFRelocBySectC = 0x20,
	kPEFRelocBySectD = 0x21,
	kPEFRelocTVector12 = 0x22,
	kPEFRelocTVector8 = 0x23,
	kPEFRelocVTable8 = 0x24,
	kPEFRelocImportRun = 0x25,
	kPEFRelocSmByImport = 0x30,
	kPEFRelocSmSetSectC = 0x31,
	kPEFRelocSmSetSectD = 0x32,
	kPEFRelocSmBySection = 0x33,
	kPEFRelocIncrPosition = 0x40,
	kPEFRelocSmRepeat = 0x48,
	kPEFRelocSetPosition = 0x50,
	kPEFRelocLgByImport = 0x52,
	kPEFRelocLgRepeat = 0x58,
	kPEFRelocLgSetOrBySection = 0x5A,
	kPEFRelocUndefinedOpcode = 0xFF
}

enum
{
	kPEFRelocLgBySectionSubopcode = 0x00,
	kPEFRelocLgSetSectCSubopcode = 0x01,
	kPEFRelocLgSetSectDSubopcode = 0x02
}

enum
{
	kPEFRelocWithSkipMaxSkipCount = 255,
	kPEFRelocWithSkipMaxRelocCount = 63
}

enum
{
	kPEFRelocRunMaxRunLength = 512
}

enum
{
	kPEFRelocSmIndexMaxIndex = 511
}

enum
{
	kPEFRelocIncrPositionMaxOffset = 4096
}

enum
{
	kPEFRelocSmRepeatMaxChunkCount = 16,
	kPEFRelocSmRepeatMaxRepeatCount = 256
}

enum
{
	kPEFRelocSetPosMaxOffset = 0x03FFFFFF
}

enum
{
	kPEFRelocLgByImportMaxIndex = 0x03FFFFFF
}

enum
{
	kPEFRelocLgRepeatMaxChunkCount = 16,
	kPEFRelocLgRepeatMaxRepeatCount = 0x003FFFFF
}

enum
{
	kPEFRelocLgSetOrBySectionMaxIndex = 0x003FFFFF
}

enum
{
	kXLibTag1 = cast(c_long)0xF04D6163,
	kVLibTag2 = getOSType!("VLib"),
	kBLibTag2 = getOSType!("BLib"),
	kXLibVersion = 0x00000001
}

struct PEFSectionHeader
{
	int nameOffset;
	uint defaultAddress;
	uint totalLength;
	uint unpackedLength;
	uint containerLength;
	uint containerOffset;
	ubyte sectionKind;
	ubyte shareKind;
	ubyte alignment;
	ubyte reservedA;
}


struct PEFLoaderInfoHeader
{
	int mainSection;
	uint mainOffset;
	int initSection;
	uint initOffset;
	int termSection;
	uint termOffset;
	uint importedLibraryCount;
	uint totalImportedSymbolCount;
	uint relocSectionCount;
	uint relocInstrOffset;
	uint loaderStringsOffset;
	uint exportHashOffset;
	uint exportHashTablePower;
	uint exportedSymbolCount;
}


struct PEFImportedLibrary
{
	uint nameOffset;
	uint oldImpVersion;
	uint currentVersion;
	uint importedSymbolCount;
	uint firstImportedSymbol;
	ubyte options;
	ubyte reservedA;
	ushort reservedB;
}


struct PEFImportedSymbol
{
	uint classAndName;
}


struct PEFExportedSymbolHashSlot
{
	uint countAndStart;
}


struct PEFSplitHashWord
{
	ushort nameLength;
	ushort hashValue;
}


struct PEFExportedSymbolKey
{
	 union
	 {
		 uint fullHashWord;
		 PEFSplitHashWord splitHashWord;
	 }
}

struct PEFExportedSymbol
{
	uint classAndName;
	short symbolValue;
	SInt16 sectionIndex;
}


struct PEFLoaderRelocationHeader
{
	ushort sectionIndex;
	uint reservedA;
	uint relocCount;
	UInt32 firstRelocOffset;
}


struct XLibContainerHeader
{
	uint tag1;
	uint tag2;
	uint currentFormat;
	uint containerStringsOffset;
	uint exportHashOffset;
	uint exportKeyOffset;
	uint exportSymbolOffset;
	uint exportNamesOffset;
	uint exportHashTablePower;
	uint exportedSymbolCount;
	uint fragNameOffset;
	uint fragNameLength;
	uint dylibPathOffset;
	uint dylibPathLength;
	uint cpuFamily;
	uint cpuModel;
	uint dateTimeStamp;
	uint currentVersion;
	uint oldDefVersion;
	UInt32 oldImpVersion;
}


struct XLibExportedSymbol
{
	uint classAndName;
	UInt32 bpOffset;
}