/// <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);