using System.Collections;
using System.Text;
-namespace PEAPI
-{
- 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);
- }
- }
-
- 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) { }
- }
-
- public class ClassRefInst : Type {
-
- private Type type;
- private bool is_value;
-
- public ClassRefInst (Type type, bool is_value) : base (PrimitiveType.Class.GetTypeIndex ()) {
- this.type = type;
- this.is_value = is_value;
- if (is_value)
- typeIndex = PrimitiveType.ValueType.GetTypeIndex ();
- tabIx = MDTable.TypeSpec;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- type.TypeSig (str);
- }
- }
-
- public class MVar : Type {
-
- private int index;
-
- public MVar (int index) : base (0x1E) {
- this.index = index;
- tabIx = MDTable.TypeSpec;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- MetaData.CompressNum ((uint) index, str);
- }
- }
-
- public class GenericTypeSpec : Type {
-
- private int index;
-
- public GenericTypeSpec (int index) : base (0x13) {
- this.index = index;
- tabIx = MDTable.TypeSpec;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- MetaData.CompressNum ((uint) index, str);
- }
- }
-
- public class GenericTypeInst : Type {
-
- private Type gen_type;
- private Type[] gen_param;
-
- public GenericTypeInst (Type gen_type, Type[] gen_param) : base (0x15)
- {
- typeIndex = 0x15;
- this.gen_type = gen_type;
- this.gen_param = gen_param;
- tabIx = MDTable.TypeSpec;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- gen_type.TypeSig (str);
- MetaData.CompressNum ((uint) gen_param.Length, str);
- foreach (Type param in gen_param)
- param.TypeSig (str);
- }
- }
-
- public class GenericMethodSig {
-
- private Type[] gen_param;
-
- public GenericMethodSig (Type[] gen_param)
- {
- this.gen_param = gen_param;
- }
-
- internal void TypeSig (MemoryStream str)
- {
- MetaData.CompressNum ((uint) gen_param.Length, str); // THIS IS NOT RIGHT, but works
- MetaData.CompressNum ((uint) gen_param.Length, str);
- foreach (Type param in gen_param)
- param.TypeSig (str);
- }
-
- internal uint GetSigIx (MetaData md)
- {
- MemoryStream sig = new MemoryStream();
- TypeSig (sig);
- return md.AddToBlobHeap (sig.ToArray());
- }
- }
-
- public class Sentinel : Type {
-
- public Sentinel () : base (0x41) { }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- }
- }
-
- /// <summary>
- /// The IL Array type
- /// </summary>
- public abstract class Array : Type
- {
-
- protected Type elemType;
- protected MetaData metaData;
- protected string cnameSpace, cname;
-
- internal Array(Type eType, byte TypeId) : base(TypeId) {
- elemType = eType;
- tabIx = MDTable.TypeSpec;
- }
-
- }
-
- /**************************************************************************/
-
- /// <summary>
- /// Single dimensional array with zero lower bound
- /// </summary>
- public class ZeroBasedArray : Array {
-
- /// <summary>
- /// Create a new array - elementType[]
- /// </summary>
- /// <param name="elementType">the type of the array elements</param>
- public ZeroBasedArray(Type elementType) : base (elementType, PrimitiveType.SZArray.GetTypeIndex ()) { }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- elemType.TypeSig(str);
- }
-
- }
-
-
- /**************************************************************************/
-
- /// <summary>
- /// Multi dimensional array with explicit bounds
- /// </summary>
- public class BoundArray : Array {
- int[] lowerBounds;
- int[] sizes;
- uint numDims;
-
- /// <summary>
- /// Create a new multi dimensional array type
- /// eg. elemType[1..5,3..10,5,,] would be
- /// new BoundArray(elemType,5,[1,3,0],[5,10,4])
- /// </summary>
- /// <param name="elementType">the type of the elements</param>
- /// <param name="dimensions">the number of dimensions</param>
- /// <param name="loBounds">lower bounds of dimensions</param>
- /// <param name="upBounds">upper bounds of dimensions</param>
- public BoundArray(Type elementType, uint dimensions, int[] loBounds,
- int[] upBounds) : base (elementType,0x14) {
- numDims = dimensions;
- lowerBounds = loBounds;
- sizes = new int[loBounds.Length];
- for (int i=0; i < loBounds.Length; i++) {
- sizes[i] = upBounds[i] - loBounds[i] + 1;
- }
- }
-
- /// <summary>
- /// Create a new multi dimensional array type
- /// eg. elemType[5,10,20] would be new BoundArray(elemType,3,[5,10,20])
- /// </summary>
- /// <param name="elementType">the type of the elements</param>
- /// <param name="dimensions">the number of dimensions</param>
- /// <param name="size">the sizes of the dimensions</param>
- public BoundArray(Type elementType, uint dimensions, int[] size)
- : base (elementType,0x14) {
- numDims = dimensions;
- sizes = size;
- }
-
- /// <summary>
- /// Create a new multi dimensional array type
- /// eg. elemType[,,] would be new BoundArray(elemType,3)
- /// </summary>
- /// <param name="elementType">the type of the elements</param>
- /// <param name="dimensions">the number of dimensions</param>
- public BoundArray(Type elementType, uint dimensions)
- : base (elementType,0x14) {
- numDims = dimensions;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- elemType.TypeSig(str);
- MetaData.CompressNum(numDims,str);
- if ((sizes != null) && (sizes.Length > 0)) {
- MetaData.CompressNum((uint)sizes.Length,str);
- for (int i=0; i < sizes.Length; i++) {
- MetaData.CompressNum((uint)sizes[i],str);
- }
- } else str.WriteByte(0);
- if ((lowerBounds != null) && (lowerBounds.Length > 0)) {
- MetaData.CompressNum((uint)lowerBounds.Length,str);
- for (int i=0; i < lowerBounds.Length; i++) {
- MetaData.CompressNum((uint)lowerBounds[i],str);
- }
- } else str.WriteByte(0);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for THIS assembly (.assembly)
- /// </summary>
- public class Assembly : ResolutionScope
- {
- ushort majorVer, minorVer, buildNo, revisionNo;
- uint flags;
- uint hashAlgId;
- uint keyIx = 0, cultIx = 0;
- bool hasPublicKey = false;
-
- internal Assembly(string name, MetaData md) : base(name,md) {
- tabIx = MDTable.Assembly;
- }
-
- /// <summary>
- /// Add details about THIS assembly
- /// </summary>
- /// <param name="majVer">Major Version</param>
- /// <param name="minVer">Minor Version</param>
- /// <param name="bldNo">Build Number</param>
- /// <param name="revNo">Revision Number</param>
- /// <param name="key">Hash Key</param>
- /// <param name="hash">Hash Algorithm</param>
- /// <param name="cult">Culture</param>
- public void AddAssemblyInfo(int majVer, int minVer, int bldNo, int revNo,
- byte[] key, uint hash, string cult) {
- majorVer = (ushort)majVer;
- minorVer = (ushort)minVer;
- buildNo = (ushort)bldNo;
- revisionNo = (ushort)revNo;
- hashAlgId = hash;
- hasPublicKey = (key != null);
- keyIx = metaData.AddToBlobHeap(key);
- cultIx = metaData.AddToStringsHeap(cult);
- }
-
- /// <summary>
- /// Add an attribute to THIS assembly
- /// </summary>
- /// <param name="aa">assembly attribute</param>
- public void AddAssemblyAttr(AssemAttr aa) {
- flags |= (uint)aa;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 16 + md.BlobIndexSize() + 2 * md.StringsIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
-// Console.WriteLine("Writing assembly element with nameIx of " + nameIx + " at file offset " + output.Seek(0,SeekOrigin.Current));
- output.Write((uint)hashAlgId);
- output.Write(majorVer);
- output.Write(minorVer);
- output.Write(buildNo);
- output.Write(revisionNo);
- output.Write(flags);
- output.BlobIndex(keyIx);
- output.StringsIndex(nameIx);
- output.StringsIndex(cultIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 14;
- case (CIx.HasDeclSecurity) : return 2;
- }
- return 0;
- }
-
- internal bool HasPublicKey {
- get { return hasPublicKey; }
- }
- }
- /**************************************************************************/
-
- public interface IExternRef {
- ClassRef AddClass(string nsName, string name);
- ClassRef AddValueClass(string nsName, string name);
- }
-
- /// <summary>
- /// A reference to an external assembly (.assembly extern)
- /// </summary>
- public class AssemblyRef : ResolutionScope, IExternRef
- {
- private ushort major, minor, build, revision;
- uint flags, keyIx, hashIx, cultIx;
- bool hasVersion = false, isKeyToken = false;
- byte[] keyBytes;
- string culture;
-
- internal AssemblyRef(MetaData md, string name) : base(name,md) {
- tabIx = MDTable.AssemblyRef;
- }
-
- /// <summary>
- /// Add version information about this external assembly
- /// </summary>
- /// <param name="majVer">Major Version</param>
- /// <param name="minVer">Minor Version</param>
- /// <param name="bldNo">Build Number</param>
- /// <param name="revNo">Revision Number</param>
- public void AddVersionInfo(int majVer, int minVer, int bldNo, int revNo) {
- major = (ushort)majVer;
- minor = (ushort)minVer;
- build = (ushort)bldNo;
- revision = (ushort)revNo;
- hasVersion = true;
- }
-
- /// <summary>
- /// Add the hash value for this external assembly
- /// </summary>
- /// <param name="hash">bytes of the hash value</param>
- public void AddHash(byte[] hash) {
- hashIx = metaData.AddToBlobHeap(hash);
- }
-
- /// <summary>
- /// Set the culture for this external assembly
- /// </summary>
- /// <param name="cult">the culture string</param>
- public void AddCulture(string cult) {
- cultIx = metaData.AddToStringsHeap(cult);
- culture = cult;
- }
-
- /// <summary>
- /// Add the full public key for this external assembly
- /// </summary>
- /// <param name="key">bytes of the public key</param>
- public void AddKey(byte[] key) {
- flags |= 0x0001; // full public key
- keyBytes = key;
- keyIx = metaData.AddToBlobHeap(key);
- }
-
- /// <summary>
- /// Add the public key token (low 8 bytes of the public key)
- /// </summary>
- /// <param name="key">low 8 bytes of public key</param>
- public void AddKeyToken(byte[] key) {
- keyIx = metaData.AddToBlobHeap(key);
- keyBytes = key;
- isKeyToken = true;
- }
-
- /// <summary>
- /// Add a class to this external assembly
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns></returns>
- public virtual ClassRef AddClass(string nsName, string name) {
- ClassRef aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- return aClass;
- }
-
- /// <summary>
- /// Add a value class to this external assembly
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns></returns>
- public virtual ClassRef AddValueClass(string nsName, string name) {
- ClassRef aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- aClass.MakeValueClass(ValueClass.ValueType);
- return aClass;
- }
-
- internal string TypeName() {
- string result = name;
- if (hasVersion)
- result = result + ", Version=" + major + "." + minor + "." +
- build + "." + revision;
- if (keyBytes != null) {
- string tokenStr = "=";
- if (isKeyToken) tokenStr = "Token=";
- result = result + ", PublicKey" + tokenStr;
- for (int i=0; i < keyBytes.Length; i++) {
- result = result + Hex.Byte(keyBytes[i]);
- }
- }
- if (culture != null)
- result = result + ", Culture=" + culture;
- return result;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 12 + 2 * md.StringsIndexSize() + 2 * md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(major);
- output.Write(minor);
- output.Write(build);
- output.Write(revision);
- output.Write(flags);
- output.BlobIndex(keyIx);
- output.StringsIndex(nameIx);
- output.StringsIndex(cultIx);
- output.BlobIndex(hashIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.ResolutionScope) : return 2;
- case (CIx.HasCustomAttr) : return 15;
- case (CIx.Implementation) : return 1;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
-
- /// <summary>
- /// flags for the assembly (.corflags)
- /// </summary>
- public enum CorFlags {CF_IL_ONLY = 1, CF_32_BITREQUIRED = 2,
- CF_STRONGNAMESIGNED = 8, CF_TRACKDEBUGDATA = 0x10000 }
-
- /// <summary>
- /// subsystem for the assembly (.subsystem)
- /// </summary>
- public enum SubSystem { Native = 1, Windows_GUI = 2,
- Windows_CUI = 3, OS2_CUI = 5, POSIX_CUI = 7, Native_Windows = 8,
- Windows_CE_GUI = 9}
-
- /// <summary>
- /// Hash algorithms for the assembly
- /// </summary>
- public enum HashAlgorithm { None, SHA1 }
-
- /// <summary>
- /// Attributes for this assembly
- /// </summary>
- public enum AssemAttr { EnableJITCompileTracking = 0x8000,
- DisableJITCompileOptimizer = 0x4000}
-
- /// <summary>
- /// Method call conventions
- /// </summary>
- public enum CallConv { Default, Cdecl, Stdcall, Thiscall,
- Fastcall, Vararg, Instance = 0x20, Generic = 0x10, InstanceExplicit = 0x60 }
-
- /// <summary>
- /// Type custom modifier
- /// </summary>
- public enum CustomModifier { modreq = 0x1F, modopt };
-
- /// <summary>
- /// Attibutes for a class
- /// </summary>
- public enum TypeAttr {Private, Public, NestedPublic, NestedPrivate,
- NestedFamily, NestedAssembly, NestedFamAndAssem, NestedFamOrAssem,
- SequentialLayout, ExplicitLayout = 0x10, Interface = 0x20,
- Abstract = 0x80, PublicAbstract = 0x81, Sealed = 0x100,
- PublicSealed = 0x101, SpecialName = 0x400, RTSpecialName = 0x800,
- Import = 0x1000, Serializable = 0x2000, UnicodeClass = 0x10000,
- AutoClass = 0x20000, BeforeFieldInit = 0x100000 }
-
- /// <summary>
- /// Attributes for a field
- /// </summary>
- public enum FieldAttr {Default, Private, FamAndAssem, Assembly,
- Family, FamOrAssem, Public, Static = 0x10, PublicStatic = 0x16,
- Initonly = 0x20, Literal = 0x40, Notserialized = 0x80,
- SpecialName = 0x200, RTSpecialName = 0x400 }
-
- /// <summary>
- /// Attributes for a method
- /// </summary>
- public enum MethAttr { Default, Private, FamAndAssem, Assembly,
- Family, FamOrAssem, Public, Static = 0x0010, PublicStatic = 0x16,
- Final = 0x0020, PublicStaticFinal = 0x36, Virtual = 0x0040,
- PrivateVirtual, PublicVirtual = 0x0046, HideBySig = 0x0080,
- NewSlot = 0x0100, Abstract = 0x0400, SpecialName = 0x0800,
- RTSpecialName = 0x1000, SpecialRTSpecialName = 0x1800,
- RequireSecObject = 0x8000}
-
- /// <summary>
- /// Attributes for .pinvokeimpl method declarations
- /// </summary>
- public enum PInvokeAttr { nomangle = 1, ansi = 2, unicode = 4, autochar = 6,
- lasterr = 0x0040, winapi = 0x0100, cdecl = 0x0200,
- stdcall = 0x0300, thiscall = 0x0400, fastcall = 0x0500 }
-
- /// <summary>
- /// Implementation attributes for a method
- /// </summary>
- public enum ImplAttr { IL, Native, Runtime = 0x03, Unmanaged = 0x04,
- ForwardRef = 0x10, PreserveSig = 0x0080, InternalCall = 0x1000,
- Synchronised = 0x0020, Synchronized = 0x0020, NoInLining = 0x0008, Optil = 0x0002}
-
- /// <summary>
- /// Modes for a parameter
- /// </summary>
- public enum ParamAttr { Default, In, Out, Opt = 16 }
-
- /// <summary>
- /// CIL instructions
- /// </summary>
- public enum Op { nop, breakOp, ldarg_0, ldarg_1, ldarg_2, ldarg_3,
- ldloc_0, ldloc_1, ldloc_2, ldloc_3, stloc_0, stloc_1, stloc_2, stloc_3,
- ldnull = 0x14, ldc_i4_m1, ldc_i4_0, ldc_i4_1, ldc_i4_2, ldc_i4_3,
- ldc_i4_4, ldc_i4_5, ldc_i4_6, ldc_i4_7, ldc_i4_8, dup = 0x25, pop,
- ret = 0x2A, ldind_i1 = 0x46, ldind_u1, ldind_i2, ldind_u2, ldind_i4,
- ldind_u4, ldind_i8, ldind_i, ldind_r4, ldind_r8, ldind_ref, stind_ref,
- stind_i1, stind_i2, stind_i4, stind_i8, stind_r4, stind_r8, add, sub, mul,
- div, div_un, rem, rem_un, and, or, xor, shl, shr, shr_un, neg, not,
- conv_i1, conv_i2, conv_i4, conv_i8, conv_r4, conv_r8, conv_u4, conv_u8,
- conv_r_un = 0x76, throwOp = 0x7A, conv_ovf_i1_un = 0x82, conv_ovf_i2_un,
- conv_ovf_i4_un, conv_ovf_i8_un, conf_ovf_u1_un, conv_ovf_u2_un,
- conv_ovf_u4_un, conv_ovf_u8_un, conv_ovf_i_un, conv_ovf_u_un,
- ldlen = 0x8E, ldelem_i1 = 0x90, ldelem_u1, ldelem_i2, ldelem_u2,
- ldelem_i4, ldelem_u4, ldelem_i8, ldelem_i, ldelem_r4, ldelem_r8,
- ldelem_ref, stelem_i, stelem_i1, stelem_i2, stelem_i4, stelem_i8, stelem_r4 = 0xA0, stelem_r8,
- stelem_ref, conv_ovf_i1 = 0xb3, conv_ovf_u1, conv_ovf_i2, conv_ovf_u2,
- conv_ovf_i4, conv_ovf_u4, conv_ovf_i8, conv_ovf_u8, ckfinite = 0xC3,
- conv_u2 = 0xD1, conv_u1, conv_i, conv_ovf_i, conv_ovf_u, add_ovf,
- add_ovf_un, mul_ovf, mul_ovf_un, sub_ovf, sub_ovf_un, endfinally,
- stind_i = 0xDF, conv_u, arglist = 0xFE00, ceq, cgt, cgt_un, clt, clt_un,
- localloc = 0xFE0F, endfilter = 0xFE11, volatile_ = 0xFE13, tail_,
- cpblk = 0xFE17, initblk, rethrow = 0xFE1A, refanytype = 0xFE1D}
-
- /// <summary>
- /// CIL instructions requiring an integer parameter
- /// </summary>
- public enum IntOp {ldarg_s = 0x0E, ldarga_s, starg_s, ldloc_s, ldloca_s,
- stloc_s, ldc_i4_s = 0x1F, ldc_i4, ldarg = 0xFE09,
- ldarga, starg, ldloc, ldloca, stloc, unaligned = 0xFE12 }
-
- /// <summary>
- /// CIL instructions requiring a field parameter
- /// </summary>
- public enum FieldOp {ldfld = 0x7B, ldflda, stfld, ldsfld, ldsflda,
- stsfld, ldtoken = 0xD0 }
-
- /// <summary>
- /// CIL instructions requiring a method parameter
- /// </summary>
- public enum MethodOp {jmp = 0x27, call, callvirt = 0x6F, newobj = 0x73,
- ldtoken = 0xD0, ldftn = 0xFE06, ldvirtfn }
-
- /// <summary>
- /// CIL instructions requiring a type parameter
- /// </summary>
- public enum TypeOp {cpobj = 0x70, ldobj, castclass = 0x74, isinst,
- unbox = 0x79, stobj = 0x81, box = 0x8C, newarr,
- ldelema = 0x8F, refanyval = 0xC2, mkrefany = 0xC6,
- ldtoken = 0xD0, initobj = 0xFE15, sizeOf = 0xFE1C,
- ldelem = 0xA3, stelem = 0xA4, unbox_any }
-
- /// <summary>
- /// CIL branch instructions
- /// </summary>
- public enum BranchOp {
- // short branches
- br_s = 0x2B, brfalse_s, brtrue_s, beq_s, bge_s, bgt_s,
- ble_s, blt_s, bne_un_s, bge_un_s, bgt_un_s, ble_un_s, blt_un_s,
- // long branches
- br = 0x38, brfalse, brtrue, beq, bge, bgt, ble, blt,
- bne_un, bge_un, bgt_un, ble_un, blt_un,
-
- leave = 0xDD, leave_s }
-
- /// <summary>
- /// Index for all the tables in the meta data
- /// </summary>
- public enum MDTable { Module, TypeRef, TypeDef, Field = 0x04, Method = 0x06,
- Param = 0x08, InterfaceImpl, MemberRef, Constant, CustomAttribute,
- FieldMarshal, DeclSecurity, ClassLayout, FieldLayout, StandAloneSig,
- EventMap, Event = 0x14, PropertyMap, Property = 0x17, MethodSemantics,
- MethodImpl, ModuleRef, TypeSpec, ImplMap, FieldRVA, Assembly = 0x20,
- AssemblyProcessor, AssemblyOS, AssemblyRef, AssemblyRefProcessor,
- AssemblyRefOS, File, ExportedType, ManifestResource, NestedClass,
- GenericParam, MethodSpec, GenericParamConstraint }
-
- public enum SafeArrayType { int16 = 2, int32, float32, float64,
- currency, date, bstr, dispatch, error, boolean, variant, unknown,
- Decimal, int8 = 16, uint8, uint16, uint32, Int = 22, UInt }
-
- internal enum CIx { TypeDefOrRef, HasConst, HasCustomAttr, HasFieldMarshal,
- HasDeclSecurity, MemberRefParent, HasSemantics, MethodDefOrRef,
- MemberForwarded, Implementation, CustomAttributeType, ResolutionScope,
- TypeOrMethodDef, MaxCIx }
-
- internal enum MapType { eventMap, propertyMap, nestedClass }
-
- /**************************************************************************/
- /// <summary>
- /// The assembly for mscorlib.
- /// </summary>
- public sealed class MSCorLib : AssemblyRef
- {
- private static readonly int valueTypeIx = 18;
- private readonly string systemName = "System";
- private ClassRef[] systemClasses = new ClassRef[valueTypeIx+2];
- private PrimitiveType[] systemTypes = new PrimitiveType[valueTypeIx];
- private TypeSpec[] specialTypeSpecs = new TypeSpec[valueTypeIx];
- private static int[] specialNames = {
- PrimitiveType.Void.GetName().GetHashCode(),
- PrimitiveType.Boolean.GetName().GetHashCode(),
- PrimitiveType.Char.GetName().GetHashCode(),
- PrimitiveType.Int8.GetName().GetHashCode(),
- PrimitiveType.UInt8.GetName().GetHashCode(),
- PrimitiveType.Int16.GetName().GetHashCode(),
- PrimitiveType.UInt16.GetName().GetHashCode(),
- PrimitiveType.Int32.GetName().GetHashCode(),
- PrimitiveType.UInt32.GetName().GetHashCode(),
- PrimitiveType.Int64.GetName().GetHashCode(),
- PrimitiveType.UInt64.GetName().GetHashCode(),
- PrimitiveType.Float32.GetName().GetHashCode(),
- PrimitiveType.Float64.GetName().GetHashCode(),
- PrimitiveType.String.GetName().GetHashCode(),
- PrimitiveType.TypedRef.GetName().GetHashCode(),
- PrimitiveType.IntPtr.GetName().GetHashCode(),
- PrimitiveType.UIntPtr.GetName().GetHashCode(),
- PrimitiveType.Object.GetName().GetHashCode(),
- PrimitiveType.ValueType.GetName ().GetHashCode(),
- "Enum".GetHashCode()
- };
-
- internal MSCorLib(MetaData md) : base(md,"mscorlib") {
- md.AddToTable(MDTable.AssemblyRef,this);
- systemTypes[PrimitiveType.Void.GetSystemTypeIx()] = PrimitiveType.Void;
- systemTypes[PrimitiveType.Boolean.GetSystemTypeIx()] = PrimitiveType.Boolean;
- systemTypes[PrimitiveType.Char.GetSystemTypeIx()] = PrimitiveType.Char;
- systemTypes[PrimitiveType.Int8.GetSystemTypeIx()] = PrimitiveType.Int8;
- systemTypes[PrimitiveType.UInt8.GetSystemTypeIx()] = PrimitiveType.UInt8;
- systemTypes[PrimitiveType.Int16.GetSystemTypeIx()] = PrimitiveType.Int16;
- systemTypes[PrimitiveType.UInt16.GetSystemTypeIx()] = PrimitiveType.UInt16;
- systemTypes[PrimitiveType.Int32.GetSystemTypeIx()] = PrimitiveType.Int32;
- systemTypes[PrimitiveType.UInt32.GetSystemTypeIx()] = PrimitiveType.UInt32;
- systemTypes[PrimitiveType.Int64.GetSystemTypeIx()] = PrimitiveType.Int64;
- systemTypes[PrimitiveType.UInt64.GetSystemTypeIx()] = PrimitiveType.UInt64;
- systemTypes[PrimitiveType.Float32.GetSystemTypeIx()] = PrimitiveType.Float32;
- systemTypes[PrimitiveType.Float64.GetSystemTypeIx()] = PrimitiveType.Float64;
- systemTypes[PrimitiveType.IntPtr.GetSystemTypeIx()] = PrimitiveType.IntPtr;
- systemTypes[PrimitiveType.UIntPtr.GetSystemTypeIx()] = PrimitiveType.UIntPtr;
- systemTypes[PrimitiveType.String.GetSystemTypeIx()] = PrimitiveType.String;
- systemTypes[PrimitiveType.Object.GetSystemTypeIx()] = PrimitiveType.Object;
- systemTypes[PrimitiveType.TypedRef.GetSystemTypeIx()] = PrimitiveType.TypedRef;
- }
-
- /// <summary>
- /// Add a class to the mscorlib assembly
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns></returns>
- public override ClassRef AddClass(string nsName, string name) {
- ClassRef aClass = GetSpecialClass(nsName,name);
- if (aClass == null) {
- aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- }
- return aClass;
- }
-
- private ClassRef GetSpecialClass(string nsName,string name) {
- if (nsName.CompareTo(systemName) != 0) return null;
- int hash = name.GetHashCode();
- for (int i=0; i < specialNames.Length; i++) {
- if (hash == specialNames[i]) {
- if (systemClasses[i] == null) {
- if (i < valueTypeIx) {
- systemClasses[i] = new SystemClass(systemTypes[i],this,metaData);
- if ((systemTypes[i] != PrimitiveType.Object) &&
- (systemTypes[i] != PrimitiveType.String)) {
- systemClasses[i].MakeValueClass(ValueClass.ValueType);
- }
- } else {
- systemClasses[i] = new ClassRef(nsName,name,metaData);
- systemClasses[i].SetParent(this);
- if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name))
- systemClasses[i].MakeValueClass(ValueClass.ValueType);
- }
- metaData.AddToTable(MDTable.TypeRef,systemClasses[i]);
- }
- return systemClasses[i];
- }
- }
- return null;
- }
-
- internal ClassRef GetSpecialSystemClass(PrimitiveType pType) {
- int ix = pType.GetSystemTypeIx();
- if (systemClasses[ix] == null) {
- systemClasses[ix] = new SystemClass(pType,this,metaData);
- metaData.AddToTable(MDTable.TypeRef,systemClasses[ix]);
- }
- return systemClasses[ix];
- }
-
- private ClassRef GetValueClass(string name, int hash) {
- int ix = valueTypeIx;
- if (hash != specialNames[valueTypeIx]) ix++;
- if (systemClasses[ix] == null) {
- systemClasses[ix] = new ClassRef(systemName,name,metaData);
- systemClasses[ix].SetParent(this);
- systemClasses[ix].MakeValueClass(ValueClass.ValueType);
- metaData.AddToTable(MDTable.TypeRef,systemClasses[ix]);
- }
- return systemClasses[ix];
- }
-
- internal ClassRef ValueType() {
- if (systemClasses[valueTypeIx] == null) {
- ClassRef valType = new ClassRef("System","ValueType",metaData);
- valType.SetParent(this);
- valType.MakeValueClass(ValueClass.ValueType);
- metaData.AddToTable(MDTable.TypeRef,valType);
- systemClasses[valueTypeIx] = valType;
- }
- return systemClasses[valueTypeIx];
- }
-
- internal ClassRef EnumType() {\r
- //systemClasses [ valueTypeIx + 1] -> System.Enum
- if (systemClasses[valueTypeIx + 1] == null) {
- ClassRef valType = new ClassRef("System","Enum",metaData);
- valType.SetParent(this);
- valType.MakeValueClass(ValueClass.Enum);
- metaData.AddToTable(MDTable.TypeRef,valType);
- systemClasses[valueTypeIx + 1] = valType;
- }
- return systemClasses[valueTypeIx + 1];
- }
-
- /// <summary>
- /// Add a value class to this external assembly
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns></returns>
- public override ClassRef AddValueClass(string nsName, string name) {
- if (nsName.CompareTo(systemName) == 0) {
- int hash = name.GetHashCode();
- if ((hash == specialNames[valueTypeIx]) ||
- (hash == specialNames[valueTypeIx+1])) {
- return GetValueClass(name,hash);
- }
- }
- ClassRef aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- aClass.MakeValueClass(ValueClass.ValueType);
- return aClass;
- }
-
- }
- public enum ValueClass
- {
- ValueType,
- Enum
- }
-
- /**************************************************************************/
- /// <summary>
- /// Signature for calli instruction
- /// </summary>
- public class CalliSig : Signature
- {
- private static readonly byte Sentinel = 0x41;
- CallConv callConv;
- Type returnType;
- Type[] parameters, optParams;
- uint numPars = 0, numOptPars = 0;
-
- /// <summary>
- /// Create a signature for a calli instruction
- /// </summary>
- /// <param name="cconv">calling conventions</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameter types</param>
- public CalliSig(CallConv cconv, Type retType, Type[] pars) {
- tabIx = MDTable.StandAloneSig;
- callConv = cconv;
- returnType = retType;
- parameters = pars;
- if (pars != null) numPars = (uint)pars.Length;
- }
-
- /// <summary>
- /// Add the optional parameters to a vararg method
- /// This method sets the vararg calling convention
- /// </summary>
- /// <param name="optPars">the optional pars for the vararg call</param>
- public void AddVarArgs(Type[] optPars) {
- optParams = optPars;
- if (optPars != null) numOptPars = (uint)optPars.Length;
- callConv |= CallConv.Vararg;
- }
-
- /// <summary>
- /// Add extra calling conventions to this callsite signature
- /// </summary>
- /// <param name="cconv"></param>
- public void AddCallingConv(CallConv cconv) {
- callConv |= cconv;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- MemoryStream sig = new MemoryStream();
- sig.WriteByte((byte)callConv);
- MetaData.CompressNum(numPars+numOptPars,sig);
- returnType.TypeSig(sig);
- for (int i=0; i < numPars; i++) {
- parameters[i].TypeSig(sig);
- }
- sigIx = md.AddToBlobHeap(sig.ToArray());
- if (numOptPars > 0) {
- sig.WriteByte(Sentinel);
- for (int i=0; i < numOptPars; i++) {
- optParams[i].TypeSig(sig);
- }
- }
- done = true;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// The IL instructions for a method
- /// </summary>
- public class CILInstructions
- {
-
- private static readonly uint ExHeaderSize = 4;
- private static readonly uint FatExClauseSize = 24;
- private static readonly uint SmlExClauseSize = 12;
- private static readonly sbyte maxByteVal = 127;
- private static readonly sbyte minByteVal = -128;
- private static readonly byte maxUByteVal = 255;
- private static readonly int smallSize = 64;
- private static readonly ushort TinyFormat = 0x2;
- private static readonly ushort FatFormat = 0x3003;
- private static readonly ushort MoreSects = 0x8;
- private static readonly ushort InitLocals = 0x10;
- private static readonly uint FatSize = 12;
- private static readonly uint FatWords = FatSize/4;
- private static readonly byte FatExceptTable = 0x41;
- private static readonly byte SmlExceptTable = 0x01;
-
- private MetaData metaData;
- private ArrayList exceptions, blockStack;
- //private bool codeChecked = false;
- private static readonly int INITSIZE = 5;
- private CILInstruction[] buffer = new CILInstruction[INITSIZE];
- private int tide = 0;
- private uint offset = 0;
- private ushort headerFlags = 0;
- private short maxStack;
- private uint paddingNeeded = 0;
- private byte exceptHeader = 0;
- uint localSigIx = 0;
- uint codeSize = 0, exceptSize = 0;
- bool tinyFormat, fatExceptionFormat = false;
-
- public uint Offset {
- get { return offset; }
- }
-
- internal CILInstructions(MetaData md) {
- metaData = md;
- }
-
- private void AddToBuffer(CILInstruction inst) {
- if (tide >= buffer.Length) {
- CILInstruction[] tmp = buffer;
- buffer = new CILInstruction[tmp.Length * 2];
- for (int i=0; i < tide; i++) {
- buffer[i] = tmp[i];
- }
- }
- //Console.WriteLine("Adding instruction at offset " + offset + " with size " + inst.size);
- inst.offset = offset;
- offset += inst.size;
- buffer[tide++] = inst;
- }
-
- /// <summary>
- /// Add a simple IL instruction
- /// </summary>
- /// <param name="inst">the IL instruction</param>
- public void Inst(Op inst) {
- AddToBuffer(new Instr((int)inst));
- }
-
- /// <summary>
- /// Add an IL instruction with an integer parameter
- /// </summary>
- /// <param name="inst">the IL instruction</param>
- /// <param name="val">the integer parameter value</param>
- public void IntInst(IntOp inst, int val) {
- int instr = (int)inst;
- if ((inst == IntOp.ldc_i4_s) || (inst == IntOp.ldc_i4))
- AddToBuffer(new IntInstr(instr,val,(inst == IntOp.ldc_i4_s)));
- else
- AddToBuffer(new UIntInstr(instr,val,((inst < IntOp.ldc_i4_s) ||
- (inst == IntOp.unaligned))));
- }
-
- /// <summary>
- /// Add the load long instruction
- /// </summary>
- /// <param name="cVal">the long value</param>
- public void ldc_i8(long cVal) {
- AddToBuffer(new LongInstr(0x21,cVal));
- }
-
- /// <summary>
- /// Add the load float32 instruction
- /// </summary>
- /// <param name="cVal">the float value</param>
- public void ldc_r4(float cVal) {
- AddToBuffer(new FloatInstr(0x22,cVal));
- }
-
- /// <summary>
- /// Add the load float64 instruction
- /// </summary>
- /// <param name="cVal">the float value</param>
- public void ldc_r8(double cVal) {
- AddToBuffer(new DoubleInstr(0x23,cVal));
- }
-
- /// <summary>
- /// Add the load string instruction
- /// </summary>
- /// <param name="str">the string value</param>
- public void ldstr(string str) {
- AddToBuffer(new StringInstr(0x72,str));
- }
-
- /// <summary>
- /// Add the load string instruction
- /// </summary>
- public void ldstr (byte[] str) {
- AddToBuffer (new StringInstr (0x72, str));
- }
-
- /// <summary>
- /// Add the calli instruction
- /// </summary>
- /// <param name="sig">the signature for the calli</param>
- public void calli(CalliSig sig) {
- AddToBuffer(new SigInstr(0x29,sig));
- }
-
- /// <summary>
- /// Add a label to the CIL instructions
- /// </summary>
- /// <param name="lab">the label to be added</param>
- public void CodeLabel(CILLabel lab) {
- AddToBuffer(new LabelInstr(lab));
- }
-
- /// <summary>
- /// Add an instruction with a field parameter
- /// </summary>
- /// <param name="inst">the CIL instruction</param>
- /// <param name="f">the field parameter</param>
- public void FieldInst(FieldOp inst, Field f) {
- AddToBuffer(new FieldInstr((int)inst,f));
- }
-
- /// <summary>
- /// Add an instruction with a method parameter
- /// </summary>
- /// <param name="inst">the CIL instruction</param>
- /// <param name="m">the method parameter</param>
- public void MethInst(MethodOp inst, Method m) {
- AddToBuffer(new MethInstr((int)inst,m));
- }
-
- /// <summary>
- /// Add an instruction with a type parameter
- /// </summary>
- /// <param name="inst">the CIL instruction</param>
- /// <param name="t">the type argument for the CIL instruction</param>
- public void TypeInst(TypeOp inst, Type aType) {
- AddToBuffer(new TypeInstr((int)inst,aType,metaData));
- }
-
- /// <summary>
- /// Add a branch instruction
- /// </summary>
- /// <param name="inst">the branch instruction</param>
- /// <param name="lab">the label that is the target of the branch</param>
- public void Branch(BranchOp inst, CILLabel lab) {
- AddToBuffer(new BranchInstr((int)inst,lab));
- }
-
- /// <summary>
- /// Add a switch instruction
- /// </summary>
- /// <param name="labs">the target labels for the switch</param>
- public void Switch(CILLabel[] labs) {
- AddToBuffer(new SwitchInstr(0x45,labs));
- }
-
- /// <summary>
- /// Add a byte to the CIL instructions (.emitbyte)
- /// </summary>
- /// <param name="bVal"></param>
- public void emitbyte(byte bVal) {
- AddToBuffer(new CILByte(bVal));
- }
-
- /// <summary>
- /// Add an instruction which puts an integer on TOS. This method
- /// selects the correct instruction based on the value of the integer.
- /// </summary>
- /// <param name="i">the integer value</param>
- public void PushInt(int i) {
- if (i == -1) {
- AddToBuffer(new Instr((int)Op.ldc_i4_m1));
- } else if ((i >= 0) && (i <= 8)) {
- Op op = (Op)(Op.ldc_i4_0 + i);
- AddToBuffer(new Instr((int)op));
- } else if ((i >= minByteVal) && (i <= maxByteVal)) {
- AddToBuffer(new IntInstr((int)IntOp.ldc_i4_s,i,true));
- } else {
- AddToBuffer(new IntInstr((int)IntOp.ldc_i4,i,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to load a long on TOS
- /// </summary>
- /// <param name="l">the long value</param>
- public void PushLong(long l) {
- AddToBuffer(new LongInstr(0x21,l));
- }
-
- /// <summary>
- /// Add an instruction to push the boolean value true on TOS
- /// </summary>
- public void PushTrue() {
- AddToBuffer(new Instr((int)Op.ldc_i4_1));
- }
-
- /// <summary>
- /// Add an instruction to push the boolean value false on TOS
- /// </summary>
- public void PushFalse() {
- AddToBuffer(new Instr((int)Op.ldc_i4_0));
- }
-
- /// <summary>
- /// Add the instruction to load an argument on TOS. This method
- /// selects the correct instruction based on the value of argNo
- /// </summary>
- /// <param name="argNo">the number of the argument</param>
- public void LoadArg(int argNo) {
- if (argNo < 4) {
- int op = (int)Op.ldarg_0 + argNo;
- AddToBuffer(new Instr(op));
- } else if (argNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.ldarg,argNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x09,argNo,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to load the address of an argument on TOS.
- /// This method selects the correct instruction based on the value
- /// of argNo.
- /// </summary>
- /// <param name="argNo">the number of the argument</param>
- public void LoadArgAdr(int argNo) {
- if (argNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.ldarga,argNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x0A,argNo,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to load a local on TOS. This method selects
- /// the correct instruction based on the value of locNo.
- /// </summary>
- /// <param name="locNo">the number of the local to load</param>
- public void LoadLocal(int locNo) {
- if (locNo < 4) {
- int op = (int)Op.ldloc_0 + locNo;
- AddToBuffer(new Instr(op));
- } else if (locNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.ldloc,locNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x0C,locNo,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to load the address of a local on TOS.
- /// This method selects the correct instruction based on the
- /// value of locNo.
- /// </summary>
- /// <param name="locNo">the number of the local</param>
- public void LoadLocalAdr(int locNo) {
- if (locNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.ldloca,locNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x0D,locNo,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to store to an argument. This method
- /// selects the correct instruction based on the value of argNo.
- /// </summary>
- /// <param name="argNo">the argument to be stored to</param>
- public void StoreArg(int argNo) {
- if (argNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.starg,argNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x0B,argNo,false));
- }
- }
-
- /// <summary>
- /// Add the instruction to store to a local. This method selects
- /// the correct instruction based on the value of locNo.
- /// </summary>
- /// <param name="locNo">the local to be stored to</param>
- public void StoreLocal(int locNo) {
- if (locNo < 4) {
- int op = (int)Op.stloc_0 + locNo;
- AddToBuffer(new Instr(op));
- } else if (locNo <= maxUByteVal) {
- AddToBuffer(new UIntInstr((int)IntOp.stloc,locNo,true));
- } else {
- AddToBuffer(new UIntInstr(0x0E,locNo,false));
- }
- }
-
- /// <summary>
- /// Create a new CIL label. To place the label in the CIL instruction
- /// stream use CodeLabel.
- /// </summary>
- /// <returns>a new CIL label</returns>
- public CILLabel NewLabel() {
- return new CILLabel();
- }
-
- public void AddTryBlock(TryBlock tryBlock) {
- if (exceptions == null)
- exceptions = new ArrayList();
- else if (exceptions.Contains(tryBlock)) return;
- exceptions.Add(tryBlock);
- }
-
- /// <summary>
- /// Create a new label at this position in the code buffer
- /// </summary>
- /// <returns>the label at the current position</returns>
- public CILLabel NewCodedLabel() {
- CILLabel lab = new CILLabel();
- AddToBuffer(new LabelInstr(lab));
- return lab;
- }
-
- /// <summary>
- /// Mark this position as the start of a new block
- /// (try, catch, filter, finally or fault)
- /// </summary>
- public void StartBlock() {
- if (blockStack == null) blockStack = new ArrayList();
- blockStack.Insert(0,NewCodedLabel());
- }
-
- /// <summary>
- /// Mark this position as the end of the last started block and
- /// make it a try block. This try block is added to the current
- /// instructions (ie do not need to call AddTryBlock)
- /// </summary>
- /// <returns>The try block just ended</returns>
- public TryBlock EndTryBlock() {
- TryBlock tBlock = new TryBlock((CILLabel)blockStack[0],NewCodedLabel());
- blockStack.RemoveAt(0);
- AddTryBlock(tBlock);
- return tBlock;
- }
-
- /// <summary>
- /// Mark this position as the end of the last started block and
- /// make it a catch block. This catch block is associated with the
- /// specified try block.
- /// </summary>
- /// <param name="exceptType">the exception type to be caught</param>
- /// <param name="tryBlock">the try block associated with this catch block</param>
- public void EndCatchBlock(Class exceptType, TryBlock tryBlock) {
- Catch catchBlock = new Catch(exceptType,(CILLabel)blockStack[0],
- NewCodedLabel());
- tryBlock.AddHandler(catchBlock);
- }
-
- /// <summary>
- /// Mark this position as the end of the last started block and
- /// make it a filter block. This filter block is associated with the
- /// specified try block.
- /// </summary>
- /// <param name="filterLab">the label where the filter code is</param>
- /// <param name="tryBlock">the try block associated with this filter block</param>
- public void EndFilterBlock(CILLabel filterLab, TryBlock tryBlock) {
- Filter filBlock = new Filter(filterLab,(CILLabel)blockStack[0],NewCodedLabel());
- tryBlock.AddHandler(filBlock);
- }
-
- /// <summary>
- /// Mark this position as the end of the last started block and
- /// make it a finally block. This finally block is associated with the
- /// specified try block.
- /// </summary>
- /// <param name="tryBlock">the try block associated with this finally block</param>
- public void EndFinallyBlock(TryBlock tryBlock) {
- Finally finBlock= new Finally((CILLabel)blockStack[0],NewCodedLabel());
- tryBlock.AddHandler(finBlock);
- }
-
- /// <summary>
- /// Mark this position as the end of the last started block and
- /// make it a fault block. This fault block is associated with the
- /// specified try block.
- /// </summary>
- /// <param name="tryBlock">the try block associated with this fault block</param>
- public void EndFaultBlock(TryBlock tryBlock) {
- Fault fBlock= new Fault((CILLabel)blockStack[0],NewCodedLabel());
- tryBlock.AddHandler(fBlock);
- }
-
- internal uint GetCodeSize() {
- return codeSize + paddingNeeded + exceptSize;
- }
-
- internal void CheckCode(uint locSigIx, bool initLocals, int maxStack) {
- if (tide == 0) return;
- bool changed = true;
- while (changed) {
- changed = false;
- for (int i=0; i < tide; i++) {
- changed = buffer[i].Check(metaData) || changed;
- }
- if (changed) {
- for (int i=1; i < tide; i++) {
- buffer[i].offset = buffer[i-1].offset + buffer[i-1].size;
- }
- offset = buffer[tide-1].offset + buffer[tide-1].size;
- }
- }
- codeSize = offset;
- // Console.WriteLine("codeSize before header added = " + codeSize);
- if ((offset < smallSize) && (maxStack <= 8) && (locSigIx == 0) && (exceptions == null)) {
- // can use tiny header
- //Console.WriteLine("Tiny Header");
- tinyFormat = true;
- headerFlags = (ushort)(TinyFormat | ((ushort)codeSize << 2));
- codeSize++;
- if ((codeSize % 4) != 0) { paddingNeeded = 4 - (codeSize % 4); }
- } else {
- //Console.WriteLine("Fat Header");
- tinyFormat = false;
- localSigIx = locSigIx;
- this.maxStack = (short)maxStack;
- headerFlags = FatFormat;
- if (exceptions != null) {
- // Console.WriteLine("Got exceptions");
- headerFlags |= MoreSects;
- uint numExceptClauses = 0;
- for (int i=0; i < exceptions.Count; i++) {
- TryBlock tryBlock = (TryBlock)exceptions[i];
- tryBlock.SetSize();
- numExceptClauses += (uint)tryBlock.NumHandlers();
- if (tryBlock.isFat()) fatExceptionFormat = true;
- }
-
- uint data_size = ExHeaderSize + numExceptClauses *
- (fatExceptionFormat ? FatExClauseSize : SmlExClauseSize);
-
- if (data_size > 256)
- fatExceptionFormat = true;
-
- // Console.WriteLine("numexceptclauses = " + numExceptClauses);
- if (fatExceptionFormat) {
- // Console.WriteLine("Fat exception format");
- exceptHeader = FatExceptTable;
- exceptSize = ExHeaderSize + numExceptClauses * FatExClauseSize;
- } else {
- // Console.WriteLine("Tiny exception format");
- exceptHeader = SmlExceptTable;
- exceptSize = ExHeaderSize + numExceptClauses * SmlExClauseSize;
- }
- // Console.WriteLine("exceptSize = " + exceptSize);
- }
- if (initLocals) headerFlags |= InitLocals;
- if ((offset % 4) != 0) { paddingNeeded = 4 - (offset % 4); }
- codeSize += FatSize;
- }
- // Console.WriteLine("codeSize = " + codeSize + " headerFlags = " +
- // Hex.Short(headerFlags));
- }
-
- internal void Write(FileImage output) {
- // Console.WriteLine("Writing header flags = " + Hex.Short(headerFlags));
- if (tinyFormat) {
- // Console.WriteLine("Writing tiny code");
- output.Write((byte)headerFlags);
- } else {
- // Console.WriteLine("Writing fat code");
- output.Write(headerFlags);
- output.Write((ushort)maxStack);
- output.Write(offset);
- output.Write(localSigIx);
- }
- // Console.WriteLine(Hex.Int(tide) + " CIL instructions");
- // Console.WriteLine("starting instructions at " + output.Seek(0,SeekOrigin.Current));
- for (int i=0; i < tide; i++) {
- buffer[i].Write(output);
- }
- // Console.WriteLine("ending instructions at " + output.Seek(0,SeekOrigin.Current));
- for (int i=0; i < paddingNeeded; i++) { output.Write((byte)0); }
- if (exceptions != null) {
- // Console.WriteLine("Writing exceptions");
- // Console.WriteLine("header = " + Hex.Short(exceptHeader) + " exceptSize = " + Hex.Int(exceptSize));
- output.Write(exceptHeader);
- output.Write3Bytes((uint)exceptSize);
- for (int i=0; i < exceptions.Count; i++) {
- TryBlock tryBlock = (TryBlock)exceptions[i];
- tryBlock.Write(output,fatExceptionFormat);
- }
- }
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// A label in the IL
- /// </summary>
- public class CILLabel
- {
- CILInstruction branch;
- CILInstruction[] multipleBranches;
- int tide = 0;
- CILInstruction labInstr;
- uint offset = 0;
-
- public CILLabel (uint offset) {
- this.offset = offset;
- }
-
-
- internal CILLabel() {
- }
-
- internal void AddBranch(CILInstruction instr) {
- if (branch == null) {
- branch = instr;
- return;
- }
- if (multipleBranches == null) {
- multipleBranches = new CILInstruction[2];
- } else if (tide >= multipleBranches.Length) {
- CILInstruction[] tmp = multipleBranches;
- multipleBranches = new CILInstruction[tmp.Length*2];
- for (int i=0; i < tide; i++) {
- multipleBranches[i] = tmp[i];
- }
- }
- multipleBranches[tide++] = instr;
- }
-
- internal void AddLabelInstr(LabelInstr lInstr) {
- labInstr = lInstr;
- }
-
- internal uint GetLabelOffset() {
- if (labInstr == null) return 0;
- return labInstr.offset + offset;
- }
-
- }
- /**************************************************************************/
- public abstract class CodeBlock {
-
- private static readonly int maxCodeSize = 256;
- protected CILLabel start, end;
- protected bool small = true;
-
- public CodeBlock(CILLabel start, CILLabel end) {
- this.start = start;
- this.end = end;
- }
-
- internal virtual bool isFat() {
- // Console.WriteLine("block start = " + start.GetLabelOffset() +
- // " block end = " + end.GetLabelOffset());
- return (end.GetLabelOffset() - start.GetLabelOffset()) > maxCodeSize;
- }
-
- internal virtual void Write(FileImage output, bool fatFormat) {
- if (fatFormat) output.Write(start.GetLabelOffset());
- else output.Write((short)start.GetLabelOffset());
- uint len = end.GetLabelOffset() - start.GetLabelOffset();
- if (fatFormat) output.Write(len);
- else output.Write((byte)len);
- }
-
- }
-
- /// <summary>
- /// The descriptor for a guarded block (.try)
- /// </summary>
- public class TryBlock : CodeBlock {
- protected bool fatFormat = false;
- protected int flags = 0;
- ArrayList handlers = new ArrayList();
-
- /// <summary>
- /// Create a new try block
- /// </summary>
- /// <param name="start">start label for the try block</param>
- /// <param name="end">end label for the try block</param>
- public TryBlock(CILLabel start, CILLabel end) : base(start,end) { }
-
- /// <summary>
- /// Add a handler to this try block
- /// </summary>
- /// <param name="handler">a handler to be added to the try block</param>
- public void AddHandler(HandlerBlock handler) {
- flags = handler.GetFlag();
- handlers.Add(handler);
- }
-
- internal void SetSize() {
- fatFormat = base.isFat();
- if (fatFormat) return;
- for (int i=0; i < handlers.Count; i++) {
- HandlerBlock handler = (HandlerBlock)handlers[i];
- if (handler.isFat()) {
- fatFormat = true;
- return;
- }
- }
- }
-
- internal int NumHandlers() {
- return handlers.Count;
- }
-
- internal override bool isFat() {
- return fatFormat;
- }
-
- internal override void Write(FileImage output, bool fatFormat) {
- // Console.WriteLine("writing exception details");
- for (int i=0; i < handlers.Count; i++) {
- // Console.WriteLine("Except block " + i);
- HandlerBlock handler = (HandlerBlock)handlers[i];
- if (fatFormat) output.Write(flags);
- else output.Write((short)flags);
- // Console.WriteLine("flags = " + Hex.Short(flags));
- base.Write(output,fatFormat);
- handler.Write(output,fatFormat);
- }
- }
- }
-
- public abstract class HandlerBlock : CodeBlock
- {
- protected static readonly short ExceptionFlag = 0;
- protected static readonly short FilterFlag = 0x01;
- protected static readonly short FinallyFlag = 0x02;
- protected static readonly short FaultFlag = 0x04;
-
- public HandlerBlock(CILLabel start, CILLabel end) : base(start,end) { }
-
- internal virtual short GetFlag() { return ExceptionFlag; }
-
- internal override void Write(FileImage output, bool fatFormat) {
- base.Write(output,fatFormat);
- }
-
- }
-
- /// <summary>
- /// The descriptor for a catch clause (.catch)
- /// </summary>
- public class Catch : HandlerBlock
- {
- Class exceptType;
-
- /// <summary>
- /// Create a new catch clause
- /// </summary>
- /// <param name="except">the exception to be caught</param>
- /// <param name="handlerStart">start of the handler code</param>
- /// <param name="handlerEnd">end of the handler code</param>
- public Catch(Class except, CILLabel handlerStart, CILLabel handlerEnd)
- : base(handlerStart,handlerEnd) {
- exceptType = except;
- }
-
- internal override void Write(FileImage output, bool fatFormat) {
- base.Write(output,fatFormat);
- output.Write(exceptType.Token());
- }
- }
-
- /// <summary>
- /// The descriptor for a filter clause (.filter)
- /// </summary>
- public class Filter : HandlerBlock
- {
- CILLabel filterLabel;
-
- /// <summary>
- /// Create a new filter clause
- /// </summary>
- /// <param name="filterLabel">the label where the filter code starts</param>
- /// <param name="handlerStart">the start of the handler code</param>
- /// <param name="handlerEnd">the end of the handler code</param>
- public Filter(CILLabel filterLabel, CILLabel handlerStart,
- CILLabel handlerEnd) : base(handlerStart,handlerEnd) {
- this.filterLabel = filterLabel;
- }
-
- internal override short GetFlag() {
- return FilterFlag;
- }
-
- internal override void Write(FileImage output, bool fatFormat) {
- base.Write(output,fatFormat);
- output.Write(filterLabel.GetLabelOffset());
- }
-
- }
-
- /// <summary>
- /// Descriptor for a finally block (.finally)
- /// </summary>
- public class Finally : HandlerBlock
- {
- /// <summary>
- /// Create a new finally clause
- /// </summary>
- /// <param name="finallyStart">start of finally code</param>
- /// <param name="finallyEnd">end of finally code</param>
- public Finally(CILLabel finallyStart, CILLabel finallyEnd)
- : base(finallyStart,finallyEnd) { }
-
- internal override short GetFlag() {
- return FinallyFlag;
- }
-
- internal override void Write(FileImage output, bool fatFormat) {
- base.Write(output,fatFormat);
- output.Write((int)0);
- }
-
- }
-
- /// <summary>
- /// Descriptor for a fault block (.fault)
- /// </summary>
- public class Fault : HandlerBlock
- {
- /// <summary>
- /// Create a new fault clause
- /// </summary>
- /// <param name="faultStart">start of the fault code</param>
- /// <param name="faultEnd">end of the fault code</param>
- public Fault(CILLabel faultStart, CILLabel faultEnd)
- : base(faultStart,faultEnd) { }
-
- internal override short GetFlag() {
- return FaultFlag;
- }
-
- internal override void Write(FileImage output, bool fatFormat) {
- base.Write(output,fatFormat);
- output.Write((int)0);
-
- }
- }
-
- /**************************************************************************/
- /// <summary>
- /// The base descriptor for a class
- /// </summary>
- public abstract class Class : Type
- {
- protected int row = 0;
- public string name, nameSpace;
- protected uint nameIx, nameSpaceIx;
- protected MetaData _metaData;
- internal Class(string nameSpaceName, string className, MetaData md)
- : base(PrimitiveType.Class.GetTypeIndex ()) {
- nameSpace = nameSpaceName;
- name = className;
- nameIx = md.AddToStringsHeap(name);
- nameSpaceIx = md.AddToStringsHeap(nameSpace);
- _metaData = md;
- }
-
- internal Class(uint nsIx, uint nIx) : base(PrimitiveType.Class.GetTypeIndex ()) {
- nameSpaceIx = nsIx;
- nameIx = nIx;
- }
-
- internal virtual uint TypeDefOrRefToken() { return 0; }
-
- internal virtual void MakeValueClass(ValueClass vClass) {
- typeIndex = PrimitiveType.ValueType.GetTypeIndex ();
- }
-
- internal virtual string TypeName() {
- return (nameSpace + "." + name);
- }
-
- internal override MetaDataElement GetTypeSpec(MetaData md) {
- return this;
- }
- }
- /**************************************************************************/
- // This Class produces entries in the TypeDef table of the MetaData
- // in the PE meta data.
-
- // NOTE: Entry 0 in TypeDef table is always the pseudo class <module>
- // which is the parent for functions and variables declared a module level
-
- /// <summary>
- /// The descriptor for a class defined in the IL (.class) in the current assembly/module
- /// </summary>
- ///
- public class ClassDef : Class
- {
- private static readonly uint HasSecurity = 0x00040000;
- private static readonly byte ElementType_Class = 0x12;
-
- Class superType;
- ArrayList fields = new ArrayList();
- ArrayList methods = new ArrayList();
- ArrayList events;
- ArrayList properties;
- bool typeIndexChecked = true;
- uint fieldIx = 0, methodIx = 0;
- byte[] securityActions;
- uint flags;
- ClassLayout layout;
- ClassDef parentClass;
- MetaData metaData;
-
- internal ClassDef(TypeAttr attrSet, string nsName, string name,
- MetaData md) : base(nsName, name, md) {
- metaData = md;
- superType = metaData.mscorlib.GetSpecialSystemClass(PrimitiveType.Object);
- flags = (uint)attrSet;
- tabIx = MDTable.TypeDef;
- }
-
- internal void SetSuper(Class sClass) {
- superType = sClass;
- if (sClass is ClassRef)
- typeIndex = superType.GetTypeIndex();
- else
- typeIndexChecked = false;
- }
-
- internal override void MakeValueClass(ValueClass vClass) {
- if (vClass == ValueClass.Enum)
- superType = metaData.mscorlib.EnumType();
- else
- superType = metaData.mscorlib.ValueType();
-
- typeIndex = superType.GetTypeIndex();
- }
-
- public void SpecialNoSuper() {
- superType = null;
- }
-
- /// <summary>
- /// Add an attribute to this class
- /// </summary>
- /// <param name="ta">the attribute to be added</param>
- public void AddAttribute(TypeAttr ta) {
- flags |= (uint)ta;
- }
-
- /// <summary>
- /// Add an interface that is implemented by this class
- /// </summary>
- /// <param name="iFace">the interface that is implemented</param>
- public void AddImplementedInterface(Class iFace) {
- metaData.AddToTable(MDTable.InterfaceImpl,new InterfaceImpl(this,iFace));
- }
-
- /// <summary>
- /// Add a named generic type parameter
- /// </summary>
- public GenericParameter AddGenericParameter (short index, string name) {
- GenericParameter gp = new GenericParameter (this, metaData, index, name);
- metaData.AddToTable (MDTable.GenericParam, gp);
- return gp;
- }
-
- /// <summary>
- /// Add a field to this class
- /// </summary>
- /// <param name="name">field name</param>
- /// <param name="fType">field type</param>
- /// <returns>a descriptor for this new field</returns>
- public FieldDef AddField(string name, Type fType) {
- FieldDef field = new FieldDef(name,fType);
- fields.Add(field);
- return field;
- }
-
- /// <summary>
- /// Add a field to this class
- /// </summary>
- /// <param name="fAtts">attributes for this field</param>
- /// <param name="name">field name</param>
- /// <param name="fType">field type</param>
- /// <returns>a descriptor for this new field</returns>
- public FieldDef AddField(FieldAttr fAtts, string name, Type fType) {
- FieldDef field = new FieldDef(fAtts,name,fType);
- fields.Add(field);
- return field;
- }
-
- public void SetFieldOrder (ArrayList fields)
- {
- this.fields = fields;
- }
-
- /// <summary>
- /// Add a method to this class
- /// </summary>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameters</param>
- /// <returns>a descriptor for this new method</returns>
- public MethodDef AddMethod(string name, Type retType, Param[] pars) {
- // Console.WriteLine("Adding method " + name + " to class " + this.name);
- MethodDef meth = new MethodDef(metaData,name,retType, pars);
- methods.Add(meth);
- return meth;
- }
-
- /// <summary>
- /// Add a method to this class
- /// </summary>
- /// <param name="mAtts">attributes for this method</param>
- /// <param name="iAtts">implementation attributes for this method</param>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameters</param>
- /// <returns>a descriptor for this new method</returns>
- public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name,
- Type retType, Param[] pars) {
- // Console.WriteLine("Adding method " + name + " to class " + this.name);
- MethodDef meth = new MethodDef(metaData,mAtts,iAtts,name,retType,pars);
- methods.Add(meth);
- return meth;
- }
-
- /// <summary>
- /// Add an event to this class
- /// </summary>
- /// <param name="name">event name</param>
- /// <param name="eType">event type</param>
- /// <returns>a descriptor for this new event</returns>
- public Event AddEvent(string name, Type eType) {
- Event e = new Event(name,eType,this);
- if (events == null) events = new ArrayList();
- events.Add(e);
- return e;
- }
-
- /// <summary>
- /// Add a property to this class
- /// </summary>
- /// <param name="name">property name</param>
- /// <param name="propType">property type</param>
- /// <returns>a descriptor for this new property</returns>
- public Property AddProperty(string name, Type retType, Type[] pars) {
- Property p = new Property(name, retType, pars, this);
- if (properties == null) properties = new ArrayList();
- properties.Add(p);
- return p;
- }
-
-
- /// <summary>
- /// Add a nested class to this class
- /// </summary>
- /// <param name="attrSet">attributes for this nested class</param>
- /// <param name="nsName">nested name space name</param>
- /// <param name="name">nested class name</param>
- /// <returns>a descriptor for this new nested class</returns>
- public ClassDef AddNestedClass(TypeAttr attrSet, string nsName,
- string name) {
- ClassDef nClass = new ClassDef(attrSet,"",name,metaData);
- metaData.AddToTable(MDTable.TypeDef,nClass);
- metaData.AddToTable(MDTable.NestedClass,new MapElem(nClass,Row,MDTable.TypeDef));
- nClass.parentClass = this;
- return (nClass);
- }
- public static bool IsValueType (Class type)
- {
- return IsValueType (type.nameSpace, type.name);
- }
-
- public static bool IsEnum (Class type)
- {
- return IsEnum (type.nameSpace, type.name);
- }
-
- public static bool IsValueType (string nsName, string name)
- {
- return ((nsName.CompareTo ("System") == 0) &&
- (name.CompareTo ("ValueType") == 0));
- }
-
- public static bool IsEnum (string nsName, string name)
- {
- return ((nsName.CompareTo ("System") == 0) &&
- (name.CompareTo ("Enum") == 0));
- }
-
- /// <summary>
- /// Add a nested class to this class
- /// </summary>
- /// <param name="attrSet">attributes for this nested class</param>
- /// <param name="nsName">nested name space name</param>
- /// <param name="name">nested class name</param>
- /// <param name="sType">super type of this nested class</param>
- /// <returns>a descriptor for this new nested class</returns>
- public ClassDef AddNestedClass(TypeAttr attrSet, string nsName,
- string name, Class sType) {
- ClassDef nClass = AddNestedClass (attrSet, nsName, name);
- nClass.SetSuper(sType);
- if (ClassDef.IsValueType (sType))
- nClass.MakeValueClass (ValueClass.ValueType);
- else
- if (ClassDef.IsEnum (sType))
- nClass.MakeValueClass (ValueClass.Enum);
-
- if (ClassDef.IsValueType (sType) || ClassDef.IsEnum (sType))
- nClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ());
-
- return (nClass);
- }
-
- /// <summary>
- /// Add layout information for this class. This class must have the
- /// sequential or explicit attribute.
- /// </summary>
- /// <param name="packSize">packing size (.pack)</param>
- /// <param name="classSize">class size (.size)</param>
- public void AddLayoutInfo (int packSize, int classSize) {
- layout = new ClassLayout(packSize,classSize,this);
- }
-
- /// <summary>
- /// Use a method as the implementation for another method (.override)
- /// </summary>
- /// <param name="decl">the method to be overridden</param>
- /// <param name="body">the implementation to be used</param>
- public void AddMethodOverride(Method decl, Method body) {
- metaData.AddToTable(MDTable.MethodImpl,new MethodImpl(this,decl,body));
- }
-
- /// <summary>
- /// Add security to this class NOT YET IMPLEMENTED
- /// </summary>
- /// <param name="permissionSet"></param>
- public void AddSecurity(byte[] permissionSet) {
- throw(new NotYetImplementedException("Class security "));
- //flags |= HasSecurity;
- // securityActions = permissionSet;
- }
-
- //public void AddLineInfo(int row, int col) { }
-
- internal void CheckTypeIndex() {
- if (typeIndexChecked) return;
- if (!(superType is ClassRef))
- ((ClassDef)superType).CheckTypeIndex();
- typeIndex = superType.GetTypeIndex();
- typeIndexChecked = true;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- if ((flags & (uint)TypeAttr.Interface) != 0) { superType = null; }
- // Console.WriteLine("Building tables for " + name);
- if (layout != null) md.AddToTable(MDTable.ClassLayout,layout);
- // Console.WriteLine("adding methods " + methods.Count);
- methodIx = md.TableIndex(MDTable.Method);
- for (int i=0; i < methods.Count; i++) {
- md.AddToTable(MDTable.Method,(MetaDataElement)methods[i]);
- ((MethodDef)methods[i]).BuildTables(md);
- }
- // Console.WriteLine("adding fields");
- fieldIx = md.TableIndex(MDTable.Field);
- for (int i=0; i < fields.Count; i++) {
- md.AddToTable(MDTable.Field,(MetaDataElement)fields[i]);
- ((FieldDef)fields[i]).BuildTables(md);
- }
- // Console.WriteLine("adding events and properties");
- if (events != null) {
- for (int i=0; i < events.Count; i++) {
- md.AddToTable(MDTable.Event,(Event)events[i]);
- ((Event)events[i]).BuildTables(md);
- }
- md.AddToTable(MDTable.EventMap,
- new MapElem(this,((Event)events[0]).Row,MDTable.Event));
- }
- if (properties != null) {
- for (int i=0; i < properties.Count; i++) {
- md.AddToTable(MDTable.Property,(Property)properties[i]);
- ((Property)properties[i]).BuildTables(md);
- }
- md.AddToTable(MDTable.PropertyMap,new MapElem(this,
- ((Property)properties[0]).Row,MDTable.Property));
- }
- // Console.WriteLine("End of building tables");
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 4 + 2 * md.StringsIndexSize() +
- md.CodedIndexSize(CIx.TypeDefOrRef) +
- md.TableIndexSize(MDTable.Field) +
- md.TableIndexSize(MDTable.Method);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.StringsIndex(nameSpaceIx);
- //if (superType != null)
- // Console.WriteLine("getting coded index for superType of " + name + " = " + superType.GetCodedIx(CIx.TypeDefOrRef));
- output.WriteCodedIndex(CIx.TypeDefOrRef,superType);
- output.WriteIndex(MDTable.Field,fieldIx);
- output.WriteIndex(MDTable.Method,methodIx);
- }
-
- internal sealed override uint TypeDefOrRefToken() {
- uint cIx = Row;
- cIx = cIx << 2;
- return cIx;
- }
-
- internal sealed override void TypeSig(MemoryStream sig) {
- if (!typeIndexChecked) CheckTypeIndex();
- sig.WriteByte(GetTypeIndex());
- MetaData.CompressNum(TypeDefOrRefToken(),sig);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.TypeDefOrRef) : return 0;
- case (CIx.HasCustomAttr) : return 3;
- case (CIx.HasDeclSecurity) : return 0;
- case (CIx.TypeOrMethodDef) : return 0;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Layout information for a class (.class [sequential | explicit])
- /// </summary>
- internal class ClassLayout : MetaDataElement
- {
- ClassDef parent;
- ushort packSize = 0;
- uint classSize = 0;
-
- internal ClassLayout(int pack, int cSize, ClassDef par) {
- packSize = (ushort)pack;
- classSize = (uint)cSize;
- parent = par;
- tabIx = MDTable.ClassLayout;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 6 + md.TableIndexSize(MDTable.TypeDef);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(packSize);
- output.Write(classSize);
- output.WriteIndex(MDTable.TypeDef,parent.Row);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a class/interface declared in another module of THIS
- /// assembly, or in another assembly.
- /// </summary>
- public class ClassRef : Class
- {
- protected ResolutionScope parent;
- ExternClass externClass;
- protected MetaData metaData;
-
- internal ClassRef(string nsName, string name, MetaData md) : base(nsName, name, md) {
- metaData = md;
- tabIx = MDTable.TypeRef;
- }
-
- /// <summary>
- /// Add a method to this class
- /// </summary>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameter types</param>
- /// <returns>a descriptor for this method</returns>
- public MethodRef AddMethod(string name, Type retType, Type[] pars) {
- MethodRef meth = new MethodRef(this,name,retType,pars,false,null);
- metaData.AddToTable(MDTable.MemberRef,meth);
- return meth;
- }
-
- /// <summary>
- /// Add a method to this class
- /// </summary>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameter types</param>
- /// <returns>a descriptor for this method</returns>
- public MethodRef AddVarArgMethod(string name, Type retType,
- Type[] pars, Type[] optPars) {
- MethodRef meth = new MethodRef(this,name,retType,pars,true,optPars);
- metaData.AddToTable(MDTable.MemberRef,meth);
- return meth;
- }
-
- /// <summary>
- /// Add a field to this class
- /// </summary>
- /// <param name="name">field name</param>
- /// <param name="fType">field type</param>
- /// <returns>a descriptor for this field</returns>
- public FieldRef AddField(string name, Type fType) {
- FieldRef field = new FieldRef(this,name,fType);
- metaData.AddToTable(MDTable.MemberRef,field);
- return field;
- }
-
- internal void SetParent(ResolutionScope par) {
- parent = par;
- }
-
- internal override string TypeName() {
- if ((parent != null) && (parent is AssemblyRef))
- return (nameSpace + "." + name + ", " + ((AssemblyRef)parent).TypeName());
- else
- return (nameSpace + name);
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.CodedIndexSize(CIx.ResolutionScope) + 2 *
- md.StringsIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteCodedIndex(CIx.ResolutionScope,parent);
- output.StringsIndex(nameIx);
- output.StringsIndex(nameSpaceIx);
- }
-
- internal override sealed uint TypeDefOrRefToken() {
- uint cIx = Row;
- cIx = (cIx << 2) | 0x1;
- return cIx;
- }
-
- internal override void TypeSig(MemoryStream sig) {
- sig.WriteByte(GetTypeIndex());
- MetaData.CompressNum(TypeDefOrRefToken(),sig);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.TypeDefOrRef) : return 1;
- case (CIx.HasCustomAttr) : return 2;
- case (CIx.MemberRefParent) : return 1;
- case (CIx.ResolutionScope) : return 3;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
-
- public class ExternClassRef : ClassRef {
-
- ExternClass externClass;
-
- internal ExternClassRef(TypeAttr attrs, string nsName, string name,
- FileRef declFile, MetaData md) : base(nsName,name,md) {
- externClass = new ExternClass(attrs,nameSpaceIx,nameIx,declFile);
- metaData.AddToTable(MDTable.ExportedType,externClass);
- }
-
- internal ExternClassRef(string name, MetaData md) : base(null,name,md) {
- }
-
- public ClassRef AddNestedClass(TypeAttr attrs, string name) {
- ExternClassRef nestedClass = new ExternClassRef(name,metaData);
- externClass = new ExternClass(attrs,0,nameIx,this.externClass);
- metaData.AddToTable(MDTable.ExportedType,externClass);
- return nestedClass;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a constant value
- /// </summary>
- public abstract class Constant {
- protected uint size = 0;
- protected Type type;
- protected uint blobIndex;
- protected bool addedToBlobHeap = false;
-
- internal Constant() { }
-
- internal virtual uint GetBlobIndex(MetaData md) { return 0; }
-
- internal uint GetSize() { return size; }
-
- internal byte GetTypeIndex() { return type.GetTypeIndex(); }
-
- internal virtual void Write(BinaryWriter bw) { }
-
- }
- /// <summary>
- /// Descriptor for a constant value
- /// </summary>
- public abstract class DataConstant : Constant {
- private uint dataOffset = 0;
-
- internal DataConstant() { }
-
- public uint DataOffset {
- get { return dataOffset; }
- set { dataOffset = value; }
- }
-
- }
-
- /// <summary>
- /// Boolean constant
- /// </summary>
- public class BoolConst : Constant {
- bool val;
-
- /// <summary>
- /// Create a new boolean constant with the value "val"
- /// </summary>
- /// <param name="val">value of this boolean constant</param>
- public BoolConst(bool val) {
- this.val = val;
- size = 1;
- type = PrimitiveType.Boolean;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- if (val) blobIndex = md.AddToBlobHeap((sbyte)1);
- else blobIndex = md.AddToBlobHeap((sbyte)0);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- if (val) bw.Write((sbyte)1);
- else bw.Write((sbyte)0);
- }
-
- }
-
- public class ByteArrConst : DataConstant {
- byte[] val;
-
- public ByteArrConst(byte[] val) {
- type = PrimitiveType.String;
- this.val = val;
- size = (uint)val.Length;
- }
-
- public Type Type {
- get { return type; }
- set { type = value; }
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- blobIndex = md.AddToBlobHeap(val);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write(val);
- }
-
- }
-
- public class CharConst : Constant {
- char val;
-
- public CharConst(char val) {
- this.val = val;
- size = 2;
- type = PrimitiveType.Char;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- blobIndex = md.AddToBlobHeap(val);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write(val);
- }
-
- }
-
- public class FloatConst : DataConstant {
- float val;
-
- public FloatConst(float val) {
- this.val = val;
- size = 4;
- type = PrimitiveType.Float32;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- blobIndex = md.AddToBlobHeap(val);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write(val);
- }
-
- }
-
- public class DoubleConst : DataConstant {
- double val;
-
- public DoubleConst(double val) {
- this.val = val;
- size = 8;
- type = PrimitiveType.Float64;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- blobIndex = md.AddToBlobHeap(val);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write(val);
- }
-
- }
-
- public class IntConst : DataConstant {
- long val;
-
- public IntConst(sbyte val) {
- this.val = val;
- size = 1;
- type = PrimitiveType.Int8;
- }
-
- public IntConst(short val) {
- this.val = val;
- size = 2;
- type = PrimitiveType.Int16;
- }
-
- public IntConst(int val) {
- this.val = val;
- size = 4;
- type = PrimitiveType.Int32;
- }
-
- public IntConst(long val) {
- this.val = val;
- size = 8;
- type = PrimitiveType.Int64;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- switch (size) {
- case (1) : blobIndex = md.AddToBlobHeap((sbyte)val); break;
- case (2) : blobIndex = md.AddToBlobHeap((short)val); break;
- case (4) : blobIndex = md.AddToBlobHeap((int)val); break;
- default : blobIndex = md.AddToBlobHeap(val); break;
- }
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- switch (size) {
- case (1) : bw.Write((sbyte)val); break;
- case (2) : bw.Write((short)val); break;
- case (4) : bw.Write((int)val); break;
- default : bw.Write(val); break;
- }
- }
-
- }
-
- public class UIntConst : Constant {
- long val;
-
- public UIntConst(sbyte val) {
- this.val = val;
- size = 1;
- type = PrimitiveType.UInt8;
- }
- public UIntConst(short val) {
- this.val = val;
- size = 2;
- type = PrimitiveType.UInt16;
- }
- public UIntConst(int val) {
- this.val = val;
- size = 4;
- type = PrimitiveType.UInt32;
- }
- public UIntConst(long val) {
- this.val = val;
- size = 8;
- type = PrimitiveType.UInt64;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- switch (size) {
- case (1) : blobIndex = md.AddToBlobHeap((sbyte)val); break;
- case (2) : blobIndex = md.AddToBlobHeap((short)val); break;
- case (4) : blobIndex = md.AddToBlobHeap((int)val); break;
- default : blobIndex = md.AddToBlobHeap(val); break;
- }
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- switch (size) {
- case (1) : bw.Write((sbyte)val); break;
- case (2) : bw.Write((short)val); break;
- case (4) : bw.Write((int)val); break;
- default : bw.Write(val); break;
- }
- }
-
- }
-
- public class StringConst : DataConstant {
- string val;
-
- public StringConst(string val) {
- this.val = val;
- size = (uint)val.Length; // need to add null ??
- type = PrimitiveType.String;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- byte [] b = Encoding.Unicode.GetBytes (val);
- blobIndex = md.AddToBlobHeap(b);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write(val);
- }
-
- }
-
- public class NullConst : Constant {
-
- public NullConst() {
- size = 4;
- type = PrimitiveType.Class;
- }
-
- internal sealed override uint GetBlobIndex(MetaData md) {
- if (!addedToBlobHeap) {
- blobIndex = md.AddToBlobHeap((int)0);
- addedToBlobHeap = true;
- }
- return blobIndex;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- bw.Write((int)0);
- }
-
- }
-
- public class AddressConstant : DataConstant {
- DataConstant data;
-
- public AddressConstant(DataConstant dConst) {
- data = dConst;
- size = 4;
- type = PrimitiveType.TypedRef;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- ((FileImage)bw).WriteDataRVA(data.DataOffset);
- }
-
- }
-
- public class RepeatedConstant : DataConstant {
- DataConstant data;
- uint repCount;
-
- public RepeatedConstant(DataConstant dConst, int repeatCount) {
- data = dConst;
- repCount = (uint)repeatCount;
- int[] sizes = new int[1];
- sizes[0] = repeatCount;
- type = new BoundArray(type,1,sizes);
- size = data.GetSize() * repCount;
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- for (int i=0; i < repCount; i++) {
- data.Write(bw);
- }
- }
-
- }
-
- public class ArrayConstant : DataConstant {
- DataConstant[] dataVals;
-
- public ArrayConstant(DataConstant[] dVals) {
- dataVals = dVals;
- for (int i=0; i < dataVals.Length; i++) {
- size += dataVals[i].GetSize();
- }
- }
-
- internal sealed override void Write(BinaryWriter bw) {
- for (int i=0; i < dataVals.Length; i++) {
- dataVals[i].Write(bw);
- }
- }
-
- }
-
- public class ClassType : Constant {
- string name;
- Class desc;
-
- public ClassType(string className) {
- name = className;
- type = PrimitiveType.ClassType;
- }
-
- public ClassType(Class classDesc) {
- desc = classDesc;
- type = PrimitiveType.ClassType;
- }
-
- internal override void Write(BinaryWriter bw) {
- if (name == null) name = desc.TypeName();
- bw.Write(name);
- }
-
- }
-
-
-
- /**************************************************************************/
- /// <summary>
- /// Summary description for ConstantElem.
- /// </summary>
- internal class ConstantElem : MetaDataElement
- {
- MetaDataElement parent;
- Constant cValue;
- uint valIx = 0;
-
- internal ConstantElem(MetaDataElement parent, Constant val) {
- this.parent = parent;
- cValue = val;
- tabIx = MDTable.Constant;
- sortTable = true;
- }
-
- internal override uint SortKey()
- {
- return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasConst])
- | parent.GetCodedIx(CIx.HasConst);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- valIx = cValue.GetBlobIndex(md);
- done = true;
- }
-
- internal void AddToBlob(BinaryWriter bw) {
- cValue.Write(bw);
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.CodedIndexSize(CIx.HasConst) + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(cValue.GetTypeIndex());
- output.Write((byte)0);
- output.WriteCodedIndex(CIx.HasConst,parent);
- output.BlobIndex(valIx);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a Custom Attribute (.custom)
- /// </summary>
-
- public class CustomAttribute : MetaDataElement
- {
- private static readonly ushort prolog = 0x0001;
- MetaDataElement parent;
- Method type;
- uint valIx;
- Constant cVal;
- byte[] byteVal;
- ushort numNamed = 0;
- ArrayList names, vals;
-
- internal CustomAttribute(MetaDataElement paren, Method constrType,
- Constant val) {
- parent = paren;
- type = constrType;
- cVal = val;
- tabIx = MDTable.CustomAttribute;
- }
-
- internal CustomAttribute(MetaDataElement paren, Method constrType,
- byte[] val) {
- parent = paren;
- type = constrType;
- tabIx = MDTable.CustomAttribute;
- byteVal = val;
- }
-
- internal override uint SortKey() {
- return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasCustomAttr])
- | parent.GetCodedIx(CIx.HasCustomAttr);
- }
-
- public void AddFieldOrProp(string name, Constant val) {
- if (numNamed == 0) {
- names = new ArrayList();
- vals = new ArrayList();
- }
- names.Add(name);
- vals.Add(val);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- BinaryWriter bw = new BinaryWriter(new MemoryStream());
- bw.Write(byteVal);
- md.AddToTable(MDTable.CustomAttribute, this);
- MemoryStream str = (MemoryStream)bw.BaseStream;
- valIx = md.AddToBlobHeap(str.ToArray());
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.CodedIndexSize(CIx.HasCustomAttr) + md.CodedIndexSize(CIx.CustomAttributeType) + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteCodedIndex(CIx.HasCustomAttr,parent);
- output.WriteCodedIndex(CIx.CustomAttributeType,type);
- output.BlobIndex(valIx);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a custom modifier of a type (modopt or modreq)
- /// </summary>
-
- public class CustomModifiedType : Type
- {
- Type type;
- Class cmodType;
-
- /// <summary>
- /// Create a new custom modifier for a type
- /// </summary>
- /// <param name="type">the type to be modified</param>
- /// <param name="cmod">the modifier</param>
- /// <param name="cmodType">the type reference to be associated with the type</param>
- public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)
- : base((byte)cmod) {
- this.type = type;
- this.cmodType = cmodType;
- }
-
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- MetaData.CompressNum(cmodType.TypeDefOrRefToken(),str);
- type.TypeSig(str);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for security permissions for a class or a method NOT YET IMPLEMENTED
- /// </summary>
-
- public class DeclSecurity : MetaDataElement
- {
- ushort action;
- MetaDataElement parent;
- uint permissionIx;
-
- internal DeclSecurity(MetaDataElement paren, ushort act) {
- parent = paren;
- action = act;
- tabIx = MDTable.DeclSecurity;
- throw(new NotYetImplementedException("Security "));
- }
-
- internal override uint SortKey() {
- return (parent.Row << MetaData.CIxShiftMap[(uint)CIx.HasDeclSecurity])
- | parent.GetCodedIx(CIx.HasDeclSecurity);
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.CodedIndexSize(CIx.HasDeclSecurity) + md.BlobIndexSize();
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
-// add permission to blob heap
- done = true;
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(action);
- output.WriteCodedIndex(CIx.HasDeclSecurity,parent);
- output.BlobIndex(permissionIx);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for an event
- /// </summary>
- public class Event : Feature
- {
- Type eventType;
-
- internal Event(string name, Type eType, ClassDef parent)
- : base(name, parent) {
- eventType = eType;
- tabIx = MDTable.Event;
- }
-
- /// <summary>
- /// Add the addon method to this event
- /// </summary>
- /// <param name="addon">the addon method</param>
- public void AddAddon(MethodDef addon) {
- AddMethod(addon,MethodType.AddOn);
- }
-
- /// <summary>
- /// Add the removeon method to this event
- /// </summary>
- /// <param name="removeOn">the removeon method</param>
- public void AddRemoveOn(MethodDef removeOn) {
- AddMethod(removeOn,MethodType.RemoveOn);
- }
-
- /// <summary>
- /// Add the fire method to this event
- /// </summary>
- /// <param name="fire">the fire method</param>
- public void AddFire(MethodDef fire) {
- AddMethod(fire,MethodType.Fire);
- }
-
- /// <summary>
- /// Add another method to this event
- /// </summary>
- /// <param name="other">the method to be added</param>
- public void AddOther(MethodDef other) {
- AddMethod(other,MethodType.Other);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- for (int i=0; i < tide; i++) {
- md.AddToTable(MDTable.MethodSemantics,methods[i]);
- }
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.StringsIndexSize() + md.CodedIndexSize(CIx.TypeDefOrRef);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.WriteCodedIndex(CIx.TypeDefOrRef,eventType);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 10;
- case (CIx.HasSemantics) : return 0;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a class defined in another module of THIS assembly
- /// and exported (.class extern)
- /// </summary>
-
- internal class ExternClass : Class
- {
- MetaDataElement parent;
- uint flags;
-
- internal ExternClass(TypeAttr attr, uint nsIx, uint nIx,
- MetaDataElement paren) : base(nsIx,nIx) {
- flags = (uint)attr;
- parent = paren;
- tabIx = MDTable.ExportedType;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 8 + 2* md.StringsIndexSize() + md.CodedIndexSize(CIx.Implementation);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.Write(0);
- output.StringsIndex(nameIx);
- output.StringsIndex(nameSpaceIx);
- output.WriteCodedIndex(CIx.Implementation,parent);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 17;
- case (CIx.Implementation) : return 2;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for Event and Property descriptors
- /// </summary>
-
- public class Feature : MetaDataElement
- {
- internal enum MethodType : ushort { Setter = 0x01, Getter, Other = 0x04, AddOn = 0x08,
- RemoveOn = 0x10, Fire = 0x20 }
-
- private static readonly int INITSIZE = 5;
- private static readonly ushort specialName = 0x200;
- private static readonly ushort rtSpecialName = 0x400;
-
- protected ClassDef parent;
- protected ushort flags = 0;
- protected string name;
- protected int tide = 0;
- protected uint nameIx;
- protected MethodSemantics[] methods = new MethodSemantics[INITSIZE];
-
- internal Feature(string name, ClassDef par) {
- parent = par;
- this.name = name;
- }
-
- internal void AddMethod(MethodDef meth, MethodType mType) {
- if (tide >= methods.Length) {
- int len = methods.Length;
- MethodSemantics[] mTmp = methods;
- methods = new MethodSemantics[len * 2];
- for (int i=0; i < len; i++) {
- methods[i] = mTmp[i];
- }
- }
- methods[tide++] = new MethodSemantics(mType,meth,this);
- }
-
- /// <summary>
- /// Set the specialName attribute for this Event or Property
- /// </summary>
- public void SetSpecialName() {
- flags |= specialName;
- }
-
- /// <summary>
- /// Set the RTSpecialName attribute for this Event or Property
- /// </summary>
- public void SetRTSpecialName() {
- flags |= rtSpecialName;
- }
-
- }
- /*****************************************************************************/
- /// <summary>
- /// Descriptor for a field of a class
- /// </summary>
-
- public abstract class Field : Member
- {
- protected static readonly byte FieldSig = 0x6;
-
- protected Type type;
-
- internal Field(string pfName, Type pfType) : base(pfName)
- {
- type = pfType;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a field defined in a class of THIS assembly/module
- /// </summary>
- public class FieldDef : Field
- {
- //private static readonly uint PInvokeImpl = 0x2000;
- private static readonly ushort HasFieldMarshal = 0x1000;
- private static readonly ushort HasFieldRVA = 0x100;
- private static readonly ushort HasDefault = 0x8000;
-
- FieldRVA rva;
- ConstantElem constVal;
- FieldLayout layout;
- FieldMarshal marshalInfo;
- ushort flags;
-
- internal FieldDef(string name, Type fType) : base(name,fType) {
- tabIx = MDTable.Field;
- }
-
- internal FieldDef(FieldAttr attrSet, string name, Type fType) : base(name, fType) {
- flags = (ushort)attrSet;
- tabIx = MDTable.Field;
- }
-
- /// <summary>
- /// Add an attribute(s) to this field
- /// </summary>
- /// <param name="fa">the attribute(s) to be added</param>
- public void AddFieldAttr(FieldAttr fa) {
- flags |= (ushort)fa;
- }
-
- /// <summary>
- /// Add a value for this field
- /// </summary>
- /// <param name="val">the value for the field</param>
- public void AddValue(Constant val) {
- constVal = new ConstantElem(this,val);
- flags |= HasDefault;
- }
-
- /// <summary>
- /// Add an initial value for this field (at dataLabel) (.data)
- /// </summary>
- /// <param name="val">the value for the field</param>
- /// <param name="repeatVal">the number of repetitions of this value</param>
- public void AddDataValue(DataConstant val) {
- flags |= HasFieldRVA;
- rva = new FieldRVA(this,val);
- }
-
- /// <summary>
- /// Set the offset of the field. Used for sequential or explicit classes.
- /// (.field [offs])
- /// </summary>
- /// <param name="offs">field offset</param>
- public void SetOffset(uint offs) {
- layout = new FieldLayout(this,offs);
- }
-
- /// <summary>
- /// Set the marshalling info for a field
- /// </summary>
- /// <param name="mInf"></param>
- public void SetMarshalInfo(NativeType marshallType) {
- flags |= HasFieldMarshal;
- marshalInfo = new FieldMarshal(this,marshallType);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- MemoryStream sig = new MemoryStream();
- sig.WriteByte(FieldSig);
- type.TypeSig(sig);
- sigIx = md.AddToBlobHeap(sig.ToArray());
- if (rva != null) {
- md.AddToTable(MDTable.FieldRVA,rva);
- rva.BuildTables(md);
- } else if (constVal != null) {
- md.AddToTable(MDTable.Constant,constVal);
- constVal.BuildTables(md);
- }
- if (layout != null) md.AddToTable(MDTable.FieldLayout,layout);
- if (marshalInfo != null) {
- md.AddToTable(MDTable.FieldMarshal,marshalInfo);
- marshalInfo.BuildTables(md);
- }
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.StringsIndexSize() + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.BlobIndex(sigIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasConst) : return 0;
- case (CIx.HasCustomAttr) : return 1;
- case (CIx.HasFieldMarshal) : return 0;
- case (CIx.MemberForwarded) : return 0;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for layout information for a field
- /// </summary>
-
- public class FieldLayout : MetaDataElement
- {
- Field field;
- uint offset;
-
- internal FieldLayout(Field field, uint offset) {
- this.field = field;
- this.offset = offset;
- tabIx = MDTable.FieldLayout;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 4 + md.TableIndexSize(MDTable.Field);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(offset);
- output.WriteIndex(MDTable.Field,field.Row);
- }
-
- }
- /*****************************************************************************/
- /// <summary>
- /// Marshalling information for a field or param
- /// </summary>
- public class FieldMarshal : MetaDataElement
- {
- MetaDataElement field;
- NativeType nt;
- uint ntIx;
-
- internal FieldMarshal(MetaDataElement field, NativeType nType) {
- this.field = field;
- this.nt = nType;
- tabIx = MDTable.FieldMarshal;
- }
-
- internal override uint SortKey() {
- return (field.Row << MetaData.CIxShiftMap[(uint)CIx.HasFieldMarshal])
- | field.GetCodedIx(CIx.HasFieldMarshal);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- ntIx = md.AddToBlobHeap(nt.ToBlob());
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.CodedIndexSize(CIx.HasFieldMarshal) + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteCodedIndex(CIx.HasFieldMarshal,field);
- output.BlobIndex(ntIx);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a field of a class defined in another assembly/module
- /// </summary>
- public class FieldRef : Field
- {
- MetaDataElement parent;
-
- internal FieldRef(MetaDataElement paren, string name, Type fType) : base(name, fType) {
- parent = paren;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- MemoryStream sig = new MemoryStream();
- sig.WriteByte(FieldSig);
- type.TypeSig(sig);
- sigIx = md.AddToBlobHeap(sig.ToArray());
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.CodedIndexSize(CIx.MemberRefParent) + md.StringsIndexSize() + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteCodedIndex(CIx.MemberRefParent,parent);
- output.StringsIndex(nameIx);
- output.BlobIndex(sigIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) { return 6; }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for the address of a field's value in the PE file
- /// </summary>
- public class FieldRVA : MetaDataElement
- {
- Field field;
- DataConstant data;
-
- internal FieldRVA(Field field, DataConstant data) {
- this.field = field;
- this.data = data;
- tabIx = MDTable.FieldRVA;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- md.AddData(data);
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 4 + md.TableIndexSize(MDTable.Field);
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteDataRVA(data.DataOffset);
- output.WriteIndex(MDTable.Field,field.Row);
- }
-
- }
- /**************************************************************************/
- /// <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 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) {
- if (tide < SectionAlignment) return rva + SectionAlignment;
- return rva + ((tide / SectionAlignment) + 1) * 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)0x100000); // 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>
- /// Descriptor for a file referenced in THIS assembly/module (.file)
- /// </summary>
- public class FileRef : MetaDataElement
- {
- private static readonly uint NoMetaData = 0x1;
- uint nameIx = 0, hashIx = 0;
- uint flags = 0;
- protected string name;
-
- internal FileRef(string name, byte[] hashBytes, bool metaData,
- bool entryPoint, MetaData md) {
- if (!metaData) flags = NoMetaData;
- if (entryPoint) md.SetEntryPoint(this);
- this.name = name;
- nameIx = md.AddToStringsHeap(name);
- hashIx = md.AddToBlobHeap(hashBytes);
- tabIx = MDTable.File;
- }
-
- internal FileRef(uint nameIx, byte[] hashBytes, bool metaData,
- bool entryPoint, MetaData md) {
- if (!metaData) flags = NoMetaData;
- if (entryPoint) md.SetEntryPoint(this);
- this.nameIx = nameIx;
- hashIx = md.AddToBlobHeap(hashBytes);
- tabIx = MDTable.File;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 4 + md.StringsIndexSize() + md.BlobIndexSize();
- }
-
- internal sealed override void BuildTables(MetaData md) {
- md.AddToTable(MDTable.File,this);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.BlobIndex(hashIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 16;
- case (CIx.Implementation) : return 0;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for pinvoke information for a method NOT YET IMPLEMENTED
- /// </summary>
- public class ImplMap : MetaDataElement
- {
- private static readonly ushort NoMangle = 0x01;
- ushort flags;
- Method meth;
- string importName;
- uint iNameIx;
- ModuleRef importScope;
-
- internal ImplMap(ushort flag, Method implMeth, string iName, ModuleRef mScope) {
- flags = flag;
- meth = implMeth;
- importName = iName;
- importScope = mScope;
- tabIx = MDTable.ImplMap;
- if (iName == null) flags |= NoMangle;
- //throw(new NotYetImplementedException("PInvoke "));
- }
-
- internal override uint SortKey() {
- return (meth.Row << MetaData.CIxShiftMap[(uint)CIx.MemberForwarded])
- | meth.GetCodedIx(CIx.MemberForwarded);
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- iNameIx = md.AddToStringsHeap(importName);
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2+ md.CodedIndexSize(CIx.MemberForwarded) +
- md.StringsIndexSize() + md.TableIndexSize(MDTable.ModuleRef);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.WriteCodedIndex(CIx.MemberForwarded,meth);
- output.StringsIndex(iNameIx);
- output.WriteIndex(MDTable.ModuleRef,importScope.Row);
- }
-
- }
-
- /**************************************************************************/
- /// <summary>
- /// Descriptor for an IL instruction
- /// </summary>
- internal abstract class CILInstruction {
- protected static readonly sbyte maxByteVal = 127;
- protected static readonly sbyte minByteVal = -128;
- protected static readonly byte leadByte = 0xFE;
- protected static readonly uint USHeapIndex = 0x70000000;
- protected static readonly int longInstrStart = (int)Op.arglist;
- public bool twoByteInstr = false;
- public uint size = 0;
- public uint offset;
-
- internal virtual bool Check(MetaData md) {
- return false;
- }
-
- internal virtual void Write(FileImage output) { }
-
- }
-
- internal class CILByte : CILInstruction {
- byte byteVal;
-
- internal CILByte(byte bVal) {
- byteVal = bVal;
- size = 1;
- }
-
- internal override void Write(FileImage output) {
- output.Write(byteVal);
- }
-
- }
-
-
- internal class Instr : CILInstruction {
- protected int instr;
-
- internal Instr(int inst) {
- if (inst >= longInstrStart) {
- instr = inst - longInstrStart;
- twoByteInstr = true;
- size = 2;
- } else {
- instr = inst;
- size = 1;
- }
- }
-
- internal override void Write(FileImage output) {
- //Console.WriteLine("Writing instruction " + instr + " with size " + size);
- if (twoByteInstr) output.Write(leadByte);
- output.Write((byte)instr);
- }
-
- }
-
- internal class IntInstr : Instr {
- int val;
- bool byteNum;
-
- internal IntInstr(int inst, int num, bool byteSize) : base(inst) {
- val = num;
- byteNum = byteSize;
- if (byteNum) size++;
- else size += 4;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- if (byteNum)
- output.Write((sbyte)val);
- else
- output.Write(val);
- }
-
- }
-
- internal class UIntInstr : Instr {
- int val;
- bool byteNum;
-
- internal UIntInstr(int inst, int num, bool byteSize) : base(inst) {
- val = num;
- byteNum = byteSize;
- if (byteNum) size++;
- else size += 2;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- if (byteNum)
- output.Write((byte)val);
- else
- output.Write((ushort)val);
- }
-
- }
-
- internal class LongInstr : Instr {
- long val;
-
- internal LongInstr(int inst, long l) : base(inst) {
- val = l;
- size += 8;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(val);
- }
-
- }
-
- internal class FloatInstr : Instr {
- float fVal;
-
- internal FloatInstr(int inst, float f) : base(inst) {
- fVal = f;
- size += 4;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(fVal);
- }
-
- }
-
- internal class DoubleInstr : Instr {
- double val;
-
- internal DoubleInstr(int inst, double d) : base(inst) {
- val = d;
- size += 8;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(val);
- }
-
- }
-
- internal class StringInstr : Instr {
- string val;
- byte[] bval;
- uint strIndex;
-
- internal StringInstr(int inst, string str) : base(inst) {
- val = str;
- size += 4;
- }
-
- internal StringInstr (int inst, byte[] str) : base (inst) {
- bval = str;
- size += 4;
- }
-
- internal sealed override bool Check(MetaData md) {
- if (val != null)
- strIndex = md.AddToUSHeap(val);
- else
- strIndex = md.AddToUSHeap (bval);
- return false;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(USHeapIndex | strIndex);
- }
-
- }
-
- internal class LabelInstr : CILInstruction {
- CILLabel label;
-
- internal LabelInstr(CILLabel lab) {
- label = lab;
- label.AddLabelInstr(this);
- }
- }
-
- internal class FieldInstr : Instr {
- Field field;
-
- internal FieldInstr(int inst, Field f) : base(inst) {
- field = f;
- size += 4;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(field.Token());
- }
-
- }
-
- internal class MethInstr : Instr {
- Method meth;
-
- internal MethInstr(int inst, Method m) : base(inst) {
- meth = m;
- size += 4;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(meth.Token());
- }
-
- }
-
- internal class SigInstr : Instr {
- CalliSig signature;
-
- internal SigInstr(int inst, CalliSig sig) : base(inst) {
- signature = sig;
- size += 4;
- }
-
- internal sealed override bool Check(MetaData md) {
- md.AddToTable(MDTable.StandAloneSig,signature);
- signature.BuildTables(md);
- return false;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(signature.Token());
- }
- }
-
- internal class TypeInstr : Instr {
- MetaDataElement theType;
-
- internal TypeInstr(int inst, Type aType, MetaData md) : base(inst) {
- theType = aType.GetTypeSpec(md);
- size += 4;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(theType.Token());
- }
-
- }
-
- internal class BranchInstr : Instr {
- CILLabel dest;
- private bool shortVer = true;
- private static readonly byte longInstrOffset = 13;
- private int target = 0;
-
- internal BranchInstr(int inst, CILLabel dst) : base(inst) {
- dest = dst;
- dest.AddBranch(this);
- size++;
-
- if (inst >= (int) BranchOp.br && inst != (int) BranchOp.leave_s) {
- shortVer = false;
- size += 3;
- }
- }
-
- internal sealed override bool Check(MetaData md) {
- target = (int)dest.GetLabelOffset() - (int)(offset + size);
- return false;
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- if (shortVer)
- output.Write((sbyte)target);
- else
- output.Write(target);
- }
-
- }
-
- internal class SwitchInstr : Instr {
- CILLabel[] cases;
- uint numCases = 0;
-
- internal SwitchInstr(int inst, CILLabel[] dsts) : base(inst) {
- cases = dsts;
- if (cases != null) numCases = (uint)cases.Length;
- size += 4 + (numCases * 4);
- for (int i=0; i < numCases; i++) {
- cases[i].AddBranch(this);
- }
- }
-
- internal sealed override void Write(FileImage output) {
- base.Write(output);
- output.Write(numCases);
- for (int i=0; i < numCases; i++) {
- int target = (int)cases[i].GetLabelOffset() - (int)(offset + size);
- output.Write(target);
- }
- }
-
- }
- /**************************************************************************/
-
- public class GenericParameter : MetaDataElement
- {
- MetaDataElement owner;
- MetaData metadata;
- string name;
- uint nameIx;
- short index;
-
- internal GenericParameter (ClassDef owner, MetaData metadata,
- short index, string name) : this (owner, metadata, index, name, true)
- {
- }
-
- internal GenericParameter (MethodDef owner, MetaData metadata,
- short index, string name) : this (owner, metadata, index, name, true)
- {
- }
-
- private GenericParameter (MetaDataElement owner, MetaData metadata,
- short index, string name, bool nadda)
- {
- this.owner = owner;
- this.metadata = metadata;
- this.index = index;
- tabIx = MDTable.GenericParam;
- this.name = name;
- }
-
- internal override uint SortKey() {
- return (owner.Row << MetaData.CIxShiftMap[(uint)CIx.TypeOrMethodDef])
- | owner.GetCodedIx(CIx.TypeOrMethodDef);
- }
-
- public void AddConstraint (Type constraint) {
- metadata.AddToTable (MDTable.GenericParamConstraint,
- new GenericParamConstraint (this, constraint));
- }
-
- internal sealed override uint Size(MetaData md) {
- return (uint) (4 +
- md.CodedIndexSize(CIx.TypeOrMethodDef) +
- 4 +
- md.TableIndexSize(MDTable.TypeDef));
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- done = true;
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write ((short) index);
- output.Write ((short) 0);
- output.WriteCodedIndex(CIx.TypeOrMethodDef, owner);
- output.Write ((uint) nameIx);
- output.WriteIndex(MDTable.TypeDef,owner.Row);
- }
-
-
- }
-
- internal class GenericParamConstraint : MetaDataElement
- {
- GenericParameter param;
- Type type;
-
- public GenericParamConstraint (GenericParameter param, Type type) {
- this.param = param;
- this.type = type;
- tabIx = MDTable.GenericParamConstraint;
- }
-
- internal sealed override uint Size(MetaData md) {
- return (uint) (md.TableIndexSize(MDTable.GenericParam) +
- md.CodedIndexSize(CIx.TypeDefOrRef));
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteIndex(MDTable.GenericParam, param.Row);
- output.WriteCodedIndex(CIx.TypeDefOrRef, type);
- }
-
-
- }
-
- internal class MethodSpec : MetaDataElement
- {
- Method meth;
- GenericMethodSig g_sig;
- uint sidx;
-
- internal MethodSpec (Method meth, GenericMethodSig g_sig) {
- this.meth = meth;
- this.g_sig = g_sig;
- tabIx = MDTable.MethodSpec;
- }
-
- internal sealed override void BuildTables (MetaData md) {
- if (done) return;
- sidx = g_sig.GetSigIx (md);
- done = true;
- }
-
- internal sealed override uint Size (MetaData md) {
- return (uint) (md.CodedIndexSize(CIx.MethodDefOrRef) +
- md.BlobIndexSize ());
- }
-
- internal sealed override void Write (FileImage output) {
- output.WriteCodedIndex (CIx.MethodDefOrRef, meth);
- output.BlobIndex (sidx);
- }
- }
-
- /**************************************************************************/
- /// <summary>
- /// Descriptor for interface implemented by a class
- /// </summary>
- public class InterfaceImpl: MetaDataElement
- {
- ClassDef theClass;
- Class theInterface;
-
- internal InterfaceImpl(ClassDef theClass, Class theInterface) {
- this.theClass = theClass;
- this.theInterface = theInterface;
- tabIx = MDTable.InterfaceImpl;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.TableIndexSize(MDTable.TypeDef) +
- md.CodedIndexSize(CIx.TypeDefOrRef);
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteIndex(MDTable.TypeDef,theClass.Row);
- output.WriteCodedIndex(CIx.TypeDefOrRef,theInterface);
- }
-
- internal sealed override uint GetCodedIx(CIx code) { return 5; }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a local of a method
- /// </summary>
- public class Local
- {
- private static readonly byte Pinned = 0x45;
- string name;
- Type type;
- bool pinned = false, byref = false;
-
- /// <summary>
- /// Create a new local variable
- /// </summary>
- /// <param name="lName">name of the local variable</param>
- /// <param name="lType">type of the local variable</param>
- public Local(string lName, Type lType) {
- name = lName;
- type = lType;
- }
-
- /// <summary>
- /// Create a new local variable that is byref and/or pinned
- /// </summary>
- /// <param name="lName">local name</param>
- /// <param name="lType">local type</param>
- /// <param name="byRef">is byref</param>
- /// <param name="isPinned">has pinned attribute</param>
- public Local(string lName, Type lType, bool byRef, bool isPinned)
- {
- name = lName;
- type = lType;
- byref = byRef;
- pinned = isPinned;
- }
-
- internal void TypeSig(MemoryStream str) {
- if (pinned) str.WriteByte(Pinned);
- type.TypeSig(str);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for the locals for a method
- /// </summary>
-
- public class LocalSig : Signature
- {
- private static readonly byte LocalSigByte = 0x7;
- Local[] locals;
-
- public LocalSig(Local[] locals) {
- this.locals = locals;
- tabIx = MDTable.StandAloneSig;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- MemoryStream sig = new MemoryStream();
- sig.WriteByte(LocalSigByte);
- MetaData.CompressNum((uint)locals.Length,sig);
- for (int i=0; i < locals.Length; i++) {
- ((Local)locals[i]).TypeSig(sig);
- }
- sigIx = md.AddToBlobHeap(sig.ToArray());
- done = true;
- }
-
- }
-
- /**************************************************************************/
- /// <summary>
- /// Descriptor for resources used in this PE file
- /// </summary>
-
- public class ManifestResource : MetaDataElement
- {
- public static readonly uint PublicResource = 0x1;
- public static readonly uint PrivateResource = 0x2;
-
- string mrName;
- MetaDataElement rRef;
- uint fileOffset;
- uint nameIx = 0;
- uint flags = 0;
- byte [] resourceBytes;
-
- public ManifestResource (string name, byte[] resBytes, uint flags) {
- InitResource (name, flags);
- this.resourceBytes = resBytes;
- }
-
- public ManifestResource(string name, uint flags, FileRef fileRef) {
- InitResource (name, flags);
- rRef = fileRef;
- }
-
- public ManifestResource(string name, uint flags, FileRef fileRef,
- uint fileIx) {
- InitResource (name, flags);
- rRef = fileRef;
- fileOffset = fileIx;
- }
-
- public ManifestResource(string name, uint flags, AssemblyRef assemRef) {
- InitResource (name, flags);
- rRef = assemRef;
- }
-
- internal ManifestResource (ManifestResource mres) {
- mrName = mres.mrName;
- flags = mres.flags;
- this.rRef = rRef;
- this.fileOffset = fileOffset;
- this.resourceBytes = resourceBytes;
- }
-
- private void InitResource (string name, uint flags) {
- mrName = name;
- this.flags = flags;
- tabIx = MDTable.ManifestResource;
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- md.AddToTable (MDTable.ManifestResource, this);
- nameIx = md.AddToStringsHeap(mrName);
- if (resourceBytes != null) {
- if (rRef != null)
- throw new Exception("ERROR: Manifest Resource has byte value and file reference");
- fileOffset = md.AddResource(resourceBytes);
- } else {
- if (rRef == null)
- throw new Exception("ERROR: Manifest Resource has no implementation or value");
- rRef.BuildTables (md);
- }
-
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 8 + md.StringsIndexSize() +
- md.CodedIndexSize(CIx.Implementation);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(fileOffset);
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.WriteCodedIndex(CIx.Implementation,rRef);
- }
-
- internal sealed override uint GetCodedIx(CIx code) { return 18; }
-
- public string Name {
- get { return mrName; }
- set { mrName = value; }
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for elements in the PropertyMap, EventMap and
- /// NestedClass MetaData tables
- /// </summary>
- public class MapElem : MetaDataElement
- {
- ClassDef parent;
- uint elemIx;
- MDTable elemTable;
-
- internal MapElem(ClassDef par, uint elIx, MDTable elemTab) {
- parent = par;
- elemIx = elIx;
- elemTable = elemTab;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.TableIndexSize(MDTable.TypeDef) + md.TableIndexSize(elemTable);
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteIndex(MDTable.TypeDef,parent.Row);
- output.WriteIndex(elemTable,elemIx);
- }
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for field/methods (member of a class)
- /// </summary>
- public abstract class Member : MetaDataElement
- {
- protected string name;
- protected uint nameIx = 0, sigIx = 0;
-
- internal Member(string memName)
- {
- name = memName;
- tabIx = MDTable.MemberRef;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// 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)
- /// </summary>
-
- public class MetaData
- {
- internal static readonly int[] CIxShiftMap = {2,2,5,1,2,3,1,1,1,2,3,2,1};
- private static readonly byte StringsHeapMask = 0x1;
- private static readonly byte GUIDHeapMask = 0x2;
- private static readonly byte BlobHeapMask = 0x4;
- private static readonly uint MetaDataSignature = 0x424A5342;
- private static readonly uint maxSmlIxSize = 0xFFFF;
- private static readonly uint max1BitSmlIx = 0x7FFF;
- private static readonly uint max2BitSmlIx = 0x3FFF;
- private static readonly uint max3BitSmlIx = 0x1FFF;
- private static readonly uint max5BitSmlIx = 0x7FF;
- // NOTE: version and stream name strings MUST always be quad padded
- private static readonly string version = "v1.0.3705\0\0\0";
- private static readonly char[] tildeName = {'#','~','\0','\0'};
- private static readonly char[] stringsName = {'#','S','t','r','i','n','g','s','\0','\0','\0','\0'};
- private static readonly char[] usName = {'#','U','S','\0'};
- private static readonly char[] guidName = {'#','G','U','I','D','\0','\0','\0'};
- private static readonly char[] blobName = {'#','B','l','o','b','\0','\0','\0'};
- private static readonly uint MetaDataHeaderSize = 20 + (uint)version.Length;
- private static readonly uint TildeHeaderSize = 24;
- private static readonly uint StreamHeaderSize = 8;
- private static readonly uint numMetaDataTables = (int)MDTable.GenericParamConstraint + 1;
- private static readonly uint tildeHeaderSize = 8 + (uint)tildeName.Length;
-
- MetaDataStream strings, us, guid, blob;
-
- MetaDataStream[] streams = new MetaDataStream[5];
- uint numStreams = 5;
- uint tildeTide = 0, tildePadding = 0, tildeStart = 0;
- uint numTables = 0, resourcesSize = 0;
- ArrayList[] metaDataTables = new ArrayList[numMetaDataTables];
- ArrayList byteCodes = new ArrayList();
- uint codeSize = 0, codeStart, byteCodePadding = 0, metaDataSize = 0;
- ulong valid = 0, /*sorted = 0x000002003301FA00;*/ sorted = 0;
- bool[] largeIx = new bool[numMetaDataTables];
- bool[] lgeCIx = new bool[(int)CIx.MaxCIx];
- bool largeStrings = false, largeUS = false, largeGUID = false, largeBlob = false;
- private FileImage file;
- private byte heapSizes = 0;
- MetaDataElement entryPoint;
- BinaryWriter output;
- public MSCorLib mscorlib;
- private TypeSpec[] systemTypeSpecs = new TypeSpec[PrimitiveType.NumSystemTypes];
- long mdStart;
- private ArrayList cattr_list;
- ArrayList resources;
-
- internal MetaData(FileImage file) {
- // tilde = new MetaDataStream(tildeName,false,0);
- this.file = file;
- strings = new MetaDataStream(stringsName,new UTF8Encoding(),true);
- us = new MetaDataStream(usName,new UnicodeEncoding(),true);
- guid = new MetaDataStream(guidName,false);
- blob = new MetaDataStream(blobName,true);
- streams[1] = strings;
- streams[2] = us;
- streams[3] = guid;
- streams[4] = blob;
- for (int i=0; i < numMetaDataTables; i++) {
- largeIx[i] = false;
- }
- for (int i=0; i < lgeCIx.Length; i++) {
- lgeCIx[i] = false;
- }
- mscorlib = new MSCorLib(this);
- }
-
- internal TypeSpec GetPrimitiveTypeSpec(int ix) {
- return systemTypeSpecs[ix];
- }
-
- internal void SetPrimitiveTypeSpec(int ix, TypeSpec typeSpec) {
- systemTypeSpecs[ix] = typeSpec;
- }
-
- internal uint Size() {
- return metaDataSize;
- }
-
-
- private void CalcHeapSizes ()
- {
- if (strings.LargeIx()) {
- largeStrings = true;
- heapSizes |= StringsHeapMask;
- }
- if (guid.LargeIx()) {
- largeGUID = true;
- heapSizes |= GUIDHeapMask;
- }
- if (blob.LargeIx()) {
- largeBlob = true;
- heapSizes |= BlobHeapMask;
- }
-
- largeUS = us.LargeIx();
- }
-
- internal void StreamSize(byte mask) {
- heapSizes |= mask;
- }
-
- internal uint AddToUSHeap(string str) {
- if (str == null) return 0;
- return us.Add(str,true);
- }
-
- internal uint AddToUSHeap(byte[] str) {
- if (str == null) return 0;
- return us.Add (str, true);
- }
-
- internal uint AddToStringsHeap(string str) {
- if ((str == null) || (str.CompareTo("") == 0)) return 0;
- return strings.Add(str,false);
- }
-
- internal uint AddToGUIDHeap(Guid guidNum) {
- return guid.Add(guidNum, false);
- }
-
- internal uint AddToBlobHeap(byte[] blobBytes) {
- if (blobBytes == null) return 0;
- return blob.Add(blobBytes, true);
- }
-
- internal uint AddToBlobHeap(byte val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(sbyte val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(ushort val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(short val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(uint val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(int val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(ulong val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(long val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(float val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(double val) {
- return blob.Add(val, true);
- }
-
- internal uint AddToBlobHeap(string val) {
- return blob.Add(val,true);
- }
-
- internal void AddCustomAttribute (CustomAttribute cattr)
- {
- if (cattr_list == null)
- cattr_list = new ArrayList ();
- cattr_list.Add (cattr);
- }
-
- private ArrayList GetTable(MDTable tableIx) {
- int tabIx = (int)tableIx;
- if (metaDataTables[tabIx] == null) {
- metaDataTables[tabIx] = new ArrayList();
- valid |= ((ulong)0x1 << tabIx);
- // Console.WriteLine("after creating table " + tableIx + "(" + tabIx + ") valid = " + valid);
- numTables++;
- }
- return metaDataTables[tabIx];
- }
-
- internal void AddToTable(MDTable tableIx, MetaDataElement elem) {
- if (elem.Row > 0) {
- // Console.Out.WriteLine("ERROR - element already in table " + tableIx);
- return;
- }
- // updates Row field of the element
- // Console.WriteLine("Adding element to table " + (uint)tableIx);
- ArrayList table = GetTable(tableIx);
- elem.Row = (uint)table.Count + 1;
- table.Add(elem);
- }
-
- internal uint TableIndex(MDTable tableIx) {
- if (metaDataTables[(int)tableIx] == null) return 1;
- return (uint)metaDataTables[(int)tableIx].Count+1;
- }
-
- internal uint AddCode(CILInstructions byteCode) {
- byteCodes.Add(byteCode);
- uint offset = codeSize + codeStart;
- codeSize += byteCode.GetCodeSize();
- return offset;
- }
-
- internal void SetEntryPoint(MetaDataElement ep) {
- entryPoint = ep;
- }
-
- internal uint AddResource(byte[] resBytes) {
- if (resources == null) resources = new ArrayList ();
- resources.Add (resBytes);
- uint offset = resourcesSize;
- resourcesSize += (uint)resBytes.Length + 4;
- return offset;
- }
-
- internal void AddData(DataConstant cVal) {
- file.AddInitData(cVal);
- }
-
- internal static void CompressNum(uint val, MemoryStream sig) {
- if (val < 0x7F) {
- sig.WriteByte((byte)val);
- } else if (val < 0x3FFF) {
- byte b1 = (byte)((val >> 8) | 0x80);
- byte b2 = (byte)(val & FileImage.iByteMask[0]);
- sig.WriteByte(b1);
- sig.WriteByte(b2);
- } else {
- byte b1 = (byte)((val >> 24) | 0xC0);
- byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);
- byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
- byte b4 = (byte)(val & FileImage.iByteMask[0]);
- sig.WriteByte(b1);
- sig.WriteByte(b2);
- sig.WriteByte(b3);
- sig.WriteByte(b4);
- }
- }
-
- internal uint CodeSize() {
- return codeSize + byteCodePadding;
- }
-
- internal uint GetResourcesSize()
- {
- return resourcesSize;
- }
-
- internal uint StringsIndexSize() {
- if (largeStrings) return 4;
- return 2;
- }
-
- internal uint GUIDIndexSize() {
- if (largeGUID) return 4;
- return 2;
- }
-
- internal uint USIndexSize() {
- if (largeUS) return 4;
- return 2;
- }
-
- internal uint BlobIndexSize() {
- if (largeBlob) return 4;
- return 2;
- }
-
- internal uint CodedIndexSize(CIx code) {
- if (lgeCIx[(uint)code]) return 4;
- return 2;
- }
-
- internal uint TableIndexSize(MDTable tabIx) {
- if (largeIx[(uint)tabIx]) return 4;
- return 2;
- }
-
- private void SetIndexSizes() {
- for (int i=0; i < numMetaDataTables; i++) {
- if (metaDataTables[i] == null)
- continue;
-
- uint count = (uint)metaDataTables[i].Count;
- if (count > maxSmlIxSize)
- largeIx[i] = true;
-
- MDTable tabIx = (MDTable)i;
- if (count > max5BitSmlIx) {
- lgeCIx[(int)CIx.HasCustomAttr] = true;
- }
- if (count > max3BitSmlIx) {
- if ((tabIx == MDTable.TypeRef) || (tabIx == MDTable.ModuleRef) || (tabIx == MDTable.Method) || (tabIx == MDTable.TypeSpec) || (tabIx == MDTable.Field))
- lgeCIx[(int)CIx.CustomAttributeType] = true;
- if ((tabIx == MDTable.Method) || (tabIx == MDTable.MemberRef))
- lgeCIx[(int)CIx.MemberRefParent] = true;
- }
- if (count > max2BitSmlIx) {
- if ((tabIx == MDTable.Field) || (tabIx == MDTable.Param) || (tabIx == MDTable.Property))
- lgeCIx[(int)CIx.HasConst] = true;
- if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.TypeRef) || (tabIx == MDTable.TypeSpec))
- lgeCIx[(int)CIx.TypeDefOrRef] = true;
- if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.Method) || (tabIx == MDTable.Assembly))
- lgeCIx[(int)CIx.HasDeclSecurity] = true;
- if ((tabIx == MDTable.File) || (tabIx == MDTable.AssemblyRef) || (tabIx == MDTable.ExportedType))
- lgeCIx[(int)CIx.Implementation] = true;
- if ((tabIx == MDTable.Module) || (tabIx == MDTable.ModuleRef) || (tabIx == MDTable.AssemblyRef) || (tabIx == MDTable.TypeRef))
- lgeCIx[(int)CIx.ResolutionScope] = true;
- }
- if (count > max1BitSmlIx) {
- if ((tabIx == MDTable.Field) || (tabIx == MDTable.Param))
- lgeCIx[(int)CIx.HasFieldMarshal] = true;
- if ((tabIx == MDTable.Event) || (tabIx == MDTable.Property))
- lgeCIx[(int)CIx.HasSemantics] = true;
- if ((tabIx == MDTable.Method) || (tabIx == MDTable.MemberRef))
- lgeCIx[(int)CIx.MethodDefOrRef] = true;
- if ((tabIx == MDTable.Field) || (tabIx == MDTable.Method))
- lgeCIx[(int)CIx.MemberForwarded] = true;
- if ((tabIx == MDTable.TypeDef) || (tabIx == MDTable.Method))
- lgeCIx[(int)CIx.TypeOrMethodDef] = true;
- }
- }
- }
-
- private void SetStreamOffsets() {
- uint sizeOfHeaders = StreamHeaderSize + (uint)tildeName.Length;
- for (int i=1; i < numStreams; i++) {
- sizeOfHeaders += streams[i].headerSize();
- }
- metaDataSize = MetaDataHeaderSize + sizeOfHeaders;
- tildeStart = metaDataSize;
- metaDataSize += tildeTide + tildePadding;
- for (int i=1; i < numStreams; i++) {
- streams[i].Start = metaDataSize;
- metaDataSize += streams[i].Size();
- streams[i].WriteDetails();
- }
- }
-
- internal void CalcTildeStreamSize() {
-CalcHeapSizes ();
- //tilde.SetIndexSizes(strings.LargeIx(),us.LargeIx(),guid.LargeIx(),blob.LargeIx());
- tildeTide = TildeHeaderSize;
- tildeTide += 4 * numTables;
- //Console.WriteLine("Tilde header + sizes = " + tildeTide);
- for (int i=0; i < numMetaDataTables; i++) {
- if (metaDataTables[i] != null) {
- ArrayList table = metaDataTables[i];
- // Console.WriteLine("Meta data table " + i + " at offset " + tildeTide);
- tildeTide += (uint)table.Count * ((MetaDataElement)table[0]).Size(this);
- // Console.WriteLine("Metadata table " + i + " has size " + table.Count);
- // Console.WriteLine("tildeTide = " + tildeTide);
- }
- }
- if ((tildeTide % 4) != 0) tildePadding = 4 - (tildeTide % 4);
- //Console.WriteLine("tildePadding = " + tildePadding);
- }
-
- internal void WriteTildeStream(FileImage output) {
- long startTilde = output.Seek(0,SeekOrigin.Current);
- output.Write((uint)0); // Reserved
- output.Write((byte)1); // MajorVersion
- output.Write((byte)0); // MinorVersion
- output.Write(heapSizes);
- output.Write((byte)1); // Reserved
- output.Write(valid);
- output.Write(sorted);
- for (int i=0; i < numMetaDataTables; i++) {
- if (metaDataTables[i] != null) {
- uint count = (uint)metaDataTables[i].Count;
- output.Write(count);
- }
- }
- long tabStart = output.Seek(0,SeekOrigin.Current);
- // Console.WriteLine("Starting metaData tables at " + tabStart);
- for (int i=0; i < numMetaDataTables; i++) {
- if (metaDataTables[i] != null) {
- // Console.WriteLine("Starting metaData table " + i + " at " + (output.Seek(0,SeekOrigin.Current) - startTilde));
- ArrayList table = metaDataTables[i];
- for (int j=0; j < table.Count; j++) {
- ((MetaDataElement)table[j]).Write(output);
- }
- }
- }
- // Console.WriteLine("Writing padding at " + output.Seek(0,SeekOrigin.Current));
- for (int i=0; i < tildePadding; i++) output.Write((byte)0);
- }
-
- private void BuildTable(ArrayList table) {
- if (table == null) return;
- for (int j=0; j < table.Count; j++) {
- ((MetaDataElement)table[j]).BuildTables(this);
- }
- }
-
- private void SortTable (ArrayList mTable) {
- if (mTable == null) return;
- mTable.Sort();
- for (int i=0; i < mTable.Count; i++) {
- ((MetaDataElement)mTable[i]).Row = (uint)i+1;
- }
- }
-
- internal void BuildMetaData(uint codeStartOffset) {
- codeStart = codeStartOffset;
- BuildTable(metaDataTables[(int)MDTable.TypeDef]);
- BuildTable(metaDataTables[(int)MDTable.MemberRef]);
- BuildTable(metaDataTables[(int)MDTable.GenericParam]);
- BuildTable(metaDataTables[(int)MDTable.MethodSpec]);
- BuildTable(metaDataTables[(int)MDTable.GenericParamConstraint]);
- BuildTable(metaDataTables[(int)MDTable.ManifestResource]);
-
- if (cattr_list != null) {
- foreach (CustomAttribute cattr in cattr_list)
- cattr.BuildTables (this);
- }
-
-/* for (int i=0; i < metaDataTables.Length; i++) {
- ArrayList table = metaDataTables[i];
- if (table != null) {
- for (int j=0; j < table.Count; j++) {
- ((MetaDataElement)table[j]).BuildTables(this);
- }
- }
- }
- */
-
- SetIndexSizes();
- for (int i=1; i < numStreams; i++) {
- streams[i].EndStream();
- }
- CalcTildeStreamSize();
- SetStreamOffsets();
- byteCodePadding = NumToAlign(codeSize,4);
- if (entryPoint != null) file.SetEntryPoint(entryPoint.Token());
-
- // Check ordering of specific tables
- // Constant, CustomAttribute, FieldMarshal, DeclSecurity, MethodSemantics
- // ImplMap, GenericParam
- // Need to load GenericParamConstraint AFTER GenericParam table in correct order
- // The tables:
- // InterfaceImpl, ClassLayout, FieldLayout, MethodImpl, FieldRVA, NestedClass
- // will _ALWAYS_ be in the correct order as embedded in BuildMDTables
-
- SortTable(metaDataTables[(int)MDTable.Constant]);
- SortTable(metaDataTables[(int)MDTable.CustomAttribute]);
- SortTable(metaDataTables[(int)MDTable.FieldMarshal]);
- SortTable(metaDataTables[(int)MDTable.DeclSecurity]);
- SortTable(metaDataTables[(int)MDTable.MethodSemantics]);
- SortTable(metaDataTables[(int)MDTable.ImplMap]);
- if (metaDataTables[(int)MDTable.GenericParam] != null) {
- SortTable(metaDataTables[(int)MDTable.GenericParam]);
- // Now add GenericParamConstraints
- /*for (int i=0; i < metaDataTables[(int)MDTable.GenericParam].Count; i++) {
- ((GenericParameter)metaDataTables[(int)MDTable.GenericParam][i]).AddConstraints(this);
- }*/
- }
- SortTable(metaDataTables[(int)MDTable.GenericParamConstraint]);
-
- }
-
- internal void WriteByteCodes(FileImage output) {
- for (int i=0; i < byteCodes.Count; i++) {
- ((CILInstructions)byteCodes[i]).Write(output);
- }
- for (int i=0; i < byteCodePadding; i++) {
- output.Write((byte)0);
- }
- }
-
- internal void WriteResources (FileImage output) {
- if (resources == null) return;
- for (int i = 0; i < resources.Count; i ++) {
- byte [] resBytes = (byte []) resources [i];
- output.Write ((uint) resBytes.Length);
- output.Write (resBytes);
- }
- }
-
- internal void WriteMetaData(FileImage output) {
- this.output = output;
- mdStart = output.Seek(0,SeekOrigin.Current);
- // Console.WriteLine("Writing metaData at " + Hex.Long(mdStart));
- output.Write(MetaDataSignature);
- output.Write((short)1); // Major Version
- output.Write((short)1); // Minor Version ECMA = 0, PEFiles = 1
- output.Write(0); // Reserved
- output.Write(version.Length);
- output.Write(version.ToCharArray()); // version string is already zero padded
- output.Write((short)0);
- output.Write((ushort)numStreams);
- // write tilde header
- output.Write(tildeStart);
- output.Write(tildeTide + tildePadding);
- output.Write(tildeName);
- for (int i=1; i < numStreams; i++) streams[i].WriteHeader(output);
- // Console.WriteLine("Writing tilde stream at " + output.Seek(0,SeekOrigin.Current) + " = " + tildeStart);
- WriteTildeStream(output);
- for (int i=1; i < numStreams; i++) streams[i].Write(output);
- // Console.WriteLine("Finished Writing metaData at " + output.Seek(0,SeekOrigin.Current));
- }
-
- internal bool LargeStringsIndex() { return strings.LargeIx(); }
- internal bool LargeGUIDIndex() { return guid.LargeIx(); }
- internal bool LargeUSIndex() { return us.LargeIx(); }
- internal bool LargeBlobIndex() { return blob.LargeIx(); }
-
- internal bool LargeIx(MDTable tabIx) { return largeIx[(uint)tabIx]; }
-
-
- private uint NumToAlign(uint val, uint alignVal) {
- if ((val % alignVal) == 0) return 0;
- return alignVal - (val % alignVal);
- }
-
- internal void WriteCodedIndex(CIx code, MetaDataElement elem, FileImage output) {
- uint ix = 0;
- if (elem != null) {
- ix = (elem.Row << CIxShiftMap[(uint)code]) | elem.GetCodedIx(code);
- // Console.WriteLine("coded index = " + ix + " row = " + elem.Row);
- //} else {
- // Console.WriteLine("elem for coded index is null");
- }
- if (lgeCIx[(uint)code])
- output.Write(ix);
- else
- output.Write((ushort)ix);
- }
-
- }
- /// <summary>
- /// Error for invalid PE file
- /// </summary>
- public class PEFileException : System.Exception {
- public PEFileException(string msg) : base("Error in PE File: " + msg) { }
- }
-
- /**************************************************************************/
- /// <summary>
- /// Base class for all Meta Data table elements
- /// </summary>
-
- public abstract class MetaDataElement: IComparable
- {
-
- protected ArrayList customAttributes;
- private uint row = 0;
- protected bool done = false;
- protected MDTable tabIx;
- protected bool sortTable = false;
-
- internal MetaDataElement() { }
-
- public uint Row {
- get {
- return row;
- }
- set {
- if (row == 0) row = value;
- }
- }
-
- internal virtual uint GetCodedIx(CIx code) { return 0; }
-
- /// <summary>
- /// Add a custom attribute to this item
- /// </summary>
- /// <param name="ctorMeth">the constructor method for this attribute</param>
- /// <param name="val">the byte value of the parameters</param>
- public void AddCustomAttribute(Method ctorMeth, byte[] val) {
- if (customAttributes == null) {
- customAttributes = new ArrayList();
- }
- customAttributes.Add(new CustomAttribute(this,ctorMeth,val));
- }
-
- /// <summary>
- /// Add a custom attribute to this item
- /// </summary>
- /// <param name="ctorMeth">the constructor method for this attribute</param>
- /// <param name="val">the constant values of the parameters</param>
- public void AddCustomAttribute(Method ctorMeth, Constant[] cVals) {
- if (customAttributes == null) {
- customAttributes = new ArrayList();
- }
-// customAttributes.Add(new CustomAttribute(this,ctorMeth,cVals));
- }
-
- internal uint Token() {
- return (((uint)tabIx << 24) | row);
- }
-
- internal virtual void BuildTables(MetaData md) {
- done = true;
- }
-
- internal virtual uint Size(MetaData md) {
- return 0;
- }
-
- internal virtual void Write(FileImage output) { }
-
- internal virtual uint SortKey()
- {
- throw new PEFileException("Trying to sort table of " + this);
- //return 0;
- }
-
- internal virtual uint SortKey2()
- {
- return 0;
- }
-
-
- public int CompareTo(object obj)
- {
- uint otherKey = ((MetaDataElement)obj).SortKey();
- uint thisKey = SortKey();
-
- if (thisKey == otherKey)
- {
- otherKey = ((MetaDataElement)obj).SortKey2();
- thisKey = SortKey2();
- if (thisKey == otherKey)
- return 0;
- if (thisKey < otherKey)
- return -1;
- return 1;
- }
- if (thisKey < otherKey) return -1;
-
- return 1;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Stream in the Meta Data (#Strings, #US, #Blob and #GUID)
- /// </summary>
-
- internal class MetaDataStream : BinaryWriter
- {
- private static readonly uint StreamHeaderSize = 8;
- private static uint maxSmlIxSize = 0xFFFF;
-
- private uint start = 0;
- uint size = 0, tide = 1;
- bool largeIx = false;
- uint sizeOfHeader;
- char[] name;
- Hashtable htable = new Hashtable();
- Hashtable btable = new Hashtable (new ByteArrayHashCodeProvider (), new ByteArrayComparer ());
-
- internal MetaDataStream(char[] name, bool addInitByte) : base(new MemoryStream()) {
- if (addInitByte) { Write((byte)0); size = 1; }
- this.name = name;
- sizeOfHeader = StreamHeaderSize + (uint)name.Length;
- }
-
- internal MetaDataStream(char[] name, System.Text.Encoding enc, bool addInitByte) : base(new MemoryStream(),enc) {
- if (addInitByte) { Write((byte)0); size = 1; }
- this.name = name;
- sizeOfHeader = StreamHeaderSize + (uint)name.Length;
- }
-
- public uint Start {
- get {
- return start;
- }
- set {
- start = value;
- }
- }
-
- internal uint headerSize() {
- // Console.WriteLine(name + " stream has headersize of " + sizeOfHeader);
- return sizeOfHeader;
- }
-
- internal void SetSize(uint siz) {
- size = siz;
- }
-
- internal uint Size() {
- return size;
- }
-
- internal bool LargeIx() {
- return largeIx;
- }
-
- internal void WriteDetails() {
- // Console.WriteLine(name + " - size = " + size);
- }
-
- internal uint Add(string str, bool prependSize) {
- Object val = htable[str];
- uint index = 0;
- if (val == null) {
- index = size;
- htable[str] = index;
- char[] arr = str.ToCharArray();
- if (prependSize) CompressNum((uint)arr.Length*2+1);
- Write(arr);
- Write((byte)0);
- size = (uint)Seek(0,SeekOrigin.Current);
- } else {
- index = (uint)val;
- }
- return index;
- }
- internal uint Add (byte[] str, bool prependSize) {
- Object val = btable [str];
- uint index = 0;
- if (val == null) {
- index = size;
- btable [str] = index;
- if (prependSize) CompressNum ((uint) str.Length);
- Write (str);
- size = (uint) Seek (0, SeekOrigin.Current);
- } else {
- index = (uint) val;
- }
- return index;
- }
-
-
- internal uint Add(Guid guid, bool prependSize) {
- byte [] b = guid.ToByteArray ();
- if (prependSize) CompressNum ((uint) b.Length);
- Write(guid.ToByteArray());
- size =(uint)Seek(0,SeekOrigin.Current);
- return tide++;
- }
-
- internal uint Add(byte[] blob) {
- uint ix = size;
- CompressNum((uint)blob.Length);
- Write(blob);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(byte val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (1);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(sbyte val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (1);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(ushort val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (2);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(short val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (2);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(uint val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (4);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(int val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (4);
- Write (val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(ulong val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (8);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(long val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (8);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(float val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (4);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- internal uint Add(double val, bool prependSize) {
- uint ix = size;
- if (prependSize) CompressNum (8);
- Write(val);
- size = (uint)Seek(0,SeekOrigin.Current);
- return ix;
- }
-
- private void CompressNum(uint val) {
- if (val < 0x7F) {
- Write((byte)val);
- } else if (val < 0x3FFF) {
- byte b1 = (byte)((val >> 8) | 0x80);
- byte b2 = (byte)(val & FileImage.iByteMask[0]);
- Write(b1);
- Write(b2);
- } else {
- byte b1 = (byte)((val >> 24) | 0xC0);
- byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);
- byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
- byte b4 = (byte)(val & FileImage.iByteMask[0]);
- Write(b1);
- Write(b2);
- Write(b3);
- Write(b4);
- }
- }
-
- private void QuadAlign() {
- if ((size % 4) != 0) {
- uint pad = 4 - (size % 4);
- size += pad;
- for (int i=0; i < pad; i++) {
- Write((byte)0);
- }
- }
- }
-
- internal void EndStream() {
- QuadAlign();
- if (size > maxSmlIxSize) {
- largeIx = true;
- }
- }
-
- internal void WriteHeader(BinaryWriter output) {
- output.Write(start);
- output.Write(size);
- output.Write(name);
- }
-
- internal virtual void Write(BinaryWriter output) {
- // Console.WriteLine("Writing " + name + " stream at " + output.Seek(0,SeekOrigin.Current) + " = " + start);
- MemoryStream str = (MemoryStream)BaseStream;
- output.Write(str.ToArray());
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for Method Descriptors
- /// </summary>
-
- public abstract class Method : Member
- {
- protected CallConv callConv = CallConv.Default;
- protected Type retType;
-
- internal Method(string methName, Type rType) : base(methName)
- {
- retType = rType;
- }
-
- /// <summary>
- /// Add calling conventions to this method descriptor
- /// </summary>
- /// <param name="cconv"></param>
- public void AddCallConv(CallConv cconv) {
- callConv |= cconv;
- }
-
- internal abstract void TypeSig(MemoryStream sig);
-
- internal uint GetSigIx(MetaData md) {
- MemoryStream sig = new MemoryStream();
- TypeSig(sig);
- return md.AddToBlobHeap(sig.ToArray());
- }
-
- internal Type GetRetType() {
- return retType;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a method defined in THIS assembly/module
- /// IL .method
- /// </summary>
-
- public class MethodDef : Method
- {
- private static readonly ushort PInvokeImpl = 0x2000;
- //private static readonly uint UnmanagedExport = 0x0008;
- // private static readonly byte LocalSigByte = 0x7;
- uint parIx = 0, textOffset = 0;
-
- MetaData metaData;
- CILInstructions code;
- ArrayList securityActions = new ArrayList();
- Param[] parList;
- Local[] locals;
- bool initLocals;
- ushort methFlags = 0, implFlags = 0;
- int maxStack = 0, numPars = 0;
- bool entryPoint = false;
- LocalSig localSig;
- ArrayList varArgSigList;
- ImplMap pinvokeImpl;
-
-
- internal MethodDef(MetaData md, string name, Type retType, Param[] pars) : base(name,retType) {
- metaData = md;
- parList = pars;
- if (parList != null) numPars = parList.Length;
- tabIx = MDTable.Method;
- }
-
- internal MethodDef(MetaData md, MethAttr mAttrSet, ImplAttr iAttrSet, string name, Type retType, Param[] pars) : base(name,retType) {
- metaData = md;
- parList = pars;
- if (parList != null) numPars = parList.Length;
- // Console.WriteLine("Creating method " + name + " with " + numPars + " parameters");
- methFlags = (ushort)mAttrSet;
- implFlags = (ushort)iAttrSet;
- tabIx = MDTable.Method;
- }
-
- internal Param[] GetPars() {
- return parList;
- }
-
- /// <summary>
- /// Add some attributes to this method descriptor
- /// </summary>
- /// <param name="ma">the attributes to be added</param>
- public void AddMethAttribute(MethAttr ma) {
- methFlags |= (ushort)ma;
- }
-
- /// <summary>
- /// Add some implementation attributes to this method descriptor
- /// </summary>
- /// <param name="ia">the attributes to be added</param>
- public void AddImplAttribute(ImplAttr ia) {
- implFlags |= (ushort)ia;
- }
-
- public void AddPInvokeInfo(ModuleRef scope, string methName,
- PInvokeAttr callAttr) {
- pinvokeImpl = new ImplMap((ushort)callAttr,this,methName,scope);
- methFlags |= PInvokeImpl;
- }
-
- /// <summary>
- /// Add a named generic type parameter
- /// </summary>
- public GenericParameter AddGenericParameter (short index, string name) {
- GenericParameter gp = new GenericParameter (this, metaData, index, name);
- metaData.AddToTable (MDTable.GenericParam, gp);
- return gp;
- }
-
- /// <summary>
- /// Set the maximum stack height for this method
- /// </summary>
- /// <param name="maxStack">the maximum height of the stack</param>
- public void SetMaxStack(int maxStack) {
- this.maxStack = maxStack;
- }
-
- /// <summary>
- /// Add local variables to this method
- /// </summary>
- /// <param name="locals">the locals to be added</param>
- /// <param name="initLocals">are locals initialised to default values</param>
- public void AddLocals(Local[] locals, bool initLocals) {
- this.locals = locals;
- this.initLocals = initLocals;
- }
-
- /// <summary>
- /// Mark this method as having an entry point
- /// </summary>
- public void DeclareEntryPoint() {
- entryPoint = true;
- }
-
- /// <summary>
- /// Create a code buffer for this method to add the IL instructions to
- /// </summary>
- /// <returns>a buffer for this method's IL instructions</returns>
- public CILInstructions CreateCodeBuffer() {
- code = new CILInstructions(metaData);
- return code;
- }
-
- /// <summary>
- /// Make a method reference descriptor for this method to be used
- /// as a callsite signature for this vararg method
- /// </summary>
- /// <param name="optPars">the optional pars for the vararg method call</param>
- /// <returns></returns>
- public MethodRef MakeVarArgSignature(Type[] optPars) {
- Type[] pars = new Type[numPars];
- MethodRef varArgSig;
- for (int i=0; i < numPars; i++) {
- pars[i] = parList[i].GetParType();
- }
- varArgSig = new MethodRef(this,name,retType,pars,true,optPars);
-
- if (varArgSigList == null)
- varArgSigList = new ArrayList ();
- varArgSigList.Add (varArgSig);
- return varArgSig;
- }
-
- internal sealed override void TypeSig(MemoryStream sig) {
- sig.WriteByte((byte)callConv);
- MetaData.CompressNum((uint)numPars,sig);
- retType.TypeSig(sig);
- for (ushort i=0; i < numPars; i++) {
- parList[i].seqNo = (ushort)(i+1);
- parList[i].TypeSig(sig);
- }
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- if (pinvokeImpl != null) {
- md.AddToTable(MDTable.ImplMap,pinvokeImpl);
- pinvokeImpl.BuildTables(md);
- }
- if (entryPoint) md.SetEntryPoint(this);
- uint locToken = 0;
- if (locals != null) {
- localSig = new LocalSig(locals);
- md.AddToTable(MDTable.StandAloneSig,localSig);
- localSig.BuildTables(md);
- locToken = localSig.Token();
- }
- if (code != null) {
- code.CheckCode(locToken,initLocals,maxStack);
- textOffset = md.AddCode(code);
- }
- nameIx = md.AddToStringsHeap(name);
- sigIx = GetSigIx(md);
- parIx = md.TableIndex(MDTable.Param);
- for (int i=0; i < numPars; i++) {
- md.AddToTable(MDTable.Param,parList[i]);
- parList[i].BuildTables(md);
- }
- if (varArgSigList != null) {
- foreach (MethodRef varArgSig in varArgSigList) {
- md.AddToTable(MDTable.MemberRef,varArgSig);
- varArgSig.BuildTables(md);
- }
- }
- // Console.WriteLine("method has " + numPars + " parameters");
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 8 + md.StringsIndexSize() + md.BlobIndexSize() + md.TableIndexSize(MDTable.Param);
- }
-
- internal sealed override void Write(FileImage output) {
- if (ZeroRva ()) output.Write(0);
- else output.WriteCodeRVA(textOffset);
- output.Write(implFlags);
- output.Write(methFlags);
- output.StringsIndex(nameIx);
- output.BlobIndex(sigIx);
- output.WriteIndex(MDTable.Param,parIx);
- }
-
- internal bool ZeroRva () {
- return (((methFlags & (ushort)MethAttr.Abstract) != 0) ||
- ((implFlags & (ushort)ImplAttr.Runtime) != 0) ||
- ((implFlags & (ushort)ImplAttr.InternalCall) != 0) ||
- (pinvokeImpl != null)); // TODO: Not entirely true but works for now
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 0;
- case (CIx.HasDeclSecurity) : return 1;
- case (CIx.MemberRefParent) : return 3;
- case (CIx.MethodDefOrRef) : return 0;
- case (CIx.MemberForwarded) : return 1;
- case (CIx.CustomAttributeType) : return 2;
- case (CIx.TypeOrMethodDef) : return 1;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for an overriding method (.override)
- /// </summary>
- public class MethodImpl : MetaDataElement
- {
- ClassDef parent;
- Method header, body;
-
- internal MethodImpl(ClassDef par, Method decl, Method bod) {
- parent = par;
- header = decl;
- body = bod;
- tabIx = MDTable.MethodImpl;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.TableIndexSize(MDTable.TypeDef) + 2 * md.CodedIndexSize(CIx.MethodDefOrRef);
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteIndex(MDTable.TypeDef,parent.Row);
- output.WriteCodedIndex(CIx.MethodDefOrRef,body);
- output.WriteCodedIndex(CIx.MethodDefOrRef,header);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a method defined in another assembly/module
- /// </summary>
- public class MethodRef : Method
- {
- private static readonly byte Sentinel = 0x41;
- Type[] parList, optParList;
- MetaDataElement parent;
- uint numPars = 0, numOptPars = 0;
-
- internal MethodRef(MetaDataElement paren, string name, Type retType,
- Type[] pars, bool varArgMeth, Type[] optPars) : base(name,retType) {
- parent = paren;
- parList = pars;
- if (parList != null) numPars = (uint)parList.Length;
- if (varArgMeth) {
- optParList = optPars;
- if (optParList != null) numOptPars = (uint)optParList.Length;
- callConv = CallConv.Vararg;
- }
- }
-
- internal sealed override void TypeSig(MemoryStream sig) {
- sig.WriteByte((byte)callConv);
- MetaData.CompressNum(numPars+numOptPars,sig);
- retType.TypeSig(sig);
- for (int i=0; i < numPars; i++) {
- parList[i].TypeSig(sig);
- }
- if (numOptPars > 0) {
- sig.WriteByte(Sentinel);
- for (int i=0; i < numOptPars; i++) {
- optParList[i].TypeSig(sig);
- }
- }
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- sigIx = GetSigIx(md);
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.CodedIndexSize(CIx.MemberRefParent) + md.StringsIndexSize() + md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.WriteCodedIndex(CIx.MemberRefParent,parent);
- output.StringsIndex(nameIx);
- output.BlobIndex(sigIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 6;
- case (CIx.MethodDefOrRef) : return 1;
- case (CIx.CustomAttributeType) : return 3;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for Property and Event methods
- /// </summary>
- public class MethodSemantics : MetaDataElement {
-
- Feature.MethodType type;
- MethodDef meth;
- Feature eventOrProp;
-
- internal MethodSemantics(Feature.MethodType mType, MethodDef method, Feature feature) {
- type = mType;
- meth = method;
- eventOrProp = feature;
- tabIx = MDTable.MethodSemantics;
- }
-
- internal override uint SortKey() {
- return eventOrProp.Row;
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.TableIndexSize(MDTable.Method) + md.CodedIndexSize(CIx.HasSemantics);
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write((ushort)type);
- output.WriteIndex(MDTable.Method,meth.Row);
- output.WriteCodedIndex(CIx.HasSemantics,eventOrProp);
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a FunctionPointer type
- /// </summary>
- ///
- public class MethPtrType : Type
- {
- bool varArgMeth;
- Type retType;
- Type [] parList;
- Type [] optParList;
- CallConv callConv;
- uint numPars;
- uint numOptPars;
- uint sigIx = 0;
-
- /// <summary>
- /// Create a new function pointer type
- /// </summary>
- /// <param name="meth">the function to be referenced</param>
- public MethPtrType (CallConv callconv, Type retType, Type[] pars,
- bool varArgMeth, Type[] optPars) : base(0x1B) {
- this.retType = retType;
- callConv = callconv;
- parList = pars;
- this.varArgMeth = varArgMeth;
- if (parList != null) numPars = (uint)parList.Length;
- if (varArgMeth) {
- optParList = optPars;
- if (optParList != null) numOptPars = (uint)optParList.Length;
- callConv |= CallConv.Vararg;
- }
- tabIx = MDTable.TypeSpec;
- }
-
- internal sealed override void TypeSig(MemoryStream sig) {
- sig.WriteByte(typeIndex);
- // Bootlegged from method ref
- sig.WriteByte((byte)callConv);
- MetaData.CompressNum (numPars + numOptPars, sig);
- retType.TypeSig (sig);
- for (int i=0; i < numPars; i++) {
- parList[i].TypeSig (sig);
- }
- if (varArgMeth) {
- sig.WriteByte (0x41); // Write the sentinel
- for (int i=0; i < numOptPars; i++) {
- optParList[i].TypeSig (sig);
- }
- }
- }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- MemoryStream sig = new MemoryStream();
- TypeSig(sig);
- sigIx = md.AddToBlobHeap(sig.ToArray());
- done = true;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.BlobIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.BlobIndex(sigIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) { return 0x1B; }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for THIS module
- /// </summary>
- public class Module : ResolutionScope
- {
- Guid mvid;
- uint mvidIx = 0;
-
- internal Module(string name, MetaData md) : base(name,md) {
- mvid = Guid.NewGuid();
- mvidIx = md.AddToGUIDHeap(mvid);
- tabIx = MDTable.Module;
- }
-
- public Guid Guid {
- get { return mvid; }
- }
-
- internal sealed override uint Size(MetaData md) {
- return 2 + md.StringsIndexSize() + 3 * md.GUIDIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write((short)0);
- output.StringsIndex(nameIx);
- output.GUIDIndex(mvidIx);
- output.GUIDIndex(0);
- output.GUIDIndex(0);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 7;
- case (CIx.ResolutionScope) : return 0;
- }
- return 0;
- }
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for another module in THIS assembly
- /// </summary>
- public class ModuleRef : ResolutionScope, IExternRef
- {
-
- internal ModuleRef(MetaData md, string name) : base(name,md) {
- tabIx = MDTable.ModuleRef;
- }
-
- /// <summary>
- /// Add a class to this external module. This is a class declared in
- /// another module of THIS assembly.
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns>a descriptor for this class in another module</returns>
- public ClassRef AddClass(string nsName, string name) {
- ClassRef aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- return aClass;
- }
-
- /// <summary>
- /// Make a file descriptor to correspond to this module. The file
- /// descriptor will have the same name as the module descriptor
- /// </summary>
- /// <param name="hashBytes">the hash of the file</param>
- /// <param name="hasMetaData">the file contains metadata</param>
- /// <param name="entryPoint">the program entry point is in this file</param>
- /// <returns>a descriptor for the file which contains this module</returns>
- public FileRef MakeFile(byte[] hashBytes, bool hasMetaData, bool entryPoint) {
- FileRef file = new FileRef(nameIx,hashBytes,hasMetaData,entryPoint,metaData);
- metaData.AddToTable(MDTable.File,file);
- return file;
- }
-
- /// <summary>
- /// Add a value class to this module. This is a class declared in
- /// another module of THIS assembly.
- /// </summary>
- /// <param name="nsName">name space name</param>
- /// <param name="name">class name</param>
- /// <returns></returns>
- public ClassRef AddValueClass(string nsName, string name) {
- ClassRef aClass = new ClassRef(nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeRef,aClass);
- aClass.SetParent(this);
- aClass.MakeValueClass(ValueClass.ValueType);
- return aClass;
- }
-
- /// <summary>
- /// Add a class which is declared public in this external module of
- /// THIS assembly. This class will be exported from this assembly.
- /// The ilasm syntax for this is .extern class
- /// </summary>
- /// <param name="attrSet">attributes of the class to be exported</param>
- /// <param name="nsName">name space name</param>
- /// <param name="name">external class name</param>
- /// <param name="declFile">the file where the class is declared</param>
- /// <param name="isValueClass">is this class a value type?</param>
- /// <returns>a descriptor for this external class</returns>
- public ExternClassRef AddExternClass(TypeAttr attrSet, string nsName,
- string name, FileRef declFile,
- bool isValueClass) {
- ExternClassRef cRef = new ExternClassRef(attrSet,nsName,name,declFile,metaData);
- metaData.AddToTable(MDTable.TypeRef,cRef);
- cRef.SetParent(this);
- if (isValueClass) cRef.MakeValueClass(ValueClass.ValueType);
- return cRef;
- }
-
- /// <summary>
- /// Add a "global" method in another module
- /// </summary>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">method parameter types</param>
- /// <returns>a descriptor for this method in anther module</returns>
- public MethodRef AddMethod(string name, Type retType, Type[] pars) {
- MethodRef meth = new MethodRef(this,name,retType,pars,false,null);
- metaData.AddToTable(MDTable.MemberRef,meth);
- return meth;
- }
-
- /// <summary>
- /// Add a vararg method to this class
- /// </summary>
- /// <param name="name">method name</param>
- /// <param name="retType">return type</param>
- /// <param name="pars">parameter types</param>
- /// <param name="optPars">optional param types for this vararg method</param>
- /// <returns>a descriptor for this method</returns>
- public MethodRef AddVarArgMethod(string name, Type retType,
- Type[] pars, Type[] optPars) {
- MethodRef meth = new MethodRef(this,name,retType,pars,true,optPars);
- metaData.AddToTable(MDTable.MemberRef,meth);
- return meth;
- }
-
- /// <summary>
- /// Add a field in another module
- /// </summary>
- /// <param name="name">field name</param>
- /// <param name="fType">field type</param>
- /// <returns>a descriptor for this field in another module</returns>
- public FieldRef AddField(string name, Type fType) {
- FieldRef field = new FieldRef(this,name,fType);
- metaData.AddToTable(MDTable.MemberRef,field);
- return field;
- }
-
- internal sealed override uint Size(MetaData md) {
- return md.StringsIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.StringsIndex(nameIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 12;
- case (CIx.MemberRefParent) : return 2;
- case (CIx.ResolutionScope) : return 1;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptors for native types used for marshalling
- /// </summary>
- public class NativeType {
- public static readonly NativeType Void = new NativeType(0x01);
- public static readonly NativeType Boolean = new NativeType(0x02);
- public static readonly NativeType Int8 = new NativeType(0x03);
- public static readonly NativeType UInt8 = new NativeType(0x04);
- public static readonly NativeType Int16 = new NativeType(0x05);
- public static readonly NativeType UInt16 = new NativeType(0x06);
- public static readonly NativeType Int32 = new NativeType(0x07);
- public static readonly NativeType UInt32 = new NativeType(0x08);
- public static readonly NativeType Int64 = new NativeType(0x09);
- public static readonly NativeType UInt64 = new NativeType(0x0A);
- public static readonly NativeType Float32 = new NativeType(0x0B);
- public static readonly NativeType Float64 = new NativeType(0x0C);
- public static readonly NativeType Currency = new NativeType(0x0F);
- public static readonly NativeType BStr = new NativeType(0x13);
- public static readonly NativeType LPStr = new NativeType(0x14);
- public static readonly NativeType LPWStr = new NativeType(0x15);
- public static readonly NativeType LPTStr = new NativeType(0x16);
- public static readonly NativeType FixedSysString = new NativeType(0x17);
- public static readonly NativeType IUnknown = new NativeType(0x19);
- public static readonly NativeType IDispatch = new NativeType(0x1A);
- public static readonly NativeType Struct = new NativeType(0x1B);
- public static readonly NativeType Interface = new NativeType(0x1C);
- public static readonly NativeType Int = new NativeType(0x1F);
- public static readonly NativeType UInt = new NativeType(0x20);
- public static readonly NativeType ByValStr = new NativeType(0x22);
- public static readonly NativeType AnsiBStr = new NativeType(0x23);
- public static readonly NativeType TBstr = new NativeType(0x24);
- public static readonly NativeType VariantBool = new NativeType(0x25);
- public static readonly NativeType FuncPtr = new NativeType(0x26);
- public static readonly NativeType AsAny = new NativeType(0x28);
-
- protected byte typeIndex;
-
- internal NativeType(byte tyIx) { typeIndex = tyIx; }
-
- internal byte GetTypeIndex() { return typeIndex; }
-
- internal virtual byte[] ToBlob() {
- byte[] bytes = new byte[1];
- bytes[0] = GetTypeIndex();
- return bytes;
- }
-
- }
-
- public class NativeArray : NativeType
- {
- NativeType elemType;
- uint len = 0, parNum = 0;
-
- /*
- public NativeArray(NativeType elemType) : base(0x2A) {
- this.elemType = elemType;
- }
-
- public NativeArray(NativeType elemType, int len) : base(0x2A) {
- this.elemType = elemType;
- this.len = len;
- }
-*/
- public NativeArray(NativeType elemType, int numElem, int parNumForLen) : base(0x2A) {
- this.elemType = elemType;
- len = (uint)numElem;
- parNum = (uint)parNumForLen;
- }
-
- internal override byte[] ToBlob() {
- MemoryStream str = new MemoryStream();
- str.WriteByte(GetTypeIndex());
- if (elemType == null) str.WriteByte(0x50); // no info (MAX)
- else str.WriteByte(elemType.GetTypeIndex());
- MetaData.CompressNum(parNum,str);
- str.WriteByte(1);
- MetaData.CompressNum(len,str);
- return str.ToArray();
- }
-
- }
-
- public class SafeArray : NativeType
- {
- SafeArrayType elemType;
-
- public SafeArray(SafeArrayType elemType) : base(0x1D) {
- this.elemType = elemType;
- }
-
- internal override byte[] ToBlob() {
- byte[] bytes = new byte[2];
- bytes[0] = GetTypeIndex();
- bytes[1] = (byte)elemType;
- return bytes;
- }
-
- }
-
- public class FixedArray : NativeType
- {
- NativeType elemType;
- uint numElem;
-
- public FixedArray(NativeType elemType, int numElems) : base(0x1E) {
- this.elemType = elemType;
- numElem = (uint)numElems;
- }
-
- internal override byte[] ToBlob() {
- MemoryStream str = new MemoryStream();
- str.WriteByte(GetTypeIndex());
- MetaData.CompressNum(numElem,str);
- if (elemType == null) str.WriteByte(0x50); // no info (MAX)
- else str.WriteByte(elemType.GetTypeIndex());
- return str.ToArray();
- }
-
- }
-
- public class CustomMarshaller : NativeType
- {
- string typeName;
- string marshallerName;
- string cookie;
-
- public CustomMarshaller(string typeNameOrGUID, string marshallerName,
- string optCookie) : base(0x2C) {
- typeName = typeNameOrGUID;
- this.marshallerName = marshallerName;
- cookie = optCookie;
- }
-
- internal override byte[] ToBlob() {
- MemoryStream str = new MemoryStream();
- BinaryWriter bw = new BinaryWriter(str,new UTF8Encoding());
- bw.Write(GetTypeIndex());
- bw.Write(typeName.ToCharArray());
- bw.Write((byte)0);
- bw.Write(marshallerName.ToCharArray());
- bw.Write((byte)0);
- if (cookie != null) bw.Write(cookie.ToCharArray());
- bw.Write((byte)0);
- bw.Flush();
- return str.ToArray();
- }
- }
-
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a parameter of a method defined in this assembly/module
- /// </summary>
- public class Param : MetaDataElement
- {
- private static readonly ushort hasDefault = 0x1000;
- private static readonly ushort hasFieldMarshal = 0x2000;
-
- Type pType;
- string pName;
- internal ushort seqNo = 0;
- ushort parMode;
- ConstantElem defaultVal;
- uint nameIx = 0;
- FieldMarshal marshalInfo;
-
- /// <summary>
- /// Create a new parameter for a method
- /// </summary>
- /// <param name="mode">param mode (in, out, opt)</param>
- /// <param name="parName">parameter name</param>
- /// <param name="parType">parameter type</param>
- public Param(ParamAttr mode, string parName, Type parType) {
- pName = parName;
- pType = parType;
- parMode = (ushort)mode;
- tabIx = MDTable.Param;
- }
-
- /// <summary>
- /// Add a default value to this parameter
- /// </summary>
- /// <param name="c">the default value for the parameter</param>
- public void AddDefaultValue(Constant cVal) {
- defaultVal = new ConstantElem(this,cVal);
- parMode |= hasDefault;
- }
-
- /// <summary>
- /// Add marshalling information about this parameter
- /// </summary>
- public void AddMarshallInfo(NativeType marshallType) {
- parMode |= hasFieldMarshal;
- marshalInfo = new FieldMarshal(this,marshallType);
- }
-
- internal Type GetParType() { return pType; }
-
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(pName);
- if (defaultVal != null) {
- md.AddToTable(MDTable.Constant,defaultVal);
- defaultVal.BuildTables(md);
- }
- if (marshalInfo != null) {
- md.AddToTable(MDTable.FieldMarshal,marshalInfo);
- marshalInfo.BuildTables(md);
- }
- done = true;
- }
-
- internal void TypeSig(MemoryStream str) {
- pType.TypeSig(str);
- }
-
- internal sealed override uint Size(MetaData md) {
- return 4 + md.StringsIndexSize();
- }
-
- internal sealed override void Write(FileImage output) {
- output.Write(parMode);
- output.Write(seqNo);
- output.StringsIndex(nameIx);
- }
-
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 4;
- case (CIx.HasConst) : return 1;
- case (CIx.HasFieldMarshal) : return 1;
- }
- return 0;
- }
-
- }
- /**************************************************************************/
- /// <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 int corFlags = 1;
- FileImage fileImage;
- MetaData metaData;
+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);
+ }
- /// <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) {
- // Console.WriteLine(Hex.Byte(0x12));
- // Console.WriteLine(Hex.Short(0x1234));
- // Console.WriteLine(Hex.Int(0x12345678));
- string fName = MakeFileName(null,name,isDLL);
- fileImage = new FileImage(isDLL,fName);
- InitPEFile(name, fName, hasAssembly);
- }
+ internal FileImage(bool makeDLL, Stream str) : base(str)
+ {
+ InitFileImage(makeDLL);
+ TimeSpan tmp = DateTime.Now.Subtract(origin);
+ dateStamp = Convert.ToUInt32(tmp.TotalSeconds);
+ }
- /// <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) {
- // Console.WriteLine(Hex.Byte(0x12));
- // Console.WriteLine(Hex.Short(0x1234));
- // Console.WriteLine(Hex.Int(0x12345678));
- string fName = MakeFileName(outputDir,name,isDLL);
- fileImage = new FileImage(isDLL,fName);
- InitPEFile(name, fName, hasAssembly);
- }
+ 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);
+ }
- /// <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) {
- fileImage = new FileImage(isDLL,outStream);
- InitPEFile(name, MakeFileName(null,name,isDLL), hasAssembly);
- }
+ internal MetaData GetMetaData()
+ {
+ return metaData;
+ }
- public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, Stream outStream) {
- fileImage = new FileImage(isDLL,outStream);
- InitPEFile(name, (module_name == null ? MakeFileName(null,name,isDLL) : module_name), hasAssembly);
- }
+ private uint GetNextSectStart(uint rva, uint tide)
+ {
+ uint c = tide / SectionAlignment;
+ if ((tide % SectionAlignment) != 0)
+ c++;
+ return rva + (c * SectionAlignment);
+ }
- 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);
- }
-
+ 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));
- 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;
- }
+ 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;
+ }
- /// <summary>
- /// Set the flags (.corflags)
- /// </summary>
- /// <param name="flags">the flags value</param>
- public void SetCorFlags(int flags) {
- corFlags = flags;
- }
+ 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;
+ }
- 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;
- }
+ internal void MakeFile()
+ {
+ if (doDLL) hintNameTable = dllHintNameTable.ToCharArray();
+ else hintNameTable = exeHintNameTable.ToCharArray();
+ BuildTextSection();
+ CalcOffsets();
+ BuildRelocSection();
+ // now write it out
+ WriteHeader();
+ WriteSections();
+ Flush();
+ Close();
+ }
- /// <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;
- }
+ 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);
+ }
- /// <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;
- }
+ private void WriteSections()
+ {
+ // Console.WriteLine("Writing text section at offset " + Seek(0,SeekOrigin.Current));
+ WriteTextSection();
+ if (sdata != null) WriteSDataSection();
+ if (rsrc != null) WriteRsrcSection();
+ WriteRelocSection();
+ }
- /// <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, Type retType, Param[] pars) {
- return moduleClass.AddMethod(name,retType,pars);
- }
+ private void WriteIAT()
+ {
+ Write(text.RVA() + hintNameTableOffset);
+ Write(0);
+ }
- /// <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, Type retType, Param[] pars) {
- return moduleClass.AddMethod(mAtts,iAtts,name,retType,pars);
- }
+ 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());
+ }
- public MethodRef AddMethodToTypeSpec (Type item, string name, Type retType, Type[] pars) {
- MethodRef meth = new MethodRef (item.GetTypeSpec (metaData), name, retType, pars, false, null);
- metaData.AddToTable (MDTable.MemberRef,meth);
- return meth;
- }
+ 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());
+ }
- 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);
- metaData.AddToTable(MDTable.MemberRef,meth);
- return meth;
- }
+ 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
+ }
- 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;
- }
+ 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);
+ }
- public void AddMethodSpec (Method m, GenericMethodSig g_sig)
- {
- MethodSpec ms = new MethodSpec (m, g_sig);
- metaData.AddToTable (MDTable.MethodSpec, ms);
- }
+ private void WriteRsrcSection()
+ {
+ }
- /// <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);
- }
+ 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));
+ }
- /// <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);
- }
+ internal void SetEntryPoint(uint entryPoint)
+ {
+ entryPointToken = entryPoint;
+ }
- /// <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) {
- ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData);
- metaData.AddToTable(MDTable.TypeDef,aClass);
- return aClass;
- }
+ 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());
+ }
- /// <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);
- aClass.MakeValueClass(vClass);
- aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ());
- metaData.AddToTable(MDTable.TypeDef,aClass);
- return aClass;
- }
+ internal void WriteZeros(uint numZeros)
+ {
+ for (int i=0; i < numZeros; i++) {
+ Write((byte)0);
+ }
+ }
- /// <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);
- aClass.SetSuper(superType);
- metaData.AddToTable(MDTable.TypeDef,aClass);
- return aClass;
- }
+ 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
+ }
- 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;
- }
+ internal void WriteRelocSectionHeader()
+ {
+ Write(relocName.ToCharArray());
+ Write(relocTide);
+ Write(relocRVA);
+ Write(relocSize);
+ Write(relocOffset);
+ WriteZeros(12);
+ Write(relocFlags);
+ }
- /// <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);
- }
+ 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);
+ }
+ }
+ }
- public void AddCustomAttribute (Method meth, byte [] data, MetaDataElement element)
- {
- metaData.AddCustomAttribute (new CustomAttribute (element, meth, data));
- }
+ private uint Align(uint val, uint alignVal)
+ {
+ if ((val % alignVal) != 0) {
+ val += alignVal - (val % alignVal);
+ }
+ return val;
+ }
- /// <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));
- }
+ private uint NumToAlign(uint val, uint alignVal)
+ {
+ if ((val % alignVal) == 0) return 0;
+ return alignVal - (val % alignVal);
+ }
- /// <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;
- }
+ internal void StringsIndex(uint ix)
+ {
+ if (largeStrings) Write(ix);
+ else Write((ushort)ix);
+ }
- public ManifestResource [] GetResources() {
- return (ManifestResource []) resources.ToArray (typeof (ManifestResource));
- }
+ internal void GUIDIndex(uint ix)
+ {
+ if (largeGUID) Write(ix);
+ else Write((ushort)ix);
+ }
- /// <summary>
- /// Write out the PEFile (the "bake" function)
- /// </summary>
- public void WritePEFile() { /* the "bake" function */
- fileImage.ReserveStrongNameSignatureSpace = thisAssembly.HasPublicKey;
- fileImage.MakeFile();
- }
+ internal void USIndex(uint ix)
+ {
+ if (largeUS) Write(ix);
+ else Write((ushort)ix);
+ }
- /// <summary>
- /// Get the descriptor of this module
- /// </summary>
- /// <returns>the descriptor for this module</returns>
- public Module GetThisModule() {
- return thisMod;
- }
+ internal void BlobIndex(uint ix)
+ {
+ if (largeBlob) Write(ix);
+ else Write((ushort)ix);
+ }
- /// <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;
- }
+ 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);
+ }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for the Primitive types defined in IL
- /// </summary>
- public class PrimitiveType : Type
- {
- private string name;
- private int systemTypeIndex;
- public static int NumSystemTypes = 18;
+ internal void WriteCodeRVA(uint offs)
+ {
+ Write(text.RVA() + offs);
+ }
- public static readonly PrimitiveType Void = new PrimitiveType(0x01,"Void",0);
- public static readonly PrimitiveType Boolean = new PrimitiveType(0x02,"Boolean",1);
- public static readonly PrimitiveType Char = new PrimitiveType(0x03,"Char",2);
- public static readonly PrimitiveType Int8 = new PrimitiveType(0x04,"SByte",3);
- public static readonly PrimitiveType UInt8 = new PrimitiveType(0x05,"Byte",4);
- public static readonly PrimitiveType Int16 = new PrimitiveType(0x06,"Int16",5);
- public static readonly PrimitiveType UInt16 = new PrimitiveType(0x07,"UInt16",6);
- public static readonly PrimitiveType Int32 = new PrimitiveType(0x08,"Int32",7);
- public static readonly PrimitiveType UInt32 = new PrimitiveType(0x09,"UInt32",8);
- public static readonly PrimitiveType Int64 = new PrimitiveType(0x0A,"Int64",9);
- public static readonly PrimitiveType UInt64 = new PrimitiveType(0x0B,"UInt64",10);
- public static readonly PrimitiveType Float32 = new PrimitiveType(0x0C,"Single",11);
- public static readonly PrimitiveType Float64 = new PrimitiveType(0x0D,"Double",12);
- public static readonly PrimitiveType String = new PrimitiveType(0x0E,"String",13);
- internal static readonly PrimitiveType Class = new PrimitiveType(0x12);
- public static readonly PrimitiveType TypedRef = new PrimitiveType(0x16,"TypedReference",14);
- public static readonly PrimitiveType IntPtr = new PrimitiveType(0x18,"IntPtr",15);
- public static readonly PrimitiveType UIntPtr = new PrimitiveType(0x19,"UIntPtr",16);
- public static readonly PrimitiveType Object = new PrimitiveType(0x1C,"Object",17);
- internal static readonly PrimitiveType ClassType = new PrimitiveType(0x50);
- internal static readonly PrimitiveType SZArray = new PrimitiveType(0x1D);\r
- internal static readonly PrimitiveType ValueType = new PrimitiveType(0x11, "ValueType", 18);\r
- public static readonly PrimitiveType NativeInt = IntPtr;
- public static readonly PrimitiveType NativeUInt = UIntPtr;
+ internal void WriteDataRVA(uint offs)
+ {
+ Write(sdata.RVA() + offs);
+ }
- internal PrimitiveType(byte typeIx) : base(typeIx) { }
+ 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 PrimitiveType(byte typeIx, string name, int STIx) : base(typeIx) {
- this.name = name;
- this.systemTypeIndex = STIx;
- }
+ internal bool ReserveStrongNameSignatureSpace {
+ get { return reserveStrongNameSignatureSpace; }
+ set { reserveStrongNameSignatureSpace = value; }
+ }
- internal string GetName() { return name; }
+ }
- internal int GetSystemTypeIx() { return systemTypeIndex; }
+ /**************************************************************************/
+ /// <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 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));
+ }
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- }
+ /// <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));
+ }
- internal override MetaDataElement GetTypeSpec(MetaData md) {
- TypeSpec tS = md.GetPrimitiveTypeSpec(systemTypeIndex);
- if (tS == null) {
- tS = new TypeSpec(this,md);
- md.SetPrimitiveTypeSpec(systemTypeIndex,tS);
- md.AddToTable(MDTable.TypeSpec,tS);
- }
- return tS;
- }
+ /// <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)
+ {
+ }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for the Property of a class
- /// </summary>
- public class Property : Feature
- {
- private static readonly byte PropertyTag = 0x8;
- MethodDef getterMeth;
- ConstantElem constVal;
- uint typeBlobIx = 0;
- Type[] parList;
- Type returnType;
- uint numPars = 0;
+ 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);
+ }
- internal Property(string name, Type retType, Type[] pars, ClassDef parent) : base(name, parent) {
- returnType = retType;
- parList = pars;
- if (pars != null) numPars = (uint)pars.Length;
- tabIx = MDTable.Property;
- }
+ private void SetName (string name)
+ {
+ if (name == "mscorlib")
+ isMSCorlib = true;
+ }
- /// <summary>
- /// Add a set method to this property
- /// </summary>
- /// <param name="setter">the set method</param>
- public void AddSetter(MethodDef setter) {
- AddMethod(setter,MethodType.Setter);
- }
+ 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);
+ }
- /// <summary>
- /// Add a get method to this property
- /// </summary>
- /// <param name="getter">the get method</param>
- public void AddGetter(MethodDef getter) {
- AddMethod(getter,MethodType.Getter);
- getterMeth = getter;
- }
+ internal static bool IsMSCorlib {
+ get { return isMSCorlib; }
+ }
- /// <summary>
- /// Add another method to this property
- /// </summary>
- /// <param name="other">the method</param>
- public void AddOther(MethodDef other) {
- AddMethod(other,MethodType.Other);
- }
+ public ClassDef ModuleClass {
+ get { return moduleClass; }
+ }
- /// <summary>
- /// Add an initial value for this property
- /// </summary>
- /// <param name="constVal">the initial value for this property</param>
- public void AddInitValue(Constant constVal) {
- this.constVal = new ConstantElem(this,constVal);
- }
+ /// <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;
+ }
- internal sealed override void BuildTables(MetaData md) {
- if (done) return;
- nameIx = md.AddToStringsHeap(name);
- MemoryStream sig = new MemoryStream();
- sig.WriteByte(PropertyTag);
- MetaData.CompressNum(numPars,sig);
- returnType.TypeSig(sig);
- for (int i=0; i < numPars; i++) {
- parList[i].TypeSig(sig);
- }
- typeBlobIx = md.AddToBlobHeap(sig.ToArray());
- for (int i=0; i < tide; i++) {
- md.AddToTable(MDTable.MethodSemantics,methods[i]);
- }
- if (constVal != null) {
- md.AddToTable(MDTable.Constant,constVal);
- constVal.BuildTables(md);
- }
- done = true;
- }
+ /// <summary>
+ /// Set the flags (.corflags)
+ /// </summary>
+ /// <param name="flags">the flags value</param>
+ public void SetCorFlags(int flags)
+ {
+ corFlags = flags;
+ }
- internal sealed override uint Size(MetaData md) {
- return 2 + md.StringsIndexSize() + md.BlobIndexSize();
- }
+ public void SetStackReserve (long stackReserve)
+ {
+ fileImage.stackReserve = stackReserve;
+ }
- internal sealed override void Write(FileImage output) {
- output.Write(flags);
- output.StringsIndex(nameIx);
- output.BlobIndex(typeBlobIx);
- }
+ 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;
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.HasCustomAttr) : return 9;
- case (CIx.HasConst) : return 2;
- case (CIx.HasSemantics) : return 1;
- }
- return 0;
- }
+ // if (isDLL) result += ".dll"; else result += ".exe";
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for an pointer (type * or type &)
- /// </summary>
- public abstract class PtrType : Type
- {
- Type baseType;
+ return result;
+ }
- internal PtrType(Type bType, byte typeIx) : base(typeIx)
- {
- baseType = bType;
- tabIx = MDTable.TypeSpec;
- }
+ /// <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;
+ }
- internal sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(typeIndex);
- baseType.TypeSig(str);
- }
+ /// <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>
- /// Descriptor for a managed pointer (type & or byref)
- /// </summary>
+ public ClassRef AddExternClass(string ns, string name, TypeAttr attrs, MetaDataElement declRef)
+ {
+ return new ExternClassRef (attrs, ns, name, declRef, metaData);
+ }
+
+ /// <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);
+ }
- public class ManagedPointer : PtrType // <type> & (BYREF)
- {
+ /// <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);
+ }
- /// <summary>
- /// Create new managed pointer to baseType
- /// </summary>
- /// <param name="bType">the base type of the pointer</param>
- public ManagedPointer(Type baseType) : base(baseType,0x10) { }
-
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for an unmanaged pointer (type *)
- /// </summary>
- public class UnmanagedPointer : PtrType // PTR
- {
- /// <summary>
- /// Create a new unmanaged pointer to baseType
- /// </summary>
- /// <param name="baseType">the base type of the pointer</param>
- public UnmanagedPointer(Type baseType) : base(baseType, 0x0F) { }
+ public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name, Type retType, Param[] pars)
+ {
+ return AddMethod (mAtts, iAtts, name, new Param (ParamAttr.Default, "", retType), pars);
+ }
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for scopes (extended by Module, ModuleRef, Assembly, AssemblyRef)
- /// </summary>
- public abstract class ResolutionScope : MetaDataElement
- {
- protected uint nameIx = 0;
- protected MetaData metaData;
- protected string name;
+ 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;
+ }
- internal ResolutionScope(string name, MetaData md)
- {
- metaData = md;
- this.name = name;
- nameIx = md.AddToStringsHeap(name);
- }
+ 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;
+ }
- internal string GetName() { return name; }
+ 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;
+ }
- }
- /**************************************************************************/
- /// <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
+ public Method AddMethodSpec (Method m, GenericMethodSig g_sig)
+ {
+ MethodSpec ms = new MethodSpec (m, g_sig);
+ metaData.AddToTable (MDTable.MethodSpec, ms);
+ return ms;
+ }
- char[] name;
- uint offset = 0, tide = 0, size = 0, rva = 0, relocTide = 0;
- //uint relocOff = 0;
- uint flags = 0, padding = 0;
- uint[] relocs;
+ /// <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);
+ }
- internal Section(string sName, uint sFlags) {
- name = sName.ToCharArray();
- flags = sFlags;
- }
+ /// <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);
+ }
- internal uint Tide() { return tide; }
+ /// <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);
+ }
- internal void IncTide(uint incVal) { tide += incVal; }
+ /// <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;
+ }
- internal uint Padding() { return padding; }
+ /// <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;
+ }
- internal uint Size() { return size; }
+ public void AddGenericClass (GenericTypeInst gti)
+ {
+ metaData.AddToTable (MDTable.TypeSpec, gti);
+ }
- internal void SetSize(uint pad) {
- padding = pad;
- size = tide + padding;
- }
+ public void AddGenericParam (GenParam param)
+ {
+ metaData.AddToTable (MDTable.TypeSpec, param);
+ }
- internal uint RVA() { return rva; }
+ 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;
+ }
- internal void SetRVA(uint rva) { this.rva = rva; }
+ public PrimitiveTypeRef AddPrimitiveType (PrimitiveType type)
+ {
+ return new PrimitiveTypeRef (type, metaData);
+ }
- internal uint Offset() { return offset; }
+ /// <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);
+ }
- internal void SetOffset(uint offs) { offset = offs; }
+ public void AddCustomAttribute (Method meth, byte [] data, MetaDataElement element)
+ {
+ metaData.AddCustomAttribute (new CustomAttribute (element, meth, data));
+ element.HasCustomAttr = true;
+ }
- 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);
- }
+ public void AddCustomAttribute (Method meth, Constant constant, MetaDataElement element)
+ {
+ metaData.AddCustomAttribute (new CustomAttribute (element, meth, constant));
+ element.HasCustomAttr = true;
+ }
- 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);
- }
- }
+ public void AddDeclSecurity (SecurityAction sec_action, byte [] data, MetaDataElement element)
+ {
+ metaData.AddDeclSecurity (new DeclSecurity (element, (ushort) sec_action, data));
+ }
- 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 void AddDeclSecurity (SecurityAction sec_action, PEAPI.PermissionSet ps, MetaDataElement element)
+ {
+ metaData.AddDeclSecurity (new DeclSecurity_20 (element, (ushort) sec_action, ps));
+ }
- }
- /**************************************************************************/
- public abstract class Signature : MetaDataElement
- {
- protected uint sigIx;
+ /// <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));
+ }
- internal Signature() {
- tabIx = MDTable.StandAloneSig;
- }
+ /// <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;
+ }
- internal sealed override uint Size(MetaData md) {
- return md.BlobIndexSize();
- }
+ public ManifestResource [] GetResources()
+ {
+ return (ManifestResource []) resources.ToArray (typeof (ManifestResource));
+ }
- internal sealed override void Write(FileImage output) {
- output.BlobIndex(sigIx);
- }
+ /// <summary>
+ /// Write out the PEFile (the "bake" function)
+ /// </summary>
+ public void WritePEFile() { /* the "bake" function */
+ if (thisAssembly != null)
+ fileImage.ReserveStrongNameSignatureSpace = thisAssembly.HasPublicKey;
+ fileImage.MakeFile();
+ }
- internal sealed override uint GetCodedIx(CIx code) { return (uint)tabIx; }
+ /// <summary>
+ /// Get the descriptor of this module
+ /// </summary>
+ /// <returns>the descriptor for this module</returns>
+ public Module GetThisModule()
+ {
+ return thisMod;
+ }
- }
- /**************************************************************************/
- /// <summary>
- /// Descriptor for a class defined in System (mscorlib)
- /// </summary>
- internal class SystemClass : ClassRef
- {
- PrimitiveType elemType;
+ /// <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;
+ }
- internal SystemClass(PrimitiveType eType, AssemblyRef paren, MetaData md)
- : base("System",eType.GetName(),md) {
- elemType = eType;
- parent = paren;
- }
+ }
- internal override sealed MetaDataElement GetTypeSpec(MetaData md) {
- if (typeSpec == null) typeSpec = (TypeSpec)elemType.GetTypeSpec(md);
- return typeSpec;
- }
+ /**************************************************************************/
+ /// <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 sealed override void TypeSig(MemoryStream str) {
- str.WriteByte(elemType.GetTypeIndex());
- }
+ internal Section(string sName, uint sFlags)
+ {
+ name = sName.ToCharArray();
+ flags = sFlags;
+ }
- }
- /**************************************************************************/
- /// <summary>
- /// Base class for all IL types
- /// </summary>
- public abstract class Type : MetaDataElement {
- protected byte typeIndex;
- protected TypeSpec typeSpec;
+ internal uint Tide() { return tide; }
- internal Type(byte tyIx) { typeIndex = tyIx; }
+ internal void IncTide(uint incVal) { tide += incVal; }
- internal byte GetTypeIndex() { return typeIndex; }
- internal void SetTypeIndex (byte b) { typeIndex = b; }
-
- internal virtual MetaDataElement GetTypeSpec(MetaData md) {
- if (typeSpec == null) {
- typeSpec = new TypeSpec(this,md);
- md.AddToTable(MDTable.TypeSpec,typeSpec);
- }
- return typeSpec;
- }
-
- internal virtual void TypeSig(MemoryStream str) {
- throw(new TypeSignatureException(this.GetType().AssemblyQualifiedName +
- " doesn't have a type signature!!"));
- }
+ internal uint Padding() { return padding; }
- }
+ internal uint Size() { return size; }
- /**************************************************************************/
+ internal void SetSize(uint pad)
+ {
+ padding = pad;
+ size = tide + padding;
+ }
- public class TypeSpec : MetaDataElement {
- uint sigIx = 0;
+ internal uint RVA() { return rva; }
- internal TypeSpec(Type aType, MetaData md) {
- MemoryStream sig = new MemoryStream();
- aType.TypeSig(sig);
- sigIx = md.AddToBlobHeap(sig.ToArray());
- tabIx = MDTable.TypeSpec;
- }
+ internal void SetRVA(uint rva) { this.rva = rva; }
- internal sealed override uint GetCodedIx(CIx code) {
- switch (code) {
- case (CIx.TypeDefOrRef) : return 2;
- case (CIx.HasCustomAttr) : return 13;
- case (CIx.MemberRefParent) : return 4;
- }
- return 0;
- }
+ internal uint Offset() { return offset; }
- internal override uint Size(MetaData md) {
- return md.BlobIndexSize();
- }
+ internal void SetOffset(uint offs) { offset = offs; }
- internal sealed override void Write(FileImage output) {
- //Console.WriteLine("Writing the blob index for a TypeSpec");
- output.BlobIndex(sigIx);
- }
+ 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);
+ }
+ }
- class ByteArrayComparer : IComparer {
+ 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++;
+ }
- public int Compare (object x, object y)
- {
- byte [] a = (byte []) x;
- byte [] b = (byte []) y;
- int len = a.Length;
+ 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);
+ }
- if (b.Length != len)
- return 1;
+ }
- for (int i = 0; i < len; ++i)
- if (a [i] != b [i])
- return 1;
- return 0;
- }
- }
+ 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);
+ }
- class ByteArrayHashCodeProvider : IHashCodeProvider {
+ 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 int GetHashCode (Object key)
+ public static String Int(int val)
{
- byte [] arr = (byte []) key;
- int len = arr.Length;
- int h = 0;
+ 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);
+ }
- for (int i = 0; i < len; ++i)
- h = (h << 5) - h + arr [i];
+ 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);
+ }
- return h;
+ 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) { }
+ }
+}
projects / mono.git / blobdiff