mono/mcs/class/PEAPI/PEAPI.cs

using System;
using System.IO;
using System.Collections;
using System.Text;

namespace PEAPI {

	/**************************************************************************/  
	/// <summary>
	/// Image for a PEFile
	/// File Structure
	///     DOS Header (128 bytes) 
	///     PE Signature ("PE\0\0") 
	///     PEFileHeader (20 bytes)
	///     PEOptionalHeader (224 bytes) 
	///     SectionHeaders (40 bytes * NumSections)
	///
	///     Sections .text (always present - contains metadata)
	///              .sdata (contains any initialised data in the file - may not be present)
	///                     (for ilams /debug this contains the Debug table)
	///              .reloc (always present - in pure CIL only has one fixup)
	///               others???  c# produces .rsrc section containing a Resource Table
	///
	/// .text layout
	///     IAT (single entry 8 bytes for pure CIL)
	///     CLIHeader (72 bytes)
	///     CIL instructions for all methods (variable size)
	///     MetaData 
	///       Root (20 bytes + UTF-8 Version String + quad align padding)
	///       StreamHeaders (8 bytes + null terminated name string + quad align padding)
	///       Streams 
	///         #~        (always present - holds metadata tables)
	///         #Strings  (always present - holds identifier strings)
	///         #US       (Userstring heap)
	///         #Blob     (signature blobs)
	///         #GUID     (guids for assemblies or Modules)
	///    ImportTable (40 bytes)
	///    ImportLookupTable(8 bytes) (same as IAT for standard CIL files)
	///    Hint/Name Tables with entry "_CorExeMain" for .exe file and "_CorDllMain" for .dll (14 bytes)
	///    ASCII string "mscoree.dll" referenced in ImportTable (+ padding = 16 bytes)
	///    Entry Point  (0xFF25 followed by 4 bytes 0x400000 + RVA of .text)
	///
	///  #~ stream structure
	///    Header (24 bytes)
	///    Rows   (4 bytes * numTables)
	///    Tables
	/// </summary>
	internal class FileImage : BinaryWriter {

		internal readonly static uint[] iByteMask = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};
		internal readonly static ulong[] lByteMask = {0x00000000000000FF, 0x000000000000FF00,
			0x0000000000FF0000, 0x00000000FF000000,
			0x000000FF00000000, 0x0000FF0000000000,
			0x00FF000000000000, 0xFF00000000000000 };
		internal readonly static uint nibble0Mask = 0x0000000F;
		internal readonly static uint nibble1Mask = 0x000000F0;

		private static readonly byte[] DOSHeader = { 0x4d,0x5a,0x90,0x00,0x03,0x00,0x00,0x00,
			0x04,0x00,0x00,0x00,0xff,0xff,0x00,0x00,
			0xb8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,
			0x0e,0x1f,0xba,0x0e,0x00,0xb4,0x09,0xcd,
			0x21,0xb8,0x01,0x4c,0xcd,0x21,0x54,0x68,
			0x69,0x73,0x20,0x70,0x72,0x6f,0x67,0x72,
			0x61,0x6d,0x20,0x63,0x61,0x6e,0x6e,0x6f,
			0x74,0x20,0x62,0x65,0x20,0x72,0x75,0x6e,
			0x20,0x69,0x6e,0x20,0x44,0x4f,0x53,0x20,
			0x6d,0x6f,0x64,0x65,0x2e,0x0d,0x0d,0x0a,
			0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
			0x50,0x45,0x00,0x00};
		private static byte[] PEHeader = { 0x4c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0xE0, 0x00, 0x0E, 0x01, // PE Header Standard Fields
			0x0B, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
		};

		private static readonly uint minFileAlign = 0x200;
		private static readonly uint maxFileAlign = 0x1000;
		private static readonly uint fileHeaderSize = 0x178;
		private static readonly uint sectionHeaderSize = 40;
		private static readonly uint SectionAlignment = 0x2000;
		private static readonly uint ImageBase = 0x400000;
		private static readonly uint ImportTableSize = 40;
		private static readonly uint IATSize = 8;
		private static readonly uint CLIHeaderSize = 72;
		private uint runtimeFlags = 0x01;  // COMIMAGE_FLAGS_ILONLY
		// 32BITREQUIRED 0x02, STRONGNAMESIGNED 0x08, TRACKDEBUGDATA 0x10000
		private static readonly uint StrongNameSignatureSize = 128;
		private bool reserveStrongNameSignatureSpace = false;

		private static readonly uint relocFlags = 0x42000040;
		private static readonly ushort exeCharacteristics = 0x010E;
		private static readonly ushort dllCharacteristics = 0x210E;
		// section names are all 8 bytes
		private static readonly string textName = ".text\0\0\0";
		private static readonly string sdataName = ".sdata\0\0";
		private static readonly string relocName = ".reloc\0\0";
		private static readonly string rsrcName = ".rsrc\0\0\0";
		private static readonly string exeHintNameTable = "\0\0_CorExeMain\0";
		private static readonly string dllHintNameTable = "\0\0_CorDllMain\0";
		private static readonly string runtimeEngineName = "mscoree.dll\0\0";

		private Section text, sdata, rsrc;
		ArrayList data;
		BinaryWriter reloc = new BinaryWriter(new MemoryStream());
		uint dateStamp = 0;
		DateTime origin = new DateTime(1970,1,1);
		uint numSections = 2; // always have .text  and .reloc sections
		internal SubSystem subSys = SubSystem.Windows_CUI;  // default is Windows Console mode
		internal long stackReserve = 0x100000; // default is 1Mb 
		internal uint fileAlign = minFileAlign;
		uint entryPointOffset, entryPointPadding, imageSize, headerSize, headerPadding, entryPointToken = 0;
		uint relocOffset, relocRVA, relocSize, relocPadding, relocTide, hintNameTableOffset;
		uint metaDataOffset, runtimeEngineOffset, initDataSize = 0, importTablePadding;
		uint resourcesSize, resourcesOffset;
		uint strongNameSigOffset;
		uint importTableOffset, importLookupTableOffset, totalImportTableSize;
		MetaData metaData;
		char[] runtimeEngine = runtimeEngineName.ToCharArray(), hintNameTable;
		bool doDLL, largeStrings, largeGUID, largeUS, largeBlob;
		ushort characteristics;

		internal FileImage(bool makeDLL, string fileName) : base(new FileStream(fileName,FileMode.Create)) 
		{
			InitFileImage(makeDLL);
			TimeSpan tmp = System.IO.File.GetCreationTime(fileName).Subtract(origin);
			dateStamp = Convert.ToUInt32(tmp.TotalSeconds);
		}

		internal FileImage(bool makeDLL, Stream str) : base(str) 
		{
			InitFileImage(makeDLL);
			TimeSpan tmp = DateTime.Now.Subtract(origin);
			dateStamp = Convert.ToUInt32(tmp.TotalSeconds);
		}

		private void InitFileImage(bool makeDLL) 
		{
			doDLL = makeDLL;
			if (doDLL) {
				hintNameTable = dllHintNameTable.ToCharArray();
				characteristics = dllCharacteristics;
			} else {
				hintNameTable = exeHintNameTable.ToCharArray();
				characteristics = exeCharacteristics;
			}
			text = new Section(textName,0x60000020);     // IMAGE_SCN_CNT  CODE, EXECUTE, READ
			//                      rsrc = new Section(rsrcName,0x40000040);     // IMAGE_SCN_CNT  INITIALIZED_DATA, READ
			metaData = new MetaData(this);
		}

		internal MetaData GetMetaData() 
		{
			return metaData;
		}

		private uint GetNextSectStart(uint rva, uint tide) 
		{
			uint c = tide / SectionAlignment;
			if ((tide % SectionAlignment) != 0)
				c++;
			return rva + (c * SectionAlignment);
		}

		private void BuildTextSection() 
		{
			// .text layout
			//    IAT (single entry 8 bytes for pure CIL)
			//    CLIHeader (72 bytes)
			//    CIL instructions for all methods (variable size)
			//    MetaData 
			//    ImportTable (40 bytes)
			//    ImportLookupTable(8 bytes) (same as IAT for standard CIL files)
			//    Hint/Name Tables with entry "_CorExeMain" for .exe file and "_CorDllMain" for .dll (14 bytes)
			//    ASCII string "mscoree.dll" referenced in ImportTable (+ padding = 16 bytes)
			//    Entry Point  (0xFF25 followed by 4 bytes 0x400000 + RVA of .text)
			metaData.BuildMetaData(IATSize + CLIHeaderSize);
			metaDataOffset = IATSize + CLIHeaderSize;
			// Console.WriteLine("Code starts at " + metaDataOffset);
			metaDataOffset += metaData.CodeSize();
			// resourcesStart =
			resourcesOffset = metaDataOffset + metaData.Size ();
			resourcesSize = metaData.GetResourcesSize ();
			if (reserveStrongNameSignatureSpace) {
				strongNameSigOffset = resourcesOffset + resourcesSize;
				// fixUps = RVA for vtable
				importTableOffset = strongNameSigOffset + StrongNameSignatureSize;
			} else {
				strongNameSigOffset = 0;
				// fixUps = RVA for vtable
				importTableOffset = resourcesOffset + resourcesSize;
			}
			importTablePadding = NumToAlign(importTableOffset,16);
			importTableOffset += importTablePadding;
			importLookupTableOffset = importTableOffset + ImportTableSize;
			hintNameTableOffset = importLookupTableOffset + IATSize;
			runtimeEngineOffset = hintNameTableOffset + (uint)hintNameTable.Length;
			entryPointOffset = runtimeEngineOffset + (uint)runtimeEngine.Length;
			totalImportTableSize = entryPointOffset - importTableOffset;
			// Console.WriteLine("total import table size = " + totalImportTableSize);
			// Console.WriteLine("entrypoint offset = " + entryPointOffset);
			entryPointPadding = NumToAlign(entryPointOffset,4) + 2;
			entryPointOffset += entryPointPadding;
			text.AddReloc(entryPointOffset+2);
			text.IncTide(entryPointOffset + 6);
			//if (text.Tide() < fileAlign) fileAlign = minFileAlign;
			text.SetSize(NumToAlign(text.Tide(),fileAlign));
			// Console.WriteLine("text size = " + text.Size() + " text tide = " + text.Tide() + " text padding = " + text.Padding());
			// Console.WriteLine("metaDataOffset = " + Hex.Int(metaDataOffset));
			// Console.WriteLine("importTableOffset = " + Hex.Int(importTableOffset));
			// Console.WriteLine("importLookupTableOffset = " + Hex.Int(importLookupTableOffset));
			// Console.WriteLine("hintNameTableOffset = " + Hex.Int(hintNameTableOffset));
			// Console.WriteLine("runtimeEngineOffset = " + Hex.Int(runtimeEngineOffset));
			// Console.WriteLine("entryPointOffset = " + Hex.Int(entryPointOffset));
			// Console.WriteLine("entryPointPadding = " + Hex.Int(entryPointPadding));

		}

		internal void BuildRelocSection() 
		{
			text.DoRelocs(reloc);
			if (sdata != null) sdata.DoRelocs(reloc);
			if (rsrc != null) rsrc.DoRelocs(reloc);
			relocTide = (uint)reloc.Seek(0,SeekOrigin.Current);
			relocPadding = NumToAlign(relocTide,fileAlign);
			relocSize = relocTide + relocPadding;
			imageSize = relocRVA + SectionAlignment;
			initDataSize += relocSize;
		}

		private void CalcOffsets() 
		{
			if (sdata != null)
				numSections++;
			if (rsrc != null)
				numSections++;
			headerSize = fileHeaderSize + (numSections * sectionHeaderSize);
			headerPadding = NumToAlign(headerSize,fileAlign);
			headerSize += headerPadding;
			uint offset = headerSize;
			uint rva = SectionAlignment;
			text.SetOffset(offset);
			text.SetRVA(rva);
			offset += text.Size();
			rva  = GetNextSectStart(rva,text.Tide());
			// Console.WriteLine("headerSize = " + headerSize);
			// Console.WriteLine("headerPadding = " + headerPadding);
			// Console.WriteLine("textOffset = " + Hex.Int(text.Offset()));
			if (sdata != null) { 
				sdata.SetSize(NumToAlign(sdata.Tide(),fileAlign));
				sdata.SetOffset(offset);
				sdata.SetRVA(rva);
				offset += sdata.Size();
				rva = GetNextSectStart(rva,sdata.Tide());
				initDataSize += sdata.Size();
			}
			if (rsrc != null) { 
				rsrc.SetSize(NumToAlign(rsrc.Tide(),fileAlign));
				rsrc.SetOffset(offset);
				rsrc.SetRVA(rva);
				offset += rsrc.Size();
				rva = GetNextSectStart(rva,rsrc.Tide());
				initDataSize += rsrc.Size();
			}
			relocOffset = offset;
			relocRVA = rva;
		}

		internal void MakeFile() 
		{
			if (doDLL) hintNameTable = dllHintNameTable.ToCharArray();
			else hintNameTable = exeHintNameTable.ToCharArray();
			BuildTextSection();
			CalcOffsets();
			BuildRelocSection();
			// now write it out
			WriteHeader();
			WriteSections();
			Flush();
			Close();
		}

		private void WriteHeader() 
		{
			Write(DOSHeader);
			// Console.WriteLine("Writing PEHeader at offset " + Seek(0,SeekOrigin.Current));
			WritePEHeader();
			// Console.WriteLine("Writing text section header at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));
			text.WriteHeader(this,relocRVA);
			if (sdata != null) sdata.WriteHeader(this,relocRVA);
			if (rsrc != null) rsrc.WriteHeader(this,relocRVA);
			// Console.WriteLine("Writing reloc section header at offset " + Seek(0,SeekOrigin.Current));
			WriteRelocSectionHeader();
			// Console.WriteLine("Writing padding at offset " + Seek(0,SeekOrigin.Current));
			WriteZeros(headerPadding);
		}

		private void WriteSections() 
		{
			// Console.WriteLine("Writing text section at offset " + Seek(0,SeekOrigin.Current));
			WriteTextSection();
			if (sdata != null) WriteSDataSection();
			if (rsrc != null) WriteRsrcSection();
			WriteRelocSection();
		}

		private void WriteIAT() 
		{
			Write(text.RVA() + hintNameTableOffset);
			Write(0);
		}

		private void WriteImportTables() 
		{
			// Import Table
			WriteZeros(importTablePadding);
			// Console.WriteLine("Writing import tables at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));
			Write(importLookupTableOffset + text.RVA());
			WriteZeros(8); 
			Write(runtimeEngineOffset + text.RVA());
			Write(text.RVA());    // IAT is at the beginning of the text section
			WriteZeros(20);
			// Import Lookup Table
			WriteIAT();                // lookup table and IAT are the same
			// Hint/Name Table
			// Console.WriteLine("Writing hintname table at " + Hex.Long(Seek(0,SeekOrigin.Current)));
			Write(hintNameTable);
			Write(runtimeEngineName.ToCharArray());
		}

		private void WriteTextSection() 
		{
			WriteIAT();
			WriteCLIHeader();
			// Console.WriteLine("Writing code at " + Hex.Long(Seek(0,SeekOrigin.Current)));
			metaData.WriteByteCodes(this);
			// Console.WriteLine("Finished writing code at " + Hex.Long(Seek(0,SeekOrigin.Current)));
			largeStrings = metaData.LargeStringsIndex();
			largeGUID = metaData.LargeGUIDIndex();
			largeUS = metaData.LargeUSIndex();
			largeBlob = metaData.LargeBlobIndex();
			metaData.WriteMetaData(this);
			metaData.WriteResources (this);
			if (reserveStrongNameSignatureSpace) {
				WriteZeros(StrongNameSignatureSize);
			}
			WriteImportTables();
			WriteZeros(entryPointPadding);
			Write((ushort)0x25FF);
			Write(ImageBase + text.RVA());
			WriteZeros(text.Padding());
		}

		private void WriteCLIHeader() 
		{
			Write(CLIHeaderSize);       // Cb
			Write((short)2);            // Major runtime version
			Write((short)0);            // Minor runtime version
			Write(text.RVA() + metaDataOffset);
			Write(metaData.Size());
			Write(runtimeFlags);
			Write(entryPointToken);
			if (resourcesSize > 0) {
				Write (text.RVA () + resourcesOffset);
				Write (resourcesSize);
			} else {
				WriteZeros (8);
			}
			// Strong Name Signature (RVA, size)
			if (reserveStrongNameSignatureSpace) {
				Write(text.RVA() + strongNameSigOffset); 
				Write(StrongNameSignatureSize);
			} else {
				WriteZeros(8);
			}
			WriteZeros(8);                     // CodeManagerTable
			WriteZeros(8);                     // VTableFixups NYI
			WriteZeros(16);                    // ExportAddressTableJumps, ManagedNativeHeader
		}

		private void WriteSDataSection() 
		{
			long size = sdata.Size ();
			long start = BaseStream.Position;
			for (int i=0; i < data.Count; i++) {
				((DataConstant)data[i]).Write(this);
			}
			while (BaseStream.Position < (start + size))
				Write ((byte) 0);
		}

		private void WriteRsrcSection() 
		{
		}

		private void WriteRelocSection() 
		{
			// Console.WriteLine("Writing reloc section at " + Seek(0,SeekOrigin.Current) + " = " + relocOffset);
			MemoryStream str = (MemoryStream)reloc.BaseStream;
			Write(str.ToArray());
			WriteZeros(NumToAlign((uint)str.Position,fileAlign));
		}

		internal void SetEntryPoint(uint entryPoint) 
		{
			entryPointToken = entryPoint;
		}

		internal void AddInitData(DataConstant cVal) 
		{
			if (sdata == null) {                    
				sdata = new Section(sdataName,0xC0000040);   // IMAGE_SCN_CNT  INITIALIZED_DATA, READ, WRITE
				data = new ArrayList(); 
			}
			data.Add(cVal);
			cVal.DataOffset = sdata.Tide();
			sdata.IncTide(cVal.GetSize());
		}

		internal void WriteZeros(uint numZeros) 
		{
			for (int i=0; i < numZeros; i++) {
				Write((byte)0);
			}
		}

		internal void WritePEHeader() 
		{
			Write((ushort)0x014C);  // Machine - always 0x14C for Managed PE Files (allow others??)
			Write((ushort)numSections);
			Write(dateStamp);
			WriteZeros(8); // Pointer to Symbol Table and Number of Symbols (always zero for ECMA CLI files)
			Write((ushort)0x00E0);  // Size of Optional Header
			Write(characteristics);
			// PE Optional Header
			Write((ushort)0x010B);   // Magic
			Write((byte)0x6);        // LMajor pure-IL = 6   C++ = 7
			Write((byte)0x0);        // LMinor
			Write(text.Size());
			Write(initDataSize);
			Write(0);                // Check other sections here!!
			Write(text.RVA() + entryPointOffset);
			Write(text.RVA());
			uint dataBase = 0;
			if (sdata != null) dataBase = sdata.RVA();
			else if (rsrc != null) dataBase = rsrc.RVA();
			else dataBase = relocRVA;
			Write(dataBase);
			Write(ImageBase);
			Write(SectionAlignment);
			Write(fileAlign);
			Write((ushort)0x04);     // OS Major
			WriteZeros(6);                  // OS Minor, User Major, User Minor
			Write((ushort)0x04);     // SubSys Major
			WriteZeros(6);           // SybSys Minor, Reserved
			Write(imageSize);
			Write(headerSize);
			Write((int)0);           // File Checksum
			Write((ushort)subSys);
			Write((short)0);         // DLL Flags
			Write((uint)stackReserve);   // Stack Reserve Size
			Write((uint)0x1000);     // Stack Commit Size
			Write((uint)0x100000);   // Heap Reserve Size
			Write((uint)0x1000);     // Heap Commit Size
			Write(0);                // Loader Flags
			Write(0x10);             // Number of Data Directories
			WriteZeros(8);                  // Export Table
			Write(importTableOffset + text.RVA());
			Write(totalImportTableSize);
			WriteZeros(24);            // Resource, Exception and Certificate Tables
			Write(relocRVA);
			Write(relocTide);
			WriteZeros(48);            // Debug, Copyright, Global Ptr, TLS, Load Config and Bound Import Tables
			Write(text.RVA());         // IATRVA - IAT is at start of .text Section
			Write(IATSize);
			WriteZeros(8);             // Delay Import Descriptor
			Write(text.RVA()+IATSize); // CLIHeader immediately follows IAT
			Write(CLIHeaderSize);    
			WriteZeros(8);             // Reserved
		}

		internal void WriteRelocSectionHeader() 
		{
			Write(relocName.ToCharArray());
			Write(relocTide);
			Write(relocRVA);
			Write(relocSize);
			Write(relocOffset);
			WriteZeros(12);
			Write(relocFlags);
		}

		private void Align (MemoryStream str, int val) 
		{
			if ((str.Position % val) != 0) {
				for (int i=val - (int)(str.Position % val); i > 0; i--) {
					str.WriteByte(0);
				}
			}
		}

		private uint Align(uint val, uint alignVal) 
		{
			if ((val % alignVal) != 0) {
				val += alignVal - (val % alignVal);
			}
			return val;
		}

		private uint NumToAlign(uint val, uint alignVal) 
		{
			if ((val % alignVal) == 0) return 0;
			return alignVal - (val % alignVal);
		}

		internal void StringsIndex(uint ix) 
		{
			if (largeStrings) Write(ix);
			else Write((ushort)ix);
		}

		internal void GUIDIndex(uint ix) 
		{
			if (largeGUID) Write(ix);
			else Write((ushort)ix);
		}

		internal void USIndex(uint ix) 
		{
			if (largeUS) Write(ix);
			else Write((ushort)ix);
		}

		internal void BlobIndex(uint ix) 
		{
			if (largeBlob) Write(ix);
			else Write((ushort)ix);
		}

		internal void WriteIndex(MDTable tabIx,uint ix) 
		{
			if (metaData.LargeIx(tabIx)) Write(ix);
			else Write((ushort)ix);
		}

		internal void WriteCodedIndex(CIx code, MetaDataElement elem) 
		{
			metaData.WriteCodedIndex(code,elem,this);
		}

		internal void WriteCodeRVA(uint offs) 
		{
			Write(text.RVA() + offs);
		}

		internal void WriteDataRVA(uint offs) 
		{
			Write(sdata.RVA() + offs);
		}

		internal void Write3Bytes(uint val) 
		{
			byte b3 = (byte)((val & FileImage.iByteMask[2]) >> 16);
			byte b2 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
			byte b1 = (byte)(val & FileImage.iByteMask[0]);
			Write(b1);
			Write(b2);
			Write(b3);
		}

		internal bool ReserveStrongNameSignatureSpace {
			get { return reserveStrongNameSignatureSpace; }
			set { reserveStrongNameSignatureSpace = value; }
		}

	}

	/**************************************************************************/  
	/// <summary>
	/// Base class for the PEFile (starting point)
	/// </summary>
	public class PEFile {

		private static readonly string mscorlibName = "mscorlib";
		private Module thisMod;
		private ClassDef moduleClass;
		private ArrayList classRefList = new ArrayList();
		private ArrayList classDefList = new ArrayList();
		private ArrayList resources = new ArrayList ();
		private Assembly thisAssembly;
		private static bool isMSCorlib;
		private int corFlags = 1;
		FileImage fileImage;
		MetaData metaData;

		/// <summary>
		/// Create a new PEFile.  Each PEFile is a module.
		/// </summary>
		/// <param name="name">module name, also used for the file name</param>
		/// <param name="isDLL">create a .dll or .exe file</param>
		/// <param name="hasAssembly">this file is an assembly and 
		/// will contain the assembly manifest.  The assembly name is the 
		/// same as the module name</param>
		public PEFile(string name, bool isDLL, bool hasAssembly)
			: this (name, null, isDLL, hasAssembly, null, null) 
		{
			// Console.WriteLine(Hex.Byte(0x12));
			// Console.WriteLine(Hex.Short(0x1234));
			// Console.WriteLine(Hex.Int(0x12345678));
		}

		/// <summary>
		/// Create a new PEFile.  Each PEFile is a module.
		/// </summary>
		/// <param name="name">module name, also used for the file name</param>
		/// <param name="isDLL">create a .dll or .exe file</param>
		/// <param name="hasAssembly">this file is an assembly and 
		/// will contain the assembly manifest.  The assembly name is the 
		/// same as the module name</param>
		/// <param name="outputDir">write the PEFile to this directory.  If this
		/// string is null then the output will be to the current directory</param>
		public PEFile(string name, bool isDLL, bool hasAssembly, string outputDir)
			: this (name, null, isDLL, hasAssembly, outputDir, null) 
		{
			// Console.WriteLine(Hex.Byte(0x12));
			// Console.WriteLine(Hex.Short(0x1234));
			// Console.WriteLine(Hex.Int(0x12345678));
		}

		/// <summary>
		/// Create a new PEFile
		/// </summary>
		/// <param name="name">module name</param>
		/// <param name="isDLL">create a .dll or .exe</param>
		/// <param name="hasAssembly">this PEfile is an assembly and
		/// will contain the assemly manifest.  The assembly name is the
		/// same as the module name</param>
		/// <param name="outStream">write the PEFile to this stream instead
		/// of to a new file</param>
		public PEFile(string name, bool isDLL, bool hasAssembly, Stream outStream)
			: this (name, null, isDLL, hasAssembly, null, outStream) 
		{
		}

		public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, Stream outStream)
			: this (name, module_name, isDLL, hasAssembly, null, outStream) 
		{
		}  

		public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, string outputDir, Stream outStream) 
		{
			SetName (name);
			string fname = module_name == null ? MakeFileName (outputDir, name, isDLL) : module_name;
			if (outStream == null)
				fileImage = new FileImage (isDLL, fname);
			else  
				fileImage = new FileImage (isDLL, outStream);

			InitPEFile (name, fname, hasAssembly);
		}

		private void SetName (string name)
		{
			if (name == "mscorlib")
				isMSCorlib = true;
		}

		private void InitPEFile(string name, string fName, bool hasAssembly) 
		{
			metaData = fileImage.GetMetaData();
			thisMod = new Module(fName,metaData);
			if (hasAssembly) {
				thisAssembly = new Assembly(name,metaData);
				metaData.AddToTable(MDTable.Assembly,thisAssembly);      
			}
			moduleClass = AddClass(TypeAttr.Private,"","<Module>");
			moduleClass.SpecialNoSuper();
			metaData.AddToTable(MDTable.Module,thisMod);
		}

		internal static bool IsMSCorlib {
			get { return isMSCorlib; }
		}

		public ClassDef ModuleClass {
			get { return moduleClass; }
		}

		/// <summary>
		/// Set the subsystem (.subsystem) (Default is Windows Console mode)
		/// </summary>
		/// <param name="subS">subsystem value</param>
		public void SetSubSystem(SubSystem subS) 
		{
			fileImage.subSys = subS;
		}

		/// <summary>
		/// Set the flags (.corflags)
		/// </summary>
		/// <param name="flags">the flags value</param>
		public void SetCorFlags(int flags) 
		{
			corFlags = flags;
		}

		public void SetStackReserve (long stackReserve)
		{
			fileImage.stackReserve = stackReserve;
		}

		private string MakeFileName(string dirName, string name, bool isDLL) 
		{
			string result = "";
			if ((dirName != null) && (dirName.CompareTo("") != 0)) {
				result = dirName;
				if (!dirName.EndsWith("\\")) result += "\\";
			}
			result += name;

			// if (isDLL) result += ".dll";  else result += ".exe";

			return result;
		}

		/// <summary>
		/// Add an external assembly to this PEFile (.assembly extern)
		/// </summary>
		/// <param name="assemName">the external assembly name</param>
		/// <returns>a descriptor for this external assembly</returns>
		public AssemblyRef AddExternAssembly(string assemName) 
		{
			if (assemName.CompareTo(mscorlibName) == 0) return metaData.mscorlib;
			AssemblyRef anAssem = new AssemblyRef(metaData,assemName);
			metaData.AddToTable(MDTable.AssemblyRef,anAssem);
			// Console.WriteLine("Adding assembly " + assemName);
			return anAssem;
		}

		/// <summary>
		/// Add an external module to this PEFile (.module extern)
		/// </summary>
		/// <param name="name">the external module name</param>
		/// <returns>a descriptor for this external module</returns>
		public ModuleRef AddExternModule(string name) 
		{
			ModuleRef modRef = new ModuleRef(metaData,name);
			metaData.AddToTable(MDTable.ModuleRef,modRef);
			return modRef;
		}

		/// <summary>
		/// Add a "global" method to this module
		/// </summary>
		/// <param name="name">method name</param>
		/// <param name="retType">return type</param>
		/// <param name="pars">method parameters</param>
		/// <returns>a descriptor for this new "global" method</returns>
		public MethodDef AddMethod (string name, Param ret_param, Param [] pars) 
		{
			return moduleClass.AddMethod (name, ret_param, pars);
		}
		
		public MethodDef AddMethod(string name, Type retType, Param[] pars) 
		{
			return AddMethod (name, new Param (ParamAttr.Default, "", retType), pars);
		}

		/// <summary>
		/// Add a "global" method to this module
		/// </summary>
		/// <param name="mAtts">method attributes</param>
		/// <param name="iAtts">method implementation attributes</param>
		/// <param name="name">method name</param>
		/// <param name="retType">return type</param>
		/// <param name="pars">method parameters</param>
		/// <returns>a descriptor for this new "global" method</returns>
		public MethodDef AddMethod (MethAttr mAtts, ImplAttr iAtts, string name, Param ret_param, Param [] pars) 
		{
			return moduleClass.AddMethod (mAtts, iAtts, name, ret_param, pars);
		}

		public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name, Type retType, Param[] pars) 
		{
			return AddMethod (mAtts, iAtts, name, new Param (ParamAttr.Default, "", retType), pars);
		}

		public MethodRef AddMethodToTypeSpec (Type item, string name, Type retType, Type[] pars) 
		{
			return AddMethodToTypeSpec (item, name, retType, pars, 0);
		}
		
		public MethodRef AddMethodToTypeSpec (Type item, string name, Type retType, Type[] pars, int gen_param_count) 
		{
			MethodRef meth = new MethodRef (item.GetTypeSpec (metaData), name, retType, pars, false, null, gen_param_count);
			metaData.AddToTable (MDTable.MemberRef,meth);
			return meth;
		}

		public MethodRef AddVarArgMethodToTypeSpec (Type item, string name, Type retType,
				Type[] pars, Type[] optPars) {
			MethodRef meth = new MethodRef(item.GetTypeSpec (metaData), name,retType,pars,true,optPars, 0);
			metaData.AddToTable(MDTable.MemberRef,meth);
			return meth;
		}

		public FieldRef AddFieldToTypeSpec (Type item, string name, Type fType) 
		{
			FieldRef field = new FieldRef (item.GetTypeSpec (metaData), name,fType);
			metaData.AddToTable (MDTable.MemberRef,field);
			return field;
		}

		public Method AddMethodSpec (Method m, GenericMethodSig g_sig)
		{
			MethodSpec ms = new MethodSpec (m, g_sig);
			metaData.AddToTable (MDTable.MethodSpec, ms);
			return ms;
		}

		/// <summary>
		/// Add a "global" field to this module
		/// </summary>
		/// <param name="name">field name</param>
		/// <param name="fType">field type</param>
		/// <returns>a descriptor for this new "global" field</returns>
		public FieldDef AddField(string name, Type fType) 
		{
			return moduleClass.AddField(name,fType);
		}

		/// <summary>
		/// Add a "global" field to this module
		/// </summary>
		/// <param name="attrSet">attributes of this field</param>
		/// <param name="name">field name</param>
		/// <param name="fType">field type</param>
		/// <returns>a descriptor for this new "global" field</returns>
		public FieldDef AddField(FieldAttr attrSet, string name, Type fType) 
		{
			return moduleClass.AddField(attrSet,name,fType);
		}

		/// <summary>
		/// Add a class to this module
		/// </summary>
		/// <param name="attrSet">attributes of this class</param>
		/// <param name="nsName">name space name</param>
		/// <param name="name">class name</param>
		/// <returns>a descriptor for this new class</returns>
		public ClassDef AddClass(TypeAttr attrSet, string nsName, string name) 
		{
			return AddClass (attrSet, nsName, name, null);
		}

		/// <summary>
		/// Add a class which extends System.ValueType to this module
		/// </summary>
		/// <param name="attrSet">attributes of this class</param>
		/// <param name="nsName">name space name</param>
		/// <param name="name">class name</param>
		/// <returns>a descriptor for this new class</returns>
		public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) 
		{
			ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData);
			if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name)) {
				aClass.MakeValueClass(vClass);
			} else {
				if (ClassDef.IsEnum (nsName, name))
					aClass.SetSuper (metaData.mscorlib.ValueType ());
				else
					aClass.SetSuper (metaData.mscorlib.GetSpecialSystemClass (PrimitiveType.Object));

				metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass);
			}
			aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ());
			metaData.AddToTable(MDTable.TypeDef,aClass);
			return aClass;
		}

		/// <summary>
		/// Add a class to this module
		/// </summary>
		/// <param name="attrSet">attributes of this class</param>
		/// <param name="nsName">name space name</param>
		/// <param name="name">class name</param>
		/// <param name="superType">super type of this class (extends)</param>
		/// <returns>a descriptor for this new class</returns>
		public ClassDef AddClass(TypeAttr attrSet, string nsName, string name, Class superType) 
		{
			ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData);
			if (superType != null)
				aClass.SetSuper(superType);
			if (PEFile.IsMSCorlib)
				metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass);
			metaData.AddToTable(MDTable.TypeDef,aClass);
			return aClass;
		}

		public void  AddGenericClass (GenericTypeInst gti)
		{
			metaData.AddToTable (MDTable.TypeSpec, gti);
		}

		public void AddGenericParam (GenParam param)
		{
			metaData.AddToTable (MDTable.TypeSpec, param);
		}

		public FileRef AddFile(string fName, byte[] hashBytes, bool hasMetaData, bool entryPoint) 
		{
			FileRef file = new FileRef(fName,hashBytes,hasMetaData,entryPoint,metaData);
			metaData.AddToTable(MDTable.File,file);
			return file;
		}

		/// <summary>
		/// Add a manifest resource to this PEFile NOT YET IMPLEMENTED
		/// </summary>
		/// <param name="mr"></param>
		public void AddManifestResource(ManifestResource mr) 
		{
			metaData.AddToTable(MDTable.ManifestResource,mr);
			resources.Add (mr);
			//mr.FixName(metaData);
		}

		public void AddCustomAttribute (Method meth, byte [] data, MetaDataElement element)
		{
			metaData.AddCustomAttribute (new CustomAttribute (element, meth, data));
			element.HasCustomAttr = true;
		}

		public void AddDeclSecurity (SecurityAction sec_action, byte [] data, MetaDataElement element)
		{
			metaData.AddDeclSecurity (new DeclSecurity (element, (ushort) sec_action, data));
		}

		public void AddDeclSecurity (SecurityAction sec_action, PEAPI.PermissionSet ps, MetaDataElement element)
		{
			metaData.AddDeclSecurity (new DeclSecurity_20 (element, (ushort) sec_action, ps));
		}

		/// <summary>
		/// Add a managed resource from another assembly.
		/// </summary>
		/// <param name="resName">The name of the resource</param>
		/// <param name="assem">The assembly where the resource is</param>
		/// <param name="isPublic">Access for the resource</param>
		public void AddExternalManagedResource (string resName, AssemblyRef assem, uint flags) 
		{
			resources.Add (new ManifestResource (resName, flags, assem));
		}

		/// <summary>
		/// Add a managed resource from another assembly.
		/// </summary>
		/// <param name="mr"></param>
		/// <param name="isPublic"></param>
		public void AddExternalManagedResource (ManifestResource mr) 
		{
			resources.Add (new ManifestResource (mr));
		}
		/// <summary>
		/// Find a resource
		/// </summary>
		/// <param name="name">The name of the resource</param>
		/// <returns>The resource with the name "name" or null </returns>
		public ManifestResource GetResource (string name) 
		{
			for (int i = 0; i < resources.Count; i ++) {
				if (((ManifestResource) resources [i]).Name == name)
					return (ManifestResource) resources [i];
			}
			return null;
		}

		public ManifestResource [] GetResources() 
		{
			return (ManifestResource []) resources.ToArray (typeof (ManifestResource));
		}

		/// <summary>
		/// Write out the PEFile (the "bake" function)
		/// </summary>
		public void WritePEFile() { /* the "bake" function */
			if (thisAssembly != null)
				fileImage.ReserveStrongNameSignatureSpace = thisAssembly.HasPublicKey;
			fileImage.MakeFile();
		}

		/// <summary>
		/// Get the descriptor of this module
		/// </summary>
		/// <returns>the descriptor for this module</returns>
		public Module GetThisModule() 
		{
			return thisMod;
		}

		/// <summary>
		/// Get the descriptor for this assembly.  The PEFile must have been
		/// created with hasAssembly = true
		/// </summary>
		/// <returns>the descriptor for this assembly</returns>
		public Assembly GetThisAssembly() 
		{
			return thisAssembly;
		}

	}

	/**************************************************************************/  
	/// <summary>
	/// Descriptor for a Section in a PEFile  eg .text, .sdata
	/// </summary>
	internal class Section {
		private static readonly uint relocPageSize = 4096;  // 4K pages for fixups

		char[] name; 
		uint offset = 0, tide = 0, size = 0, rva = 0, relocTide = 0;
		//uint relocOff = 0;
		uint flags = 0, padding = 0;
		uint[] relocs; 

		internal Section(string sName, uint sFlags) 
		{
			name = sName.ToCharArray();
			flags = sFlags;
		}

		internal uint Tide() { return tide; }

		internal void IncTide(uint incVal) { tide += incVal; }

		internal uint Padding() { return padding; }

		internal uint Size() { return size; }

		internal void SetSize(uint pad) 
		{
			padding = pad;
			size = tide + padding;
		}

		internal uint RVA() { return rva; }

		internal void SetRVA(uint rva) { this.rva = rva; }

		internal uint Offset() { return offset; }

		internal void SetOffset(uint offs) { offset = offs; }

		internal void DoBlock(BinaryWriter reloc, uint page, int start, int end) 
		{
			//Console.WriteLine("rva = " + rva + "  page = " + page);
			reloc.Write(rva + page);
			reloc.Write((uint)(((end-start+1)*2) + 8));
			for (int j=start; j < end; j++) {
				//Console.WriteLine("reloc offset = " + relocs[j]);
				reloc.Write((ushort)((0x3 << 12) | (relocs[j] - page)));
			}
			reloc.Write((ushort)0);
		}

		internal void DoRelocs(BinaryWriter reloc) 
		{
			if (relocTide > 0) {
				//relocOff = (uint)reloc.Seek(0,SeekOrigin.Current);
				uint block = (relocs[0]/relocPageSize + 1) * relocPageSize;
				int start = 0;
				for (int i=1; i < relocTide; i++) {
					if (relocs[i] >= block) {
						DoBlock(reloc,block-relocPageSize,start,i);
						start = i;
						block = (relocs[i]/relocPageSize + 1) * relocPageSize;
					}
				}
				DoBlock(reloc,block-relocPageSize,start,(int)relocTide);
			}
		}

		internal void AddReloc(uint offs) 
		{
			int pos = 0;
			if (relocs == null) {
				relocs = new uint[5];
			} else {
				if (relocTide >= relocs.Length) {
					uint[] tmp = relocs;
					relocs = new uint[tmp.Length + 5];
					for (int i=0; i < relocTide; i++) {
						relocs[i] = tmp[i];
					}
				}
				while ((pos < relocTide) && (relocs[pos] < offs)) pos++;
				for (int i=pos; i < relocTide; i++) {
					relocs[i+1] = relocs[i];
				}
			}
			relocs[pos] = offs;
			relocTide++;    
		}

		internal void WriteHeader(BinaryWriter output, uint relocRVA) 
		{
			output.Write(name);
			output.Write(tide);
			output.Write(rva);
			output.Write(size);
			output.Write(offset);
			output.Write(0);
			//output.Write(relocRVA + relocOff);
			output.Write(0);
			output.Write(0);
			//output.Write((ushort)relocTide);
			//output.Write((ushort)0);
			output.Write(flags);
		}

	}

	public class Hex {
		readonly static char[] hexDigit = {'0','1','2','3','4','5','6','7',
			'8','9','A','B','C','D','E','F'};
		readonly static uint[] iByteMask = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};
		readonly static ulong[] lByteMask = {0x00000000000000FF, 0x000000000000FF00, 
			0x0000000000FF0000, 0x00000000FF000000,
			0x000000FF00000000, 0x0000FF0000000000,
			0x00FF000000000000, 0xFF00000000000000 };
		readonly static uint nibble0Mask = 0x0000000F;
		readonly static uint nibble1Mask = 0x000000F0;

		public static String Byte(int b) 
		{
			char[] str = new char[2];
			uint num = (uint)b;
			uint b1 = num & nibble0Mask;
			uint b2 = (num & nibble1Mask) >> 4;
			str[0] = hexDigit[b2];
			str[1] = hexDigit[b1];
			return new String(str);
		}

		public static String Short(int b) 
		{
			char[] str = new char[4];
			uint num1 = (uint)b & iByteMask[0];
			uint num2 = ((uint)b & iByteMask[1]) >> 8;
			uint b1 = num1 & nibble0Mask;
			uint b2 = (num1 & nibble1Mask) >> 4;
			uint b3 = num2 & nibble0Mask;
			uint b4 = (num2 & nibble1Mask) >> 4;
			str[0] = hexDigit[b4];
			str[1] = hexDigit[b3];
			str[2] = hexDigit[b2];
			str[3] = hexDigit[b1];
			return new String(str);
		}

		public static String Int(int val) 
		{
			char[] str = new char[8];
			uint num = (uint)val;
			int strIx = 7;
			for (int i=0; i < iByteMask.Length; i++) {
				uint b = num & iByteMask[i];
				b >>= (i*8);
				uint b1 = b & nibble0Mask;
				uint b2 = (b & nibble1Mask) >> 4;
				str[strIx--] = hexDigit[b1];
				str[strIx--] = hexDigit[b2];
			}
			return new String(str);
		}

		public static String Int(uint num) 
		{
			char[] str = new char[8];
			int strIx = 7;
			for (int i=0; i < iByteMask.Length; i++) {
				uint b = num & iByteMask[i];
				b >>= (i*8);
				uint b1 = b & nibble0Mask;
				uint b2 = (b & nibble1Mask) >> 4;
				str[strIx--] = hexDigit[b1];
				str[strIx--] = hexDigit[b2];
			}
			return new String(str);
		}

		public static String Long(long lnum) 
		{
			ulong num = (ulong)lnum;
			char[] str = new char[16];
			int strIx = 15;
			for (int i=0; i < lByteMask.Length; i++) {
				ulong b = num & lByteMask[i];
				b >>= (i*8);
				ulong b1 = b & nibble0Mask;
				ulong b2 = (b & nibble1Mask) >> 4;
				str[strIx--] = hexDigit[b1];
				str[strIx--] = hexDigit[b2];
			}
			return new String(str);
		}
	}

	/// <summary>
	/// Error for invalid PE file
	/// </summary>
	public class PEFileException : System.Exception {
		public PEFileException(string msg) : base(msg) { }
	}

	public class NotYetImplementedException : System.Exception  {
		public NotYetImplementedException(string msg) : base(msg + " Not Yet Implemented") { }
	}

	public class TypeSignatureException : System.Exception {
		public TypeSignatureException(string msg) : base(msg) { }
	}

}