public IRParameter Clone(IRMethod newMethod)
{
IRParameter p = new IRParameter(this.Assembly);
p.ParentMethod = newMethod;
p.mParentParameter = this.mType == null ? this : null;
p.Type = this.mType;
return p;
}
internal void LoadStage1()
{
Console.WriteLine("========== Stage 1: {0,-45} ==========", File.ReferenceName);
Types = new List<IRType>(File.TypeDefTable.Length);
Fields = new List<IRField>(File.FieldTable.Length);
Methods = new List<IRMethod>(File.MethodDefTable.Length);
foreach (TypeDefData typeDefData in File.TypeDefTable) Types.Add(new IRType(this));
foreach (FieldData fieldData in File.FieldTable) Fields.Add(new IRField(this));
foreach (MethodDefData methodDefData in File.MethodDefTable)
{
IRMethod method = new IRMethod(this);
Methods.Add(method);
var mGenParams = new List<GenericParamData>(methodDefData.GenericParamList);
for (int i = 0; i < mGenParams.Count; i++)
{
method.GenericParameters.Add(IRType.GetMVarPlaceholder(mGenParams[i].Number));
}
}
for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex)
{
IRType type = Types[typeIndex];
TypeDefData typeDefData = File.TypeDefTable[typeIndex];
type.Namespace = typeDefData.TypeNamespace;
type.Name = typeDefData.TypeName;
type.Flags = typeDefData.Flags;
var genParams = new List<GenericParamData>(typeDefData.GenericParamList);
for (int i = 0; i < genParams.Count; i++)
{
type.GenericParameters.Add(IRType.GetVarPlaceholder(genParams[i].Number));
}
foreach (FieldData fieldData in typeDefData.FieldList)
{
IRField field = Fields[fieldData.TableIndex];
field.Name = fieldData.Name;
field.Flags = fieldData.Flags;
field.ParentType = type;
type.Fields.Add(field);
}
foreach (MethodDefData methodDefData in typeDefData.MethodList)
{
IRMethod method = Methods[methodDefData.TableIndex];
method.Name = methodDefData.Name;
method.Flags = methodDefData.Flags;
method.ImplFlags = methodDefData.ImplFlags;
method.ParentType = type;
type.Methods.Add(method);
foreach (ParamData paramData in methodDefData.ParamList)
{
IRParameter parameter = new IRParameter(this);
parameter.ParentMethod = method;
method.Parameters.Add(parameter);
}
if (methodDefData.Body != null && methodDefData.Body.ExpandedLocalVarSignature != null)
{
method.MaximumStackDepth = methodDefData.Body.MaxStack;
foreach (SigLocalVar sigLocalVar in methodDefData.Body.ExpandedLocalVarSignature.LocalVars)
{
IRLocal local = new IRLocal(this);
local.ParentMethod = method;
local.Index = method.Locals.Count;
method.Locals.Add(local);
}
}
}
}
for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex)
{
IRType type = Types[typeIndex];
TypeDefData typeDefData = File.TypeDefTable[typeIndex];
foreach (TypeDefData nestedTypeDefData in typeDefData.NestedClassList)
{
IRType nestedType = Types[nestedTypeDefData.TableIndex];
//nestedType.Namespace = type.Namespace + "." + type.Name;
nestedType.NestedInsideOfType = type;
type.NestedTypes.Add(nestedType);
}
}
if (CORLibrary) AppDomain.CacheCOR(this);
else if (RuntimeLibrary) AppDomain.CacheRuntime(this);
}
internal void LoadStage2()
{
Console.WriteLine("========== Stage 2: {0,-45} ==========", File.ReferenceName);
for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex)
{
IRType type = Types[typeIndex];
TypeDefData typeDefData = File.TypeDefTable[typeIndex];
if (typeDefData.Extends.Type != TypeDefRefOrSpecIndex.TypeDefRefOrSpecType.TypeDef || typeDefData.Extends.TypeDef != null) type.BaseType = AppDomain.PresolveType(typeDefData.Extends);
for (int fieldIndex = 0; fieldIndex < type.Fields.Count; ++fieldIndex)
{
IRField field = type.Fields[fieldIndex];
field.Type = AppDomain.PresolveType(typeDefData.FieldList[fieldIndex].ExpandedSignature);
if (field.Type == null) throw new Exception();
}
for (int interfaceIndex = 0; interfaceIndex < typeDefData.InterfaceList.Count; ++interfaceIndex)
{
type.ImplementedInterfaces.Add(AppDomain.PresolveType(typeDefData.InterfaceList[interfaceIndex]));
}
}
for (int fieldIndex = 0; fieldIndex < Fields.Count; ++fieldIndex)
{
IRField field = Fields[fieldIndex];
FieldData fieldData = File.FieldTable[fieldIndex];
if (field.IsLiteral)
{
if (fieldData.Constant == null) throw new Exception();
field.LiteralType = fieldData.Constant.Type;
field.LiteralValue = fieldData.Constant.Value;
}
}
for (int layoutIndex = 0; layoutIndex < File.ClassLayoutTable.Length; ++layoutIndex)
{
ClassLayoutData classLayoutData = File.ClassLayoutTable[layoutIndex];
IRType type = Types[classLayoutData.Parent.TableIndex];
type.ClassSize = (int)classLayoutData.ClassSize;
type.PackingSize = (int)classLayoutData.PackingSize;
}
for (int i = 0; i < File.FieldLayoutTable.Length; i++)
{
FieldLayoutData fieldLayoutData = File.FieldLayoutTable[i];
IRField field = Fields[fieldLayoutData.Field.TableIndex];
field.Offset = (int)fieldLayoutData.Offset;
}
for (int methodIndex = 0; methodIndex < Methods.Count; ++methodIndex)
{
IRMethod method = Methods[methodIndex];
MethodDefData methodDefData = File.MethodDefTable[methodIndex];
method.ReturnType = AppDomain.PresolveType(methodDefData.ExpandedSignature.RetType);
int missingFromSig = 0;
for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; ++parameterIndex)
{
IRParameter parameter = method.Parameters[parameterIndex];
if ((methodDefData.ParamList[parameterIndex].Flags & ParamAttributes.HasFieldMarshal) == ParamAttributes.HasFieldMarshal)
{
++missingFromSig;
parameter.Type = AppDomain.System_IntPtr;
}
else
parameter.Type = AppDomain.PresolveType(methodDefData.ExpandedSignature.Params[parameterIndex - missingFromSig]);
}
for (int localIndex = 0; localIndex < method.Locals.Count; ++localIndex)
{
IRLocal local = method.Locals[localIndex];
local.Type = AppDomain.PresolveType(methodDefData.Body.ExpandedLocalVarSignature.LocalVars[localIndex]);
}
}
for (int methodIndex = 0; methodIndex < Methods.Count; ++methodIndex)
{
IRMethod method = Methods[methodIndex];
MethodDefData methodDefData = File.MethodDefTable[methodIndex];
if (methodDefData.ExpandedSignature.HasThis && !methodDefData.ExpandedSignature.ExplicitThis)
{
IRParameter implicitThis = new IRParameter(this);
implicitThis.ParentMethod = method;
implicitThis.Type = method.ParentType.IsValueType ? AppDomain.GetUnmanagedPointerType(method.ParentType) : method.ParentType;
method.Parameters.Insert(0, implicitThis);
}
}
for (int typeIndex = 0; typeIndex < Types.Count; ++typeIndex)
{
IRType type = Types[typeIndex];
TypeDefData typeDefData = File.TypeDefTable[typeIndex];
foreach (MethodImplData methodImpl in typeDefData.MethodImplList)
{
type.ExplicitOverrides.Add(new IRType.OverrideDescriptor(AppDomain.PresolveMethod(methodImpl.MethodDeclaration), AppDomain.PresolveMethod(methodImpl.MethodBody)));
}
}
}