/// <summary>
/// Splits up <see cref="TypeParameters"/> into type and method generic arguments
/// </summary>
/// <param name="typeGenArgs">Gets updated with a list containing all generic type arguments</param>
/// <param name="methGenArgs">Gets updated with a list containing all generic method arguments</param>
/// <returns></returns>
public bool GetTypeAndMethodGenericParameters(out CorType[] typeGenArgs, out CorType[] methGenArgs)
{
var func = Function;
var module = func?.Module;
if (module == null)
{
typeGenArgs = Array.Empty <CorType>();
methGenArgs = Array.Empty <CorType>();
return(false);
}
var mdi = module.GetMetaDataInterface <IMetaDataImport>();
var gas = new List <CorType>(TypeParameters);
var cls = func.Class;
int typeGenArgsCount = cls == null ? 0 : MetaDataUtils.GetCountGenericParameters(mdi, cls.Token);
int methGenArgsCount = MetaDataUtils.GetCountGenericParameters(mdi, func.Token);
Debug.Assert(typeGenArgsCount + methGenArgsCount == gas.Count);
typeGenArgs = new CorType[typeGenArgsCount];
methGenArgs = new CorType[methGenArgsCount];
int j = 0;
for (int i = 0; j < gas.Count && i < typeGenArgs.Length; i++, j++)
{
typeGenArgs[i] = gas[j];
}
for (int i = 0; j < gas.Count && i < methGenArgs.Length; i++, j++)
{
methGenArgs[i] = gas[j];
}
return(true);
}
TypeSig GetThisType(CorFunction func)
{
if (func == null)
{
return(null);
}
var funcClass = func.Class;
var mod = funcClass == null ? null : funcClass.Module;
var mdi = mod == null ? null : mod.GetMetaDataInterface <IMetaDataImport>();
if (mdi == null)
{
return(null);
}
int numTypeGenArgs = MetaDataUtils.GetCountGenericParameters(mdi, funcClass.Token);
var genTypeArgs = this.TypeParameters.Take(numTypeGenArgs).ToArray();
var td = DebugSignatureReader.CreateTypeDef(mdi, funcClass.Token);
// Assume it's a class for now. The code should ignore ClassSig and just use the TypeDef
var sig = new ClassSig(td);
if (genTypeArgs.Length == 0)
{
return(sig);
}
var genArgs = new List <TypeSig>(genTypeArgs.Length);
for (int i = 0; i < genTypeArgs.Length; i++)
{
genArgs.Add(new GenericVar(i));
}
return(new GenericInstSig(sig, genArgs));
}
public static bool IsSystemNullable(this GenericInstSig gis)
{
if (gis == null)
{
return(false);
}
if (gis.GenericArguments.Count != 1)
{
return(false);
}
var type = gis.GenericType as ValueTypeSig;
if (type == null)
{
return(false);
}
var mdip = type.TypeDefOrRef as IMetaDataImportProvider;
if (mdip == null)
{
return(false);
}
return(MetaDataUtils.IsSystemNullable(mdip.MetaDataImport, mdip.MDToken.Raw));
}
/// <summary>
/// Gets method parameters and method flags
/// </summary>
/// <param name="methodAttrs">Method attributes</param>
/// <param name="methodImplAttrs">Method implementation attributes</param>
/// <returns></returns>
public MDParameters GetMDParameters(out MethodAttributes methodAttrs, out MethodImplAttributes methodImplAttrs)
{
methodAttrs = 0;
methodImplAttrs = 0;
var mod = Module;
if (mod == null)
{
return(null);
}
var mdi = mod.GetMetaDataInterface <IMetaDataImport>();
if (mdi == null)
{
return(null);
}
if (!MDAPI.GetMethodAttributes(mdi, Token, out methodAttrs, out methodImplAttrs))
{
return(null);
}
var name = MDAPI.GetMethodName(mdi, Token);
if (name == null)
{
return(null);
}
return(MetaDataUtils.GetParameters(mdi, Token));
}
/// <summary>
/// Returns true if an attribute is present
/// </summary>
/// <param name="attributeName">Full name of attribute type</param>
/// <returns></returns>
public bool HasAttribute(string attributeName)
{
var mod = Module;
var mdi = mod == null ? null : mod.GetMetaDataInterface <IMetaDataImport>();
return(MetaDataUtils.HasAttribute(mdi, Token, attributeName));
}
public PropertySig GetPropertySig()
{
var mod = Module;
var mdi = mod == null ? null : mod.GetMetaDataInterface <IMetaDataImport>();
return(MetaDataUtils.ReadPropertySig(mdi, Token));
}
public static bool GetSystemNullableFields(this CorType type, out TokenAndName hasValueInfo, out TokenAndName valueInfo)
{
hasValueInfo = new TokenAndName();
valueInfo = new TokenAndName();
if (type == null || !type.IsSystemNullable)
{
return(false);
}
var cls = type.Class;
var mdi = cls?.Module?.GetMetaDataInterface <IMetaDataImport>();
var fields = MetaDataUtils.GetFields(mdi, cls?.Token ?? 0);
if (fields.Count != 2)
{
return(false);
}
if (fields[0].Name != "hasValue")
{
return(false);
}
if (fields[1].Name != "value")
{
return(false);
}
hasValueInfo = fields[0];
valueInfo = fields[1];
return(true);
}
public MethodSig GetMethodSig()
{
var mod = Module;
var mdi = mod == null ? null : mod.GetMetaDataInterface <IMetaDataImport>();
if (mdi == null)
{
return(null);
}
return(MetaDataUtils.GetMethodSignature(mdi, Token));
}
bool OnLoadModule(BreakpointConditionContext context)
{
var ctx = (DebugEventBreakpointConditionContext)context;
var lmArgs = (LoadModuleDebugCallbackEventArgs)ctx.EventArgs;
var mod = lmArgs.CorModule;
if (!IsOurModule(mod))
{
return(false);
}
debugger.RemoveBreakpoint(breakpoint);
breakpoint = null;
var serMod = mod.SerializedDnModule;
if (type == BreakProcessType.ModuleCctorOrEntryPoint)
{
uint cctorToken = MetaDataUtils.GetGlobalStaticConstructor(mod.GetMetaDataInterface <IMetaDataImport>());
if (cctorToken != 0)
{
SetILBreakpoint(serMod, cctorToken);
return(false);
}
}
string otherModuleName;
uint epToken = GetEntryPointToken(filename, out otherModuleName);
if (epToken != 0)
{
if ((Table)(epToken >> 24) == Table.Method)
{
SetILBreakpoint(serMod, epToken);
return(false);
}
if (otherModuleName != null)
{
Debug.Assert((Table)(epToken >> 24) == Table.File);
otherModuleFullName = GetOtherModuleFullName(otherModuleName);
if (otherModuleFullName != null)
{
thisAssembly = mod.Assembly;
breakpoint = debugger.CreateBreakpoint(DebugEventBreakpointType.LoadModule, OnLoadOtherModule);
return(false);
}
}
}
// Failed to set BP. Break to debugger.
return(true);
}
bool OnLoadModule(DebugEventBreakpointConditionContext ctx)
{
var lmArgs = (LoadModuleDebugCallbackEventArgs)ctx.EventArgs;
var mod = lmArgs.CorModule;
if (!IsOurModule(mod))
{
return(false);
}
debugger.RemoveBreakpoint(breakpoint);
breakpoint = null;
Debug.Assert(!mod.IsDynamic && !mod.IsInMemory);
// It's not a dyn/in-mem module so id isn't used
var moduleId = mod.GetModuleId(uint.MaxValue);
if (type == BreakProcessKind.ModuleCctorOrEntryPoint)
{
uint cctorToken = MetaDataUtils.GetGlobalStaticConstructor(mod.GetMetaDataInterface <IMetaDataImport>());
if (cctorToken != 0)
{
SetILBreakpoint(moduleId, cctorToken);
return(false);
}
}
uint epToken = GetEntryPointToken(filename, out string otherModuleName);
if (epToken != 0)
{
if ((Table)(epToken >> 24) == Table.Method)
{
SetILBreakpoint(moduleId, epToken);
return(false);
}
if (otherModuleName != null)
{
Debug.Assert((Table)(epToken >> 24) == Table.File);
otherModuleFullName = GetOtherModuleFullName(otherModuleName);
if (otherModuleFullName != null)
{
thisAssembly = mod.Assembly;
breakpoint = debugger.CreateBreakpoint(DebugEventBreakpointKind.LoadModule, OnLoadOtherModule);
return(false);
}
}
}
// Failed to set BP. Break to debugger.
return(true);
}
/// <summary>
/// Gets all argument and local types
/// </summary>
/// <param name="argTypes">Gets updated with all argument types. If there's a hidden this
/// parameter, it's the first type. This type can be null. If it's not null, ignore any
/// <see cref="ClassSig"/> since it might still be a value type</param>
/// <param name="localTypes">Gets updated with all local types</param>
/// <returns></returns>
public bool GetArgAndLocalTypes(out List <TypeSig> argTypes, out List <TypeSig> localTypes)
{
argTypes = new List <TypeSig>();
localTypes = new List <TypeSig>();
var func = Function;
if (func == null)
{
return(false);
}
var module = func.Module;
if (module == null)
{
return(false);
}
var mdi = module.GetMetaDataInterface <IMetaDataImport>();
var methodSig = MetaDataUtils.GetMethodSignature(mdi, func.Token);
if (methodSig != null)
{
if (methodSig.HasThis)
{
argTypes.Add(GetThisType(func));
}
argTypes.AddRange(methodSig.Params);
if (methodSig.ParamsAfterSentinel != null)
{
argTypes.AddRange(methodSig.ParamsAfterSentinel);
}
}
uint localVarSigTok = func.LocalVarSigToken;
if ((localVarSigTok & 0x00FFFFFF) != 0)
{
var localSig = MetaDataUtils.ReadCallingConventionSig(mdi, localVarSigTok) as LocalSig;
if (localSig != null)
{
localTypes.AddRange(localSig.Locals);
}
}
return(true);
}
/// <summary>
/// Returns true if it's a System.XXX type in the corlib (eg. mscorlib)
/// </summary>
/// <param name="name">Name (not including namespace)</param>
/// <returns></returns>
public bool IsSystem(string name)
{
var mod = Module;
if (mod == null)
{
return(false);
}
var names = MetaDataUtils.GetTypeDefFullNames(mod.GetMetaDataInterface <IMetaDataImport>(), Token);
if (names.Count != 1)
{
return(false);
}
if (names[0].Name != "System." + name)
{
return(false);
}
//TODO: Check if it's mscorlib
return(true);
}
public string ToReflectionString()
{
var list = MetaDataUtils.GetTypeDefFullNames(Module.GetMetaDataInterface <IMetaDataImport>(), token);
if (list.Count == 0)
{
return("???");
}
if (list.Count == 1)
{
return(list[0].Name);
}
var sb = new StringBuilder();
for (int i = 0; i < list.Count; i++)
{
if (i > 0)
{
sb.Append('+');
}
sb.Append(list[i].Name);
}
return(sb.ToString());
}
/// <summary>
/// Same as <see cref="ElementType"/> except that it tries to return a primitive element
/// type (eg. <see cref="CorElementType.U4"/>) if it's a primitive type.
/// </summary>
public CorElementType TryGetPrimitiveType()
{
var etype = ElementType;
if (etype != CorElementType.Class && etype != CorElementType.ValueType)
{
return(etype);
}
uint token;
var mdi = GetMetaDataImport(out token);
var list = MetaDataUtils.GetTypeDefFullNames(mdi, token);
if (list.Count != 1)
{
return(etype);
}
if (DerivesFromSystemValueType)
{
switch (list[0].Name)
{
case "System.Boolean": return(CorElementType.Boolean);
case "System.Byte": return(CorElementType.U1);
case "System.Char": return(CorElementType.Char);
case "System.Double": return(CorElementType.R8);
case "System.Int16": return(CorElementType.I2);
case "System.Int32": return(CorElementType.I4);
case "System.Int64": return(CorElementType.I8);
case "System.IntPtr": return(CorElementType.I);
case "System.SByte": return(CorElementType.I1);
case "System.Single": return(CorElementType.R4);
case "System.TypedReference": return(CorElementType.TypedByRef);
case "System.UInt16": return(CorElementType.U2);
case "System.UInt32": return(CorElementType.U4);
case "System.UInt64": return(CorElementType.U8);
case "System.UIntPtr": return(CorElementType.U);
case "System.Void": return(CorElementType.Void);
}
}
else
{
switch (list[0].Name)
{
case "System.Object":
if (Base == null)
{
return(CorElementType.Object);
}
break;
case "System.String":
var b = Base;
if (b != null && b.IsSystemObject)
{
return(CorElementType.String);
}
break;
}
}
return(etype);
}
public FieldSig GetFieldSig() => MetaDataUtils.ReadFieldSig(Module?.GetMetaDataInterface <IMetaDataImport>(), Token);
/// <summary> /// Gets type generic parameters /// </summary> /// <returns></returns> public List <TokenAndName> GetGenericParameters() => MetaDataUtils.GetGenericParameterNames(Module?.GetMetaDataInterface <IMetaDataImport>(), Token);
/// <summary>
/// Gets the ToString() method or null if there was an error
/// </summary>
/// <returns></returns>
public CorMethodInfo GetToStringMethod()
{
return(MetaDataUtils.GetToStringMethod(this));
}
/// <summary>
/// Gets all properties
/// </summary>
/// <param name="checkBaseClasses">true to check base classes</param>
/// <returns></returns>
public IEnumerable <CorPropertyInfo> GetProperties(bool checkBaseClasses = true)
{
return(MetaDataUtils.GetProperties(this, checkBaseClasses));
}
/// <summary>
/// Gets all fields
/// </summary>
/// <param name="checkBaseClasses">true to check base classes</param>
/// <returns></returns>
public IEnumerable <CorFieldInfo> GetFields(bool checkBaseClasses = true)
{
return(MetaDataUtils.GetFieldInfos(this, checkBaseClasses));
}
public PropertySig GetPropertySig() => MetaDataUtils.ReadPropertySig(Module?.GetMetaDataInterface <IMetaDataImport>(), Token);
/// <summary>
/// Gets method generic parameters
/// </summary>
/// <returns></returns>
public List <TokenAndName> GetGenericParameters()
{
var module = Module;
return(MetaDataUtils.GetGenericParameterNames(module == null ? null : module.GetMetaDataInterface <IMetaDataImport>(), Token));
}
/// <summary> /// Gets the ToString() method or null if there was an error /// </summary> /// <returns></returns> public CorMethodInfo GetToStringMethod() => MetaDataUtils.GetToStringMethod(this);
public MethodSig GetMethodSig() => MetaDataUtils.GetMethodSignature(Module?.GetMetaDataInterface <IMetaDataImport>(), Token);
