public void NewParameterizedObject(CorFunction managedFunction, CorType[] argumentTypes, CorValue[] arguments) { ICorDebugType[] types = null; int typesLength = 0; ICorDebugValue[] values = null; int valuesLength = 0; ICorDebugEval2 eval2 = (ICorDebugEval2)m_eval; if (argumentTypes != null) { types = new ICorDebugType[argumentTypes.Length]; for (int i = 0; i < argumentTypes.Length; i++) { types[i] = argumentTypes[i].m_type; } typesLength = types.Length; } if (arguments != null) { values = new ICorDebugValue[arguments.Length]; for (int i = 0; i < arguments.Length; i++) { values[i] = arguments[i].m_val; } valuesLength = values.Length; } eval2.NewParameterizedObject(managedFunction.m_function, (uint)typesLength, types, (uint)valuesLength, values); }
internal Value(AppDomain appDomain, ICorDebugValue corValue) { if (corValue == null) { throw new ArgumentNullException("corValue"); } this.appDomain = appDomain; this.corValue = corValue; this.corValue_pauseSession = this.Process.PauseSession; this.isNull = corValue is ICorDebugReferenceValue && ((ICorDebugReferenceValue)corValue).IsNull() != 0; if (corValue is ICorDebugReferenceValue && ((ICorDebugReferenceValue)corValue).GetValue() == 0 && ((ICorDebugValue2)corValue).GetExactType() == null) { // We were passed null reference and no metadata description // (happens during CreateThread callback for the thread object) this.type = appDomain.ObjectType; } else { ICorDebugType exactType = ((ICorDebugValue2)this.CorValue).GetExactType(); this.type = appDomain.Compilation.Import(exactType); } }
internal Value(Process process, Expression expression, ICorDebugValue corValue) { if (corValue == null) { throw new ArgumentNullException("corValue"); } this.process = process; this.expression = expression; this.corValue = corValue; this.corValue_pauseSession = process.PauseSession; if (corValue.Is <ICorDebugReferenceValue>() && corValue.CastTo <ICorDebugReferenceValue>().Value == 0 && corValue.CastTo <ICorDebugValue2>().ExactType == null) { // We were passed null reference and no metadata description // (happens during CreateThread callback for the thread object) this.type = DebugType.Create(this.Process, null, "System.Object"); } else { ICorDebugType exactType = this.CorValue.CastTo <ICorDebugValue2>().ExactType; this.type = DebugType.Create(this.Process, exactType); } }
public void CallParameterizedFunction (CorFunction managedFunction, CorType[] argumentTypes, CorValue[] arguments) { ICorDebugType[] types = null; int typesLength = 0; ICorDebugValue[] values = null; int valuesLength = 0; ICorDebugEval2 eval2 = (ICorDebugEval2) m_eval; if (argumentTypes != null) { types = new ICorDebugType[argumentTypes.Length]; for (int i = 0; i < argumentTypes.Length; i++) types[i] = argumentTypes[i].m_type; typesLength = types.Length; } if (arguments != null) { values = new ICorDebugValue[arguments.Length]; for (int i = 0; i < arguments.Length; i++) values[i] = arguments[i].m_val; valuesLength = values.Length; } eval2.CallParameterizedFunction(managedFunction.m_function, (uint)typesLength, types, (uint)valuesLength, values); }
DebugType(Process process, ICorDebugType corType) { if (corType == null) { throw new ArgumentNullException("corType"); } this.process = process; this.corType = corType; this.corElementType = (CorElementType)corType.Type; if (this.IsClass || this.IsValueType) { this.corClass = corType.Class; this.module = process.GetModule(corClass.Module); this.classProps = module.MetaData.GetTypeDefProps(corClass.Token); } if (this.IsClass || this.IsValueType || this.IsArray || this.IsPointer) { foreach (ICorDebugType t in corType.EnumerateTypeParameters().Enumerator) { typeArguments.Add(DebugType.Create(process, t)); } } this.fullName = GetFullName(); }
static public DebugType Create(Process process, ICorDebugClass corClass, params ICorDebugType[] typeArguments) { MetaData metaData = process.GetModule(corClass.Module).MetaData; bool isValueType = false; uint superClassToken = metaData.GetTypeDefProps(corClass.Token).SuperClassToken; if ((superClassToken & 0xFF000000) == 0x02000000) // TypeDef { if (metaData.GetTypeDefProps(superClassToken).Name == "System.ValueType") { isValueType = true; } } if ((superClassToken & 0xFF000000) == 0x01000000) // TypeRef { if (metaData.GetTypeRefProps(superClassToken).Name == "System.ValueType") { isValueType = true; } } int getArgsCount = metaData.GetGenericParamCount(corClass.Token); Array.Resize(ref typeArguments, getArgsCount); ICorDebugType corType = corClass.CastTo <ICorDebugClass2>().GetParameterizedType( isValueType ? (uint)CorElementType.VALUETYPE : (uint)CorElementType.CLASS, typeArguments ); return(Create(process, corType)); }
internal ICorDebugType GetDebugType() { var class2 = (ICorDebugClass2)_debugClass; ICorDebugType ppType; ICorDebugType[] typeArgs = new ICorDebugType[0]; class2.GetParameterizedType(CorElementType.ELEMENT_TYPE_CLASS, 0, typeArgs, out ppType); return ppType; }
/** Returns CorType object for an array of or pointer to the given type */ public CorType GetArrayOrPointerType(CorElementType elementType, int rank, CorType parameterTypes) { ICorDebugType ct = null; uint urank = (uint)rank; (_ad() as ICorDebugAppDomain2).GetArrayOrPointerType(elementType, urank, parameterTypes.m_type, out ct); return(ct == null?null:new CorType(ct)); }
int ICorDebugEval2.CreateValueForType(ICorDebugType pType, out ICorDebugValue ppValue) { CorElementType type; ICorDebugClass cls; pType.GetType(out type); pType.GetClass(out cls); return(((ICorDebugEval)this).CreateValue(type, cls, out ppValue)); }
int ICorDebugEval2.NewParameterizedArray(ICorDebugType pElementType, uint rank, ref uint dims, ref uint lowBounds) { CorElementType type; ICorDebugClass cls; pElementType.GetType(out type); pElementType.GetClass(out cls); return(((ICorDebugEval)this).NewArray(type, cls, rank, dims, lowBounds)); }
public ICorDebugType Next() { ICorDebugType[] corTypes = new ICorDebugType[1]; uint typesFetched = this.Next(1, corTypes); if (typesFetched == 0) { return null; } else { return corTypes[0]; } }
/// <summary> Obtains instance of DebugType. Same types will return identical instance. </summary> static public DebugType Create(Process process, ICorDebugType corType) { DateTime startTime = Util.HighPrecisionTimer.Now; DebugType type = new DebugType(process, corType); // Get types with matching names from cache List <DebugType> typesWithMatchingName; if (!loadedTypes.TryGetValue(type.FullName, out typesWithMatchingName)) { // No types with such name - create a new list typesWithMatchingName = new List <DebugType>(1); loadedTypes.Add(type.FullName, typesWithMatchingName); } // Try to find the type foreach (DebugType loadedType in typesWithMatchingName) { if (loadedType.Equals(type)) { TimeSpan totalTime = Util.HighPrecisionTimer.Now - startTime; if (process.Options.Verbose) { process.TraceMessage("Type " + type.FullName + " was loaded already (" + totalTime.TotalMilliseconds + " ms)"); } return(loadedType); // Type was loaded before } } // The type is not in the cache, finish loading it and add it to the cache if (type.IsClass || type.IsValueType) { type.LoadMemberInfo(); } typesWithMatchingName.Add(type); type.Process.Exited += delegate { typesWithMatchingName.Remove(type); }; TimeSpan totalTime2 = Util.HighPrecisionTimer.Now - startTime; string prefix = type.IsInterface ? "interface" : "type"; if (process.Options.Verbose) { process.TraceMessage("Loaded {0} {1} ({2} ms)", prefix, type.FullName, totalTime2.TotalMilliseconds); foreach (DebugType inter in type.Interfaces) { process.TraceMessage(" - Implements {0}", inter.FullName); } } return(type); }
public static Value NewObject(Process process, DebugType debugType) { ICorDebugType ppTypeArgs = null; ICorDebugValue ppArgs = null; Eval e = new Eval( process, "New object: " + debugType.Token, delegate(ICorDebugEval corEval) { corEval.CastTo <ICorDebugEval2>().NewParameterizedObject (debugType.GetDefaultConstructor(), (uint)debugType.GenericArguments.Count, ref ppTypeArgs, 0, ref ppArgs); } ); return(e.EvaluateNow()); }
// // IEnumerator interface // #region IEnumerator Members public bool MoveNext() { if (m_enum == null) return false; var a = new ICorDebugType[1]; uint c = 0; int r = m_enum.Next((uint) a.Length, a, out c); if (r == 0 && c == 1) // S_OK && we got 1 new element m_ty = new CorType(a[0]); else m_ty = null; return m_ty != null; }
// // IEnumerator interface // public bool MoveNext () { if( m_enum==null ) return false; ICorDebugType[] a = new ICorDebugType[1]; uint c = 0; int r = m_enum.Next ((uint) a.Length, a, out c); if (r==0 && c==1) // S_OK && we got 1 new element m_ty = new CorType (a[0]); else m_ty = null; return m_ty != null; }
public CorType GetParameterizedType(CorElementType elementType, CorType[] typeArguments) { ICorDebugType[] types = null; uint length = 0; if (typeArguments != null) { types = new ICorDebugType[typeArguments.Length]; for (int i = 0; i < typeArguments.Length; i++) types[i] = typeArguments[i].m_type; length = (uint)typeArguments.Length; } ICorDebugType pType; (m_class as ICorDebugClass2).GetParameterizedType(elementType, length, types, out pType); return pType==null?null:new CorType (pType); }
public CorType GetVirtualMethodAndType(int memberToken, out CorFunction managedFunction) { ICorDebugType dt = null; ICorDebugFunction pfunc = null; (m_objVal as ICorDebugObjectValue2).GetVirtualMethodAndType((uint)memberToken, out pfunc, out dt); if (pfunc == null) { managedFunction = null; } else { managedFunction = new CorFunction(pfunc); } return(dt == null ? null : new CorType(dt)); }
/** Returns CorType object for a pointer to a function */ public CorType GetFunctionPointerType(CorType[] parameterTypes) { ICorDebugType[] types = null; if (parameterTypes != null) { types = new ICorDebugType[parameterTypes.Length]; for (int i = 0; i < parameterTypes.Length; i++) { types[i] = parameterTypes[i].m_type; } } ICorDebugType ct = null; (_ad() as ICorDebugAppDomain2).GetFunctionPointerType((uint)types.Length, types, out ct); return(ct == null?null:new CorType(ct)); }
public void NewParameterizedObjectNoConstructor(CorClass managedClass, CorType[] argumentTypes) { ICorDebugType[] types = null; int typesLength = 0; ICorDebugEval2 eval2 = (ICorDebugEval2)m_eval; if (argumentTypes != null) { types = new ICorDebugType[argumentTypes.Length]; for (int i = 0; i < argumentTypes.Length; i++) { types[i] = argumentTypes[i].m_type; } typesLength = types.Length; } eval2.NewParameterizedObjectNoConstructor(managedClass.m_class, (uint)typesLength, types); }
public static Eval AsyncNewObjectNoConstructor(Thread evalThread, IType type) { ICorDebugType[] typeArgs = new ICorDebugType[0]; var genType = type as ParameterizedType; if (genType != null) { typeArgs = genType.TypeArguments.Select(t => t.ToCorDebug()).ToArray(); } return(new Eval( evalThread, "New object: " + type.FullName, delegate(Eval eval) { eval.CorEval2.NewParameterizedObjectNoConstructor(type.ToCorDebug().GetClass(), (uint)typeArgs.Length, typeArgs); } )); }
public CorType GetParameterizedType(CorElementType elementType, CorType[] typeArguments) { ICorDebugType[] types = null; uint length = 0; if (typeArguments != null) { types = new ICorDebugType[typeArguments.Length]; for (int i = 0; i < typeArguments.Length; i++) { types[i] = typeArguments[i].m_type; } length = (uint)typeArguments.Length; } ICorDebugType pType; (m_class as ICorDebugClass2).GetParameterizedType(elementType, length, types, out pType); return(pType == null ? null : new CorType(pType)); }
/// <summary> /// Get a method from a managed type, method name and argument count /// </summary> public static MethodInfo GetFromName(Process process, System.Type type, string name, int paramCount) { if (type.IsNested) { throw new DebuggerException("Not implemented for nested types"); } if (type.IsGenericType) { throw new DebuggerException("Not implemented for generic types"); } if (type.IsGenericParameter) { throw new DebuggerException("Type can not be generic parameter"); } foreach (Module module in process.Modules) { TypeDefProps typeDefProps; try { typeDefProps = module.MetaData.FindTypeDefByName(type.FullName, 0 /* enclosing class for nested */); } catch { continue; } foreach (MethodProps methodProps in module.MetaData.EnumMethodsWithName(typeDefProps.Token, name)) { if (module.MetaData.GetParamCount(methodProps.Token) == paramCount) { ICorDebugFunction corFunction = module.CorModule.GetFunctionFromToken(methodProps.Token); ICorDebugClass2 corClass = corFunction.Class.As <ICorDebugClass2>(); ICorDebugType corType = corClass.GetParameterizedType(type.IsValueType ? (uint)CorElementType.VALUETYPE : (uint)CorElementType.CLASS, 0, new ICorDebugType[] {}); return(new MethodInfo(DebugType.Create(process, corType), methodProps)); } } } throw new DebuggerException("Not found"); }
/// <summary> Obtains instance of DebugType. Same types will return identical instance. </summary> static internal DebugType Create(Process process, ICorDebugType corType) { DateTime startTime = Util.HighPrecisionTimer.Now; DebugType type = new DebugType(process, corType); // Get types with matching names from cache List <DebugType> typesWithMatchingName; if (!loadedTypes.TryGetValue(type.FullName, out typesWithMatchingName)) { // No types with such name - create a new list typesWithMatchingName = new List <DebugType>(1); loadedTypes.Add(type.FullName, typesWithMatchingName); } // Try to find the type foreach (DebugType loadedType in typesWithMatchingName) { if (loadedType.Equals(type)) { TimeSpan totalTime = Util.HighPrecisionTimer.Now - startTime; //process.TraceMessage("Type " + type.FullName + " was loaded already (" + totalTime.TotalMilliseconds + " ms)"); return(loadedType); // Type was loaded before } } // The type is not in the cache, finish loading it and add it to the cache if (type.IsClass || type.IsValueType || type.ManagedType == typeof(string)) { type.LoadMemberInfo(); } typesWithMatchingName.Add(type); type.Process.Expired += delegate { typesWithMatchingName.Remove(type); }; TimeSpan totalTime2 = Util.HighPrecisionTimer.Now - startTime; process.TraceMessage("Loaded type " + type.FullName + " (" + totalTime2.TotalMilliseconds + " ms)"); return(type); }
// // IEnumerator interface // #region IEnumerator Members public bool MoveNext() { if (m_enum == null) { return(false); } var a = new ICorDebugType[1]; uint c = 0; int r = m_enum.Next((uint)a.Length, a, out c); if (r == 0 && c == 1) // S_OK && we got 1 new element { m_ty = new CorType(a[0]); } else { m_ty = null; } return(m_ty != null); }
public static void GetVirtualMethodAndType(this ICorDebugObjectValue2 instance, uint memberRef, out ICorDebugFunction ppFunction, out ICorDebugType ppType) { instance.__GetVirtualMethodAndType(memberRef, out ppFunction, out ppType); }
int ICorDebugType.GetBase (out ICorDebugType pBase) { pBase = null; return Utility.COM_HResults.E_NOTIMPL; }
public static ICorDebugType GetParameterizedType(this ICorDebugClass2 instance, uint elementType, uint nTypeArgs, ICorDebugType[] ppTypeArgs) { ICorDebugType ppType; instance.__GetParameterizedType(elementType, nTypeArgs, ppTypeArgs, out ppType); return ppType; }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { ppType = new CorDebugTypeArray(this); return(COM_HResults.S_OK); }
public static ICorDebugValue CreateValueForType(this ICorDebugEval2 instance, ICorDebugType pType) { ICorDebugValue ppValue; instance.__CreateValueForType(pType, out ppValue); return ppValue; }
public void NewParameterizedObjectNoConstructor(CorClass managedClass, CorType[] argumentTypes) { ICorDebugType[] types = null; int typesLength=0; ICorDebugEval2 eval2 = (ICorDebugEval2) m_eval; if (argumentTypes != null) { types = new ICorDebugType[argumentTypes.Length]; for (int i = 0; i < argumentTypes.Length; i++) types[i] = argumentTypes[i].m_type; typesLength = types.Length; } eval2.NewParameterizedObjectNoConstructor(managedClass.m_class, (uint)typesLength, types); }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { ppType = new CorDebugGenericType(RuntimeValue.CorElementType, m_rtv, m_appDomain); return(COM_HResults.S_OK); }
/// <summary> Obtains instance of DebugType. Same types will return identical instance. </summary> static internal DebugType Create(Process process, ICorDebugType corType) { DateTime startTime = Util.HighPrecisionTimer.Now; DebugType type = new DebugType(process, corType); // Get types with matching names from cache List<DebugType> typesWithMatchingName; if (!loadedTypes.TryGetValue(type.FullName, out typesWithMatchingName)) { // No types with such name - create a new list typesWithMatchingName = new List<DebugType>(1); loadedTypes.Add(type.FullName, typesWithMatchingName); } // Try to find the type foreach(DebugType loadedType in typesWithMatchingName) { if (loadedType.Equals(type)) { TimeSpan totalTime = Util.HighPrecisionTimer.Now - startTime; //process.TraceMessage("Type " + type.FullName + " was loaded already (" + totalTime.TotalMilliseconds + " ms)"); return loadedType; // Type was loaded before } } // The type is not in the cache, finish loading it and add it to the cache if (type.IsClass || type.IsValueType || type.ManagedType == typeof(string)) { type.LoadMemberInfo(); } typesWithMatchingName.Add(type); type.Process.Expired += delegate { typesWithMatchingName.Remove(type); }; TimeSpan totalTime2 = Util.HighPrecisionTimer.Now - startTime; process.TraceMessage("Loaded type " + type.FullName + " (" + totalTime2.TotalMilliseconds + " ms)"); return type; }
int ICorDebugType.GetFirstTypeParameter(out ICorDebugType value) { // For non-arrays there is not first parameter. value = null; return(COM_HResults.E_NOTIMPL); }
/* * The function ICorDebugType.GetFirstTypeParameter returns the type * of element in the array. * It control viewing of arrays elements in the watch window of debugger. */ int ICorDebugType.GetFirstTypeParameter(out ICorDebugType value) { value = new CorDebugGenericType(CorElementType.ELEMENT_TYPE_CLASS, m_ValueArray.RuntimeValue, m_ValueArray.AppDomain); return(COM_HResults.S_OK); }
public static void NewParameterizedObjectNoConstructor(this ICorDebugEval2 instance, ICorDebugClass pClass, uint nTypeArgs, ICorDebugType[] ppTypeArgs) { instance.__NewParameterizedObjectNoConstructor(pClass, nTypeArgs, ppTypeArgs); }
int ICorDebugType.GetBase(out ICorDebugType pBase) { pBase = null; return(COM_HResults.E_NOTIMPL); }
public static ICorDebugType GetArrayOrPointerType(this ICorDebugAppDomain2 instance, uint elementType, uint nRank, ICorDebugType pTypeArg) { ICorDebugType ppType; instance.__GetArrayOrPointerType(elementType, nRank, pTypeArg, out ppType); return ppType; }
public static void CallParameterizedFunction(this ICorDebugEval2 instance, ICorDebugFunction pFunction, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs) { instance.__CallParameterizedFunction(pFunction, nTypeArgs, ppTypeArgs, nArgs, ppArgs); }
/** Returns CorType object for a pointer to a function */ public CorType GetFunctionPointerType(CorType[] parameterTypes) { ICorDebugType[] types = null; if (parameterTypes != null) { types = new ICorDebugType[parameterTypes.Length]; for (int i = 0; i < parameterTypes.Length; i++) types[i] = parameterTypes[i].m_type; } ICorDebugType ct = null; (_ad() as ICorDebugAppDomain2).GetFunctionPointerType((uint)types.Length, types, out ct); return ct==null?null:new CorType (ct); }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { return ((ICorDebugValue2)m_value).GetExactType( out ppType); }
public static Eval AsyncNewObjectNoConstructor(Thread evalThread, IType type) { ICorDebugType[] typeArgs = new ICorDebugType[0]; var genType = type as ParameterizedType; if (genType != null) { typeArgs = genType.TypeArguments.Select(t => t.ToCorDebug()).ToArray(); } return new Eval( evalThread, "New object: " + type.FullName, delegate(Eval eval) { eval.CorEval2.NewParameterizedObjectNoConstructor(type.ToCorDebug().GetClass(), (uint)typeArgs.Length, typeArgs); } ); }
public static ITypeReference ToTypeReference(this ICorDebugType corType, Process process) { switch ((CorElementType)corType.GetTheType()) { case CorElementType.VOID: return(KnownTypeReference.Void); case CorElementType.BOOLEAN: return(KnownTypeReference.Boolean); case CorElementType.CHAR: return(KnownTypeReference.Char); case CorElementType.I1: return(KnownTypeReference.SByte); case CorElementType.U1: return(KnownTypeReference.Byte); case CorElementType.I2: return(KnownTypeReference.Int16); case CorElementType.U2: return(KnownTypeReference.UInt16); case CorElementType.I4: return(KnownTypeReference.Int32); case CorElementType.U4: return(KnownTypeReference.UInt32); case CorElementType.I8: return(KnownTypeReference.Int64); case CorElementType.U8: return(KnownTypeReference.UInt64); case CorElementType.R4: return(KnownTypeReference.Single); case CorElementType.R8: return(KnownTypeReference.Double); case CorElementType.STRING: return(KnownTypeReference.String); case CorElementType.PTR: return(new PointerTypeReference(corType.GetFirstTypeParameter().ToTypeReference(process))); case CorElementType.BYREF: return(new ByReferenceTypeReference(corType.GetFirstTypeParameter().ToTypeReference(process))); case CorElementType.VALUETYPE: case CorElementType.CLASS: // Get generic arguments List <ITypeReference> genericArguments = new List <ITypeReference>(); foreach (ICorDebugType t in corType.EnumerateTypeParameters().GetEnumerator()) { genericArguments.Add(t.ToTypeReference(process)); } var module = process.GetModule(corType.GetClass().GetModule()); ITypeReference typeDefinitionReference = ToTypeDefinitionReference(module, corType.GetClass().GetToken()); if (genericArguments.Count > 0) { return(new ParameterizedTypeReference(typeDefinitionReference, genericArguments)); } else { return(typeDefinitionReference); } case CorElementType.ARRAY: return(new ArrayTypeReference(corType.GetFirstTypeParameter().ToTypeReference(process), (int)corType.GetRank())); case CorElementType.GENERICINST: throw new NotSupportedException(); case CorElementType.I: return(KnownTypeReference.IntPtr); case CorElementType.U: return(KnownTypeReference.UIntPtr); case CorElementType.OBJECT: return(KnownTypeReference.Object); case CorElementType.SZARRAY: return(new ArrayTypeReference(corType.GetFirstTypeParameter().ToTypeReference(process))); case CorElementType.CMOD_REQD: case CorElementType.CMOD_OPT: return(corType.GetFirstTypeParameter().ToTypeReference(process)); default: throw new InvalidOperationException("Invalid value for CorElementType"); } }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { ppType = new CorDebugTypeArray( this ); return Utility.COM_HResults.S_OK; }
public static void NewParameterizedObject(this ICorDebugEval2 instance, ICorDebugFunction pConstructor, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs) { instance.__NewParameterizedObject(pConstructor, nTypeArgs, ppTypeArgs, nArgs, ppArgs); }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { return(((ICorDebugValue2)m_value).GetExactType(out ppType)); }
public static void NewParameterizedArray(this ICorDebugEval2 instance, ICorDebugType pElementType, uint rank, uint[] dims, uint[] lowBounds) { instance.__NewParameterizedArray(pElementType, rank, dims, lowBounds); }
int ICorDebugClass2.GetParameterizedType(CorElementType elementType, uint nTypeArgs, ICorDebugType [] ppTypeArgs, out ICorDebugType ppType) { // CorDebugClass.GetParameterizedType is not implemented ppType = null; return(COM_HResults.S_OK); }
public static uint Next(this ICorDebugTypeEnum instance, uint celt, ICorDebugType[] values) { uint pceltFetched; instance.__Next(celt, values, out pceltFetched); return pceltFetched; }
int ICorDebugValue2.GetExactType(out ICorDebugType ppType) { ppType = new CorDebugGenericType(RuntimeValue.CorElementType, m_rtv, m_appDomain); return Utility.COM_HResults.S_OK; }
int ICorDebugClass2.GetParameterizedType( CorElementType elementType, uint nTypeArgs, ICorDebugType []ppTypeArgs, out ICorDebugType ppType ) { // CorDebugClass.GetParameterizedType is not implemented ppType = null; return Utility.COM_HResults.S_OK; }
private void SetNameModuleAndFields(CorElementType typeKind, COR_TYPEID typeID, int numFields) { // THere is recursion in the definition of primitive types (they have a value field of the primtitive type. // Cut this off here. if (GCRootNames.IsPrimitiveType(typeKind)) { numFields = 0; } var buffer = new StringBuilder(1024); IMetadataImport metaData = null; int bufferSizeRet; // This is getting names. If we fail, we can still plow on .... try { ICorDebugType corType = null; // Console.WriteLine("Calling GetTypeForTypeID {0:x} {1:x}", typeID.token1, typeID.token2); m_heap.m_process5.GetTypeForTypeID(typeID, out corType); string moduleFilePath; m_name = GCRootNames.GetTypeName(corType, out moduleFilePath, out metaData, buffer); m_moduleFilePath = moduleFilePath; } catch (Exception e) { Console.WriteLine("Error: Caught exception for type ID {0:x} {1:x}: {2}", typeID.token1, typeID.token2, e.Message); m_name = string.Format("!ERROR TYPE ID {0:x} {1:x}", typeID.token1, typeID.token2); m_moduleFilePath = Name; } if (numFields > 0) { m_fields = new ICorDebugGCHeapField[numFields]; var corFields = new COR_FIELD[numFields]; int fieldsFetched; m_heap.m_process5.GetTypeFields(typeID, corFields.Length, corFields, out fieldsFetched); Debug.Assert(fieldsFetched == m_fields.Length); for (int i = 0; i < corFields.Length; i++) { int fieldTypeToken, fieldAttr, sigBlobSize, cplusTypeFlab, fieldValSize; IntPtr sigBlob, fieldVal; buffer.Length = 0; if (metaData != null) { metaData.GetFieldProps(corFields[i].token, out fieldTypeToken, buffer, buffer.Capacity, out bufferSizeRet, out fieldAttr, out sigBlob, out sigBlobSize, out cplusTypeFlab, out fieldVal, out fieldValSize); } var fieldName = buffer.ToString(); ICorDebugGCHeapType fieldType = null; // If the type has never been loaded, then you can get a null field type. // TODO FIX NOW, think about this. if (corFields[i].id.token1 != 0 || corFields[i].id.token2 != 0) { // Console.WriteLine("Looking up field {0}.{1} typeId {2:x} {3:x}", Name, fieldName, corFields[i].id.token1, corFields[i].id.token2); Debug.Assert(corFields[i].fieldType != CorElementType.ELEMENT_TYPE_END); // TODO FIX NOW remove the condition if (!GCRootNames.IsReferenceType(corFields[i].fieldType)) { fieldType = m_heap.GetObjectTypeFromID(corFields[i].id); } } else { // Console.WriteLine("Warning, NULL type token for {0}.{1} assuming it is an objectRef", Name, fieldName); // Zero means the type is not loaded. This can only happen if it is a reference type corFields[i].fieldType = CorElementType.ELEMENT_TYPE_CLASS; } // The element types match. (string matches class) #if DEBUG if (fieldType != null) { var fieldTypeKind = fieldType.TypeKind; if (fieldTypeKind == CorElementType.ELEMENT_TYPE_STRING) { fieldTypeKind = CorElementType.ELEMENT_TYPE_CLASS; } if (fieldTypeKind == CorElementType.ELEMENT_TYPE_OBJECT) { fieldTypeKind = CorElementType.ELEMENT_TYPE_CLASS; } Debug.Assert(fieldTypeKind == corFields[i].fieldType); } #endif m_fields[i] = new ICorDebugGCHeapField(fieldName, corFields[i].offset, fieldType, corFields[i].fieldType); } } }
int ICorDebugAppDomain2.GetArrayOrPointerType( CorElementType elementType, uint nRank, ICorDebugType pTypeArg, out ICorDebugType ppType ) { ppType = null; return Utility.COM_HResults.S_OK; }
internal CorType (ICorDebugType type) : base(type) { m_type = type; }
int ICorDebugAppDomain2.GetFunctionPointerType( uint nTypeArgs, ICorDebugType[] ppTypeArgs, out ICorDebugType ppType ) { ppType = null; return Utility.COM_HResults.S_OK; }
public static IType Import(this ICompilation compilation, ICorDebugType corType) { return(ToTypeReference(corType, GetAppDomain(compilation).Process).Resolve(compilation.TypeResolveContext)); }
internal CorType(ICorDebugType type) : base(type) { m_type = type; }
public ICorDebugType GetParameterizedType(uint elementType, ICorDebugType[] ppTypeArgs) { return this.GetParameterizedType(elementType, (uint)ppTypeArgs.Length, ppTypeArgs); }
public static ICorDebugType GetFunctionPointerType(this ICorDebugAppDomain2 instance, uint nTypeArgs, ref ICorDebugType ppTypeArgs) { ICorDebugType ppType; instance.__GetFunctionPointerType(nTypeArgs, ref ppTypeArgs, out ppType); return ppType; }
internal RuntimeTypeDescriptor(NetDebuggerSession session, ICorDebugType comType) { _session = session; _comType = comType; }
DebugType(Process process, ICorDebugType corType) { if (corType == null) throw new ArgumentNullException("corType"); this.process = process; this.corType = corType; this.corElementType = (CorElementType)corType.Type; if (this.IsClass || this.IsValueType) { this.corClass = corType.Class; this.module = process.GetModule(corClass.Module); this.classProps = module.MetaData.GetTypeDefProps(corClass.Token); } if (this.IsClass || this.IsValueType || this.IsArray || this.IsPointer) { foreach(ICorDebugType t in corType.EnumerateTypeParameters().Enumerator) { typeArguments.Add(DebugType.Create(process, t)); } } this.fullName = GetFullName(); }