using System.IO;
using System.Collections;
using System.Text;
+using System.Reflection;
namespace PEAPI {
/// <summary>
/// Attributes for this assembly
/// </summary>
- public enum AssemAttr { EnableJITCompileTracking = 0x8000,
+ public enum AssemAttr { Retargetable = 0x100, EnableJITCompileTracking = 0x8000,
DisableJITCompileOptimizer = 0x4000}
/// <summary>
/// <summary>
/// Attibutes for a class
/// </summary>
+ [Flags]
public enum TypeAttr {Private, Public, NestedPublic, NestedPrivate,
NestedFamily, NestedAssembly, NestedFamAndAssem, NestedFamOrAssem,
SequentialLayout, ExplicitLayout = 0x10, Interface = 0x20,
PublicSealed = 0x101, SpecialName = 0x400, RTSpecialName = 0x800,
Import = 0x1000, Serializable = 0x2000, UnicodeClass = 0x10000,
AutoClass = 0x20000, HasSecurity = 0x40000, BeforeFieldInit = 0x100000,
+ Forwarder = 0x200000,
VisibilityMask = 0x07 }
/// <summary>
Family, FamOrAssem, Public, Static = 0x0010, PublicStatic = 0x16,
Final = 0x0020, PublicStaticFinal = 0x36, Virtual = 0x0040,
PrivateVirtual, PublicVirtual = 0x0046, HideBySig = 0x0080,
- NewSlot = 0x0100, Abstract = 0x0400, SpecialName = 0x0800,
+ NewSlot = 0x0100, Strict = 0x200, Abstract = 0x0400, SpecialName = 0x0800,
RTSpecialName = 0x1000, SpecialRTSpecialName = 0x1800,
HasSecurity = 0x4000, RequireSecObject = 0x8000}
protected bool done = false;
protected MDTable tabIx;
protected bool sortTable = false;
+ //Temporary hack..
+ private bool has_custom_attrs = false;
internal MetaDataElement() { }
}
}
+ public bool HasCustomAttr {
+ get { return has_custom_attrs; }
+ set { has_custom_attrs = value; }
+ }
+
internal virtual uint GetCodedIx(CIx code) { return 0; }
/// <summary>
public class CustomAttribute : MetaDataElement {
- private static readonly ushort prolog = 0x0001;
MetaDataElement parent;
Method type;
uint valIx;
internal sealed override void BuildTables(MetaData md)
{
+ md.AddToTable(MDTable.CustomAttribute, this);
+ if (byteVal == null) {
+ valIx = 0;
+ return;
+ }
+
BinaryWriter bw = new BinaryWriter(new MemoryStream());
bw.Write(byteVal);
- md.AddToTable(MDTable.CustomAttribute, this);
MemoryStream str = (MemoryStream)bw.BaseStream;
valIx = md.AddToBlobHeap(str.ToArray());
}
/// Descriptor for security permissions for a class or a method
/// </summary>
- public class DeclSecurity : MetaDataElement {
+ public abstract class BaseDeclSecurity : MetaDataElement {
ushort action;
MetaDataElement parent;
uint permissionIx;
- byte [] byteVal;
- internal DeclSecurity(MetaDataElement paren, ushort act, byte [] val)
+ internal BaseDeclSecurity(MetaDataElement paren, ushort act)
{
parent = paren;
action = act;
tabIx = MDTable.DeclSecurity;
- byteVal = val;
}
internal override uint SortKey()
internal sealed override void BuildTables(MetaData md)
{
if (done) return;
+
BinaryWriter bw = new BinaryWriter (new MemoryStream ());
- bw.Write (byteVal);
md.AddToTable (MDTable.DeclSecurity, this);
MemoryStream str = (MemoryStream)bw.BaseStream;
+ WriteSig (bw);
permissionIx = md.AddToBlobHeap(str.ToArray());
done = true;
}
+ internal abstract void WriteSig (BinaryWriter bw);
+
internal sealed override void Write(FileImage output)
{
output.Write(action);
}
+ public class DeclSecurity : BaseDeclSecurity {
+
+ byte [] byteVal;
+
+ internal DeclSecurity(MetaDataElement paren, ushort act, byte [] val)
+ : base (paren, act)
+ {
+ byteVal = val;
+ }
+
+ internal override void WriteSig (BinaryWriter bw)
+ {
+ bw.Write (byteVal);
+ }
+
+ }
+
+ public class DeclSecurity_20 : BaseDeclSecurity {
+
+ PermissionSet ps;
+
+ internal DeclSecurity_20 (MetaDataElement paren, ushort act, PermissionSet ps)
+ : base (paren, act)
+ {
+ this.ps = ps;
+ }
+
+ internal override void WriteSig (BinaryWriter bw)
+ {
+ ps.Write (bw);
+ }
+ }
+
+ public class PermissionMember {
+
+ MemberTypes member_type;
+ PEAPI.Type type;
+ string name;
+ object value;
+
+ public PermissionMember (MemberTypes member_type, PEAPI.Type type, string name, object value)
+ {
+ this.member_type = member_type;
+ this.type = type;
+ this.name = name;
+ this.value = value;
+ }
+
+ public void Write (BinaryWriter bw)
+ {
+ byte [] b;
+
+ if (member_type == MemberTypes.Field)
+ bw.Write ((byte) 0x53);
+ else
+ //Property
+ bw.Write ((byte) 0x54);
+
+ if (type is PrimitiveType) {
+ bw.Write (type.GetTypeIndex ());
+ } else {
+ //must be enum
+ bw.Write ((byte) 0x55); //ENUM
+
+ b = Encoding.UTF8.GetBytes (((ClassRef) type).TypeName ());
+ MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
+ bw.Write (b);
+ }
+
+ b = Encoding.UTF8.GetBytes (name);
+ MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
+ bw.Write (b);
+
+ ((Constant) value).Write (bw);
+ }
+
+ }
+
+ public class Permission
+ {
+ PEAPI.Type type;
+
+ //PermissionMembers
+ ArrayList members;
+ string name;
+
+ public Permission (PEAPI.Type type, string name)
+ {
+ this.type = type;
+ this.name = name;
+ }
+
+ public void AddMember (PEAPI.PermissionMember member)
+ {
+ if (members == null)
+ members = new ArrayList ();
+
+ members.Add (member);
+ }
+
+ public void Write (BinaryWriter bw)
+ {
+ byte [] b = Encoding.UTF8.GetBytes (name);
+ MetaData.CompressNum ((uint) b.Length, (MemoryStream) bw.BaseStream);
+ bw.Write (b);
+
+ BinaryWriter perm_writer = new BinaryWriter (new MemoryStream (), Encoding.Unicode);
+ MemoryStream str = (MemoryStream) perm_writer.BaseStream;
+
+ MetaData.CompressNum ((uint) members.Count, str);//number of params
+ foreach (PermissionMember member in members)
+ member.Write (perm_writer);
+
+ bw.Write ((byte) str.Length); //(optional) parameters length
+ bw.Write (str.ToArray ());
+ }
+ }
+
+ public class PermissionSet
+ {
+ PEAPI.SecurityAction sec_action;
+ ArrayList permissions;
+
+ public PermissionSet (PEAPI.SecurityAction sec_action)
+ {
+ this.sec_action = sec_action;
+ }
+
+ public void AddPermission (PEAPI.Permission perm)
+ {
+ if (permissions == null)
+ permissions = new ArrayList ();
+
+ permissions.Add (perm);
+ }
+
+ public void Write (BinaryWriter bw)
+ {
+ bw.Write ((byte) 0x2e);
+ MetaData.CompressNum ((uint) permissions.Count, (MemoryStream) bw.BaseStream);
+
+ foreach (Permission perm in permissions)
+ perm.Write (bw);
+ }
+
+ }
+
/**************************************************************************/
/// <summary>
/// Descriptor for layout information for a field
nameIx = md.AddToStringsHeap(mrName);
if (resourceBytes != null) {
if (rRef != null)
- throw new Exception("ERROR: Manifest Resource has byte value and file reference");
+ throw new PEFileException ("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");
+ throw new PEFileException ("Manifest Resource has no implementation or value");
rRef.BuildTables (md);
}
tabIx = MDTable.Param;
}
+ public bool HasMarshalInfo {
+ get { return marshalInfo != null; }
+ }
+
/// <summary>
/// Add a default value to this parameter
/// </summary>
///
public class ClassDef : Class {
- private static readonly byte ElementType_Class = 0x12;
-
Class superType;
ArrayList fields = new ArrayList();
ArrayList methods = new ArrayList();
ArrayList properties;
bool typeIndexChecked = true;
uint fieldIx = 0, methodIx = 0;
- byte[] securityActions;
uint flags;
ClassLayout layout;
ClassDef parentClass;
/// <param name="pars">parameters</param>
/// <returns>a descriptor for this new method</returns>
public MethodDef AddMethod(string name, Type retType, Param[] pars)
+ {
+ return AddMethod (name, new Param (ParamAttr.Default, "", retType), pars);
+ }
+
+ public MethodDef AddMethod (string name, Param ret_param, Param [] pars)
{
// Console.WriteLine("Adding method " + name + " to class " + this.name);
- MethodDef meth = new MethodDef(metaData,name,retType, pars);
+ MethodDef meth = new MethodDef(metaData,name, ret_param, pars);
methods.Add(meth);
return meth;
}
/// <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) {
+ Param ret_param, Param [] pars) {
// Console.WriteLine("Adding method " + name + " to class " + this.name);
- MethodDef meth = new MethodDef(metaData,mAtts,iAtts,name,retType,pars);
+ MethodDef meth = new MethodDef (metaData, mAtts, iAtts, name, ret_param, pars);
methods.Add(meth);
return meth;
}
public class ClassRef : Class, IExternRef, IResolutionScope {
protected IResolutionScope parent;
- ExternClass externClass;
protected MetaData metaData;
internal ClassRef(string nsName, string name, MetaData md) : base(nsName, name, md)
ExternClass externClass;
internal ExternClassRef(TypeAttr attrs, string nsName, string name,
- FileRef declFile, MetaData md) : base(nsName,name,md)
+ MetaDataElement declRef, MetaData md) : base(nsName,name,md)
{
- externClass = new ExternClass(attrs,nameSpaceIx,nameIx,declFile);
+ externClass = new ExternClass(attrs,nameSpaceIx,nameIx,declRef);
metaData.AddToTable(MDTable.ExportedType,externClass);
}
internal sealed override void TypeSig(MemoryStream str)
{
if (index < 0)
- throw new Exception (String.Format ("Unresolved {0} - {1}", (GenParamType) GetTypeIndex (), param_name));
+ throw new PEFileException (String.Format ("Unresolved {0} - {1}", (GenParamType) GetTypeIndex (), param_name));
str.WriteByte(typeIndex);
MetaData.CompressNum ((uint) index, str);
}
private void CompressSignedNum (int val, MemoryStream str)
{
uint uval = (uint) val;
- int sign = val < 0 ? 1 : 0;
- uint fval = (uint) ((uval << 1) | sign);
- int sval = (((val < 0 ? - val : val)) << 1) - sign;
-
- if (sval < 0x80)
+ byte sign = 0;
+ if (val < 0) {
+ val = -val;
+ sign = 1;
+ }
+
+ /* Map the signed number to an unsigned number in two ways.
+
+ fval: left-rotated 2's complement representation
+ sval: map the signed number to unsigned as follows: 0 -> 0, -1 -> 1, 1 -> 2, -2 -> 3, 2 -> 4, ....
+ the mapping is: x -> 2*|x| - signbit(x)
+ */
+ uint fval = (uval << 1) | sign;
+ int sval = (val << 1) - sign;
+
+ /* An overly clever transformation:
+
+ a. sval is used to determine the number of bytes in the compressed representation.
+ b. fval is truncated to the appropriate number of bits and output using the
+ normal unsigned-int compressor.
+
+ However, or certain values, the truncated fval doesn't carry enough information to round trip.
+
+ (fval & 0x3FFF) <= 0x7F => compressor emits 1 byte, not 2 => there is aliasing of values
+
+ So, we use full 4 bytes to encode such values.
+
+ LAMESPEC: The Microsoft implementation doesn't appear to handle this subtle case.
+ e.g., it ends up encoding -8192 as the byte 0x01, which decodes to -64
+ */
+ if (sval <= 0x7F)
MetaData.CompressNum (fval & 0x7F, str);
- else if (sval < 0x4000 && (fval & 0x3fff) >= 0x80)
- /* If (fval & 0x3fff) < 0x80, then
- encode with full 4 bytes */
+ else if (sval <= 0x3FFF && (fval & 0x3FFF) > 0x7F)
MetaData.CompressNum (fval & 0x3FFF, str);
+ else if (sval <= 0x1FFFFFFF && (fval & 0x1FFFFFFF) > 0x3FFF)
+ MetaData.CompressNum (fval & 0x1FFFFFFF, str);
else
- MetaData.CompressNum ((uint) (fval & 0x1FFFFFFF), str);
+ /* FIXME: number cannot be represented. Report a warning. */
+ // throw new Exception ("cannot represent signed value" + -val);
+ MetaData.CompressNum (fval, str);
}
-
}
#endregion
/// <summary>
/// Descriptor for THIS module
/// </summary>
- public class Module : ResolutionScope {
+ public class Module : ResolutionScope, IExternRef {
Guid mvid;
uint mvidIx = 0;
get { return mvid; }
}
+ public ClassRef AddClass(string nsName, string name)
+ {
+ ClassRef aClass = new ClassRef (nsName, name, metaData);
+ metaData.AddToTable (MDTable.TypeRef, aClass);
+ aClass.SetParent (this);
+ return aClass;
+ }
+
+ public ClassRef AddValueClass(string nsName, string name)
+ {
+ ClassRef aClass = AddClass (nsName, name);
+ aClass.MakeValueClass (ValueClass.ValueType);
+ return aClass;
+ }
+
internal sealed override uint Size(MetaData md)
{
return 2 + md.StringsIndexSize() + 3 * md.GUIDIndexSize();
// private static readonly byte LocalSigByte = 0x7;
uint parIx = 0, textOffset = 0;
private CallConv callConv = CallConv.Default;
- private Type retType;
private int gen_param_count;
MetaData metaData;
CILInstructions code;
- ArrayList securityActions = new ArrayList();
Param[] parList;
Local[] locals;
bool initLocals;
ImplMap pinvokeImpl;
Param ret_param;
-
- internal MethodDef(MetaData md, string name, Type retType, Param[] pars) : base (name)
+ internal MethodDef (MetaData md, string name, Param ret_param, Param [] pars)
+ : this (md, 0, 0, name, ret_param, pars)
{
- this.retType = 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) : this (md, name, retType, pars)
+ Param ret_param, Param [] pars)
+ : base (name)
{
methFlags = (ushort)mAttrSet;
implFlags = (ushort)iAttrSet;
+ this.ret_param = ret_param;
+ metaData = md;
+ parList = pars;
+ if (parList != null)
+ numPars = parList.Length;
+ tabIx = MDTable.Method;
}
internal Param[] GetPars()
/* Add Marshal info for return type */
public void AddRetTypeMarshallInfo (NativeType marshallType)
{
- ret_param = new Param (ParamAttr.HasFieldMarshal, "", retType);
ret_param.AddMarshallInfo (marshallType);
}
for (int i=0; i < numPars; i++) {
pars[i] = parList[i].GetParType();
}
- varArgSig = new MethodRef(this,name,retType,pars,true,optPars, 0);
+ varArgSig = new MethodRef (this, name, ret_param.GetParType (), pars, true, optPars, 0);
if (varArgSigList == null)
varArgSigList = new ArrayList ();
if ((callConv & CallConv.Generic) == CallConv.Generic)
MetaData.CompressNum ((uint) gen_param_count, sig);
MetaData.CompressNum((uint)numPars,sig);
- if (ret_param != null)
- ret_param.seqNo = 0;
- retType.TypeSig(sig);
+
+ ret_param.seqNo = 0;
+ ret_param.TypeSig (sig);
for (ushort i=0; i < numPars; i++) {
parList[i].seqNo = (ushort)(i+1);
parList[i].TypeSig(sig);
nameIx = md.AddToStringsHeap(name);
sigIx = GetSigIx(md);
parIx = md.TableIndex(MDTable.Param);
- if (ret_param != null) {
+ if (ret_param.HasMarshalInfo || ret_param.HasCustomAttr) {
md.AddToTable(MDTable.Param, ret_param);
ret_param.BuildTables(md);
}
public static readonly NativeType VariantBool = new NativeType(0x25);
public static readonly NativeType FuncPtr = new NativeType(0x26);
public static readonly NativeType AsAny = new NativeType(0x28);
+ public static readonly NativeType LPStruct = new NativeType(0x2b);
+ public static readonly NativeType Error = new NativeType(0x2d);
protected byte typeIndex;
public class FixedArray : NativeType {
- NativeType elemType;
uint numElem;
//public FixedArray(NativeType elemType, int numElems) : base(0x1E) {
tabIx = MDTable.AssemblyRef;
}
+ public void AddAssemblyAttr (AssemAttr aa)
+ {
+ flags |= (uint)aa;
+ }
+
/// <summary>
/// Add version information about this external assembly
/// </summary>
private readonly string systemName = "System";
private Class[] systemClasses = new Class[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(),
private static readonly uint max3BitSmlIx = 0x1FFF;
private static readonly uint max5BitSmlIx = 0x7FF;
// NOTE: version and stream name strings MUST always be quad padded
-#if NET_2_0 || BOOTSTRAP_NET_2_0
+#if NET_4_0
+ private static readonly string version = "v4.0.30319\0\0";
+#elif NET_2_0
private static readonly string version = "v2.0.50727\0\0";
#else
private static readonly string version = "v1.1.4322\0\0\0";
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;
cattr_list.Add (cattr);
}
- internal void AddDeclSecurity (DeclSecurity decl_sec)
+ internal void AddDeclSecurity (BaseDeclSecurity decl_sec)
{
if (declsec_list == null)
declsec_list = new ArrayList ();
internal void WriteTildeStream(FileImage output)
{
- long startTilde = output.Seek(0,SeekOrigin.Current);
+ output.Seek(0,SeekOrigin.Current);
output.Write((uint)0); // Reserved
-#if NET_2_0 || BOOTSTRAP_NET_2_0
+#if NET_2_0
output.Write((byte)2); // MajorVersion
output.Write((byte)0); // MinorVersion
#else
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);
+
+ output.Seek(0,SeekOrigin.Current);
// Console.WriteLine("Starting metaData tables at " + tabStart);
for (int i=0; i < numMetaDataTables; i++) {
if (metaDataTables[i] != null) {
BuildTable(metaDataTables[(int)MDTable.TypeDef]);
BuildTable(metaDataTables[(int)MDTable.TypeSpec]);
BuildTable(metaDataTables[(int)MDTable.MemberRef]);
-#if NET_2_0 || BOOTSTRAP_NET_2_0
+#if NET_2_0
BuildTable(metaDataTables[(int)MDTable.GenericParam]);
BuildTable(metaDataTables[(int)MDTable.MethodSpec]);
BuildTable(metaDataTables[(int)MDTable.GenericParamConstraint]);
}
if (declsec_list != null) {
- foreach (DeclSecurity decl_sec in declsec_list)
+ foreach (BaseDeclSecurity decl_sec in declsec_list)
decl_sec.BuildTables (this);
}
SortTable(metaDataTables[(int)MDTable.DeclSecurity]);
SortTable(metaDataTables[(int)MDTable.MethodSemantics]);
SortTable(metaDataTables[(int)MDTable.ImplMap]);
-#if NET_2_0 || BOOTSTRAP_NET_2_0
+#if NET_2_0
if (metaDataTables[(int)MDTable.GenericParam] != null) {
SortTable(metaDataTables[(int)MDTable.GenericParam]);
// Now add GenericParamConstraints
projects / mono.git / blobdiff