public static FieldInfoMirror GetMonoField(TypeMirror monoType, DmdFieldInfo field) { var fields = field.DeclaringType.DeclaredFields; int fieldIndex = GetIndex(fields, field); return(GetMonoField(monoType, fields, fieldIndex)); }
public ReferenceTypeFieldAddress(DebuggerRuntimeImpl runtime, DbgDotNetValue objValue, DmdFieldInfo field) : base(runtime, field.FieldType) { Debug.Assert(!field.ReflectedType.IsValueType && !objValue.Type.IsArray); this.objValue = objValue; this.field = field; }
protected override void FormatFieldName(IDbgTextWriter output, DmdFieldInfo field) { var name = Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(field.Name); var color = MemberUtils.GetColor(field); output.Write(color, name); }
protected override void FormatFieldName(ITextColorWriter output, DmdFieldInfo field) { var name = Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(field.Name); var color = MemberUtils.GetColor(field); output.Write(color, name); }
static DmdFieldInfo TryGetBuilderFieldByType(DmdType type) { DmdFieldInfo builderField = null; foreach (var field in type.Fields) { var fieldType = field.FieldType; if (fieldType.IsNested) { continue; } if (fieldType.IsConstructedGenericType) { fieldType = fieldType.GetGenericTypeDefinition(); } foreach (var info in builderWellKnownTypeNames) { if (fieldType.MetadataNamespace == info.@namespace && fieldType.MetadataName == info.name) { return(field); } } if ((object)builderField == null && fieldType.MetadataName != null && (fieldType.MetadataName.EndsWith("MethodBuilder", StringComparison.Ordinal) || fieldType.MetadataName.EndsWith("MethodBuilder`1", StringComparison.Ordinal))) { builderField = field; } } return(builderField); }
public ValueTypeFieldAddress(DebuggerRuntimeImpl runtime, AddressILValue objValue, DmdFieldInfo field) : base(runtime, field.FieldType) { Debug.Assert(field.ReflectedType.IsValueType); this.objValue = objValue; this.field = field; }
public override ILValue LoadFieldAddress(DmdFieldInfo field) { if (field.ReflectedType.IsValueType) { return(runtime.LoadValueTypeFieldAddress(this, field)); } return(null); }
static int GetIndex(ReadOnlyCollection<DmdFieldInfo> fields, DmdFieldInfo field) { for (int i = 0; i < fields.Count; i++) { var f = fields[i]; if (f.MetadataToken == field.MetadataToken && f.Module == field.Module) return i; } throw new InvalidOperationException(); }
public override ILValue LoadFieldAddress(DmdFieldInfo field) { if (!fields.ContainsKey(field)) { return(null); } return(new FakeFieldAddress(fields, field)); }
public override ILValue?LoadFieldAddress(DmdFieldInfo field) { if (!field.ReflectedType !.IsValueType) { return(runtime.LoadReferenceTypeFieldAddress(ObjValue, field)); } return(null); }
public override bool StoreField(DmdFieldInfo field, ILValue value) { if (!fields.ContainsKey(field)) { return(false); } fields[field] = value; return(true); }
void WriteEnumField(DmdFieldInfo field) { if (Edit) { FormatType(field.ReflectedType); OutputWrite(".", DbgTextColor.Operator); } OutputWrite(VisualBasicTypeFormatter.GetFormattedIdentifier(field.Name), DbgTextColor.EnumField); }
void WriteEnumField(DmdFieldInfo field) { if (Edit) { FormatType(field.ReflectedType); OutputWrite(".", BoxedTextColor.Operator); } OutputWrite(CSharpTypeFormatter.GetFormattedIdentifier(field.Name), BoxedTextColor.EnumField); }
public bool StoreField(DmdFieldInfo field, ILValue value) { InitFields(field.ReflectedType); if (!AllFields.ContainsKey(field)) { return(false); } AllFields[field] = value; return(true); }
internal bool StoreStaticField(DmdFieldInfo field, object value) { var error = runtime.StoreField(evalInfo, null, field, value); if (error != null) { throw new InterpreterMessageException(error); } return(true); }
internal bool StoreInstanceField(DbgDotNetValue objValue, DmdFieldInfo field, object value) { var error = runtime.StoreField(context, frame, objValue, field, value, cancellationToken); if (error != null) { throw new InterpreterMessageException(error); } return(true); }
/// <summary> /// Gets the builder instance. It's assumed to be stored in a field in the current 'this' instance. /// /// The decompiler should already know the field. If that info isn't available, we'll try to find /// the field by name, and if that fails, by field type. /// /// null is returned if we couldn't find the field or if we failed to read the field. /// </summary> /// <param name="evalInfo">Evaluation info</param> /// <param name="builderFieldModule">Module of builder field or null if unknown</param> /// <param name="builderFieldToken">Token of builder field or 0 if unknown</param> /// <returns></returns> public static DbgDotNetValue TryGetBuilder(DbgEvaluationInfo evalInfo, DmdModule builderFieldModule, uint builderFieldToken) { DbgDotNetValueResult thisArg = default; DbgDotNetValueResult tmpResult = default; try { var runtime = evalInfo.Runtime.GetDotNetRuntime(); thisArg = runtime.GetParameterValue(evalInfo, 0); if (!thisArg.IsNormalResult || thisArg.Value.IsNull) { return(null); } if (thisArg.Value.Type.IsByRef) { tmpResult = thisArg.Value.LoadIndirect(); if (!tmpResult.IsNormalResult || tmpResult.Value.IsNull) { return(null); } thisArg.Value?.Dispose(); thisArg = tmpResult; tmpResult = default; } DmdFieldInfo builderField = null; if (builderFieldModule != null && builderFieldToken != 0) { builderField = thisArg.Value.Type.GetField(builderFieldModule, (int)builderFieldToken); } if ((object)builderField == null) { builderField = TryGetBuilderField(thisArg.Value.Type); } if ((object)builderField == null) { return(null); } Debug.Assert((object)builderField == TryGetBuilderFieldByType(thisArg.Value.Type)); Debug.Assert((object)TryGetBuilderFieldByname(thisArg.Value.Type) == null || (object)TryGetBuilderFieldByname(thisArg.Value.Type) == TryGetBuilderFieldByType(thisArg.Value.Type)); tmpResult = runtime.LoadField(evalInfo, thisArg.Value, builderField); if (!tmpResult.IsNormalResult || tmpResult.Value.IsNull) { return(null); } var fieldValue = tmpResult.Value; tmpResult = default; return(fieldValue); } finally { thisArg.Value?.Dispose(); tmpResult.Value?.Dispose(); } }
public override ILValue LoadStaticFieldAddress(DmdFieldInfo field) { var addrValue = runtime.LoadFieldAddress(evalInfo, null, field); if (addrValue != null) { Debug.Assert(addrValue.Type.IsByRef); return(new ByRefILValueImpl(this, RecordValue(addrValue))); } return(new StaticFieldAddress(this, field)); }
internal ILValue LoadReferenceTypeFieldAddress(DbgDotNetValue objValue, DmdFieldInfo field) { Debug.Assert(!field.ReflectedType.IsValueType); var addrValue = runtime.LoadFieldAddress(evalInfo, objValue, field); if (addrValue != null) { Debug.Assert(addrValue.Type.IsByRef); return(new ByRefILValueImpl(this, RecordValue(addrValue))); } return(new ReferenceTypeFieldAddress(this, objValue, field)); }
internal ILValue LoadValueTypeFieldAddress(AddressILValue objValue, DmdFieldInfo field) { Debug.Assert(field.ReflectedType.IsValueType); var dnObjValue = TryGetDotNetValue(objValue, canCreateValue: false); if (dnObjValue != null) { var addrValue = runtime.LoadFieldAddress(evalInfo, dnObjValue, field); if (addrValue != null) { Debug.Assert(addrValue.Type.IsByRef); return(new ByRefILValueImpl(this, RecordValue(addrValue))); } } return(new ValueTypeFieldAddress(this, objValue, field)); }
public static DbgTextColor GetColor(DmdFieldInfo field) { if (field.ReflectedType.IsEnum) { return(DbgTextColor.EnumField); } if (field.IsLiteral) { return(DbgTextColor.LiteralField); } if (field.IsStatic) { return(DbgTextColor.StaticField); } return(DbgTextColor.InstanceField); }
public override DmdFieldInfo[] ReadDeclaredFields(DmdType declaringType, DmdType reflectedType) { var ridList = reader.Metadata.GetFieldRidList(Rid); if (ridList.Count == 0) { return(Array.Empty <DmdFieldInfo>()); } var fields = new DmdFieldInfo[ridList.Count]; for (int i = 0; i < fields.Length; i++) { uint rid = ridList[i]; fields[i] = reader.CreateFieldDef(rid, declaringType, reflectedType); } return(fields); }
public static (DmdFieldInfo hasValueField, DmdFieldInfo valueField) TryGetNullableFields(DmdType type) { Debug.Assert(type.IsNullable); DmdFieldInfo hasValueField = null; DmdFieldInfo valueField = null; var fields = type.DeclaredFields; for (int i = 0; i < fields.Count; i++) { var field = fields[i]; if (field.IsStatic || field.IsLiteral) { continue; } switch (field.Name) { case HasValueFieldName: case HasValueFieldName_Mono: if ((object)hasValueField != null) { return(null, null); } hasValueField = field; break; case ValueFieldName: if ((object)valueField != null) { return(null, null); } valueField = field; break; default: return(null, null); } } if ((object)hasValueField == null || (object)valueField == null) { return(null, null); } return(hasValueField, valueField); }
DmdFieldInfo[] ReadDeclaredFields_COMThread(DmdType declaringType, DmdType reflectedType) { reader.Dispatcher.VerifyAccess(); var tokens = MDAPI.GetFieldTokens(reader.MetaDataImport, (uint)MetadataToken); if (tokens.Length == 0) { return(Array.Empty <DmdFieldInfo>()); } var fields = new DmdFieldInfo[tokens.Length]; for (int i = 0; i < fields.Length; i++) { uint rid = tokens[i] & 0x00FFFFFF; fields[i] = reader.CreateFieldDef_COMThread(rid, declaringType, reflectedType); } return(fields); }
public static (DmdFieldInfo keyField, DmdFieldInfo valueField) TryGetFields(DmdType type) { Debug.Assert(IsKeyValuePair(type)); DmdFieldInfo keyField = null; DmdFieldInfo valueField = null; var fields = type.DeclaredFields; for (int i = 0; i < fields.Count; i++) { var field = fields[i]; if (field.IsStatic || field.IsLiteral) { continue; } switch (field.Name) { case KeyFieldName: if ((object)keyField != null) { return(null, null); } keyField = field; break; case ValueFieldName: if ((object)valueField != null) { return(null, null); } valueField = field; break; default: return(null, null); } } if ((object)keyField == null || (object)valueField == null) { return(null, null); } return(keyField, valueField); }
public static (DmdFieldInfo keyField, DmdFieldInfo valueField) TryGetFields(DmdType type, string keyFieldName, string valueFieldName) { DmdFieldInfo keyField = null; DmdFieldInfo valueField = null; var fields = type.DeclaredFields; for (int i = 0; i < fields.Count; i++) { var field = fields[i]; if (field.IsStatic || field.IsLiteral) { continue; } if (field.Name == keyFieldName) { if ((object)keyField != null) { return(null, null); } keyField = field; } else if (field.Name == valueFieldName) { if ((object)valueField != null) { return(null, null); } valueField = field; } else { return(null, null); } } if ((object)keyField == null || (object)valueField == null) { return(null, null); } return(keyField, valueField); }
public static bool IsMatch(DmdFieldInfo field, DmdBindingFlags bindingAttr) { var attr = DmdBindingFlags.Default; if (field.IsPublic) { attr |= DmdBindingFlags.Public; } else { attr |= DmdBindingFlags.NonPublic; } if (field.IsStatic) { attr |= DmdBindingFlags.Static; } else { attr |= DmdBindingFlags.Instance; } if ((object)field.ReflectedType != field.DeclaringType) { if (field.IsStatic) { if (field.IsPrivate) { return(false); } attr |= DmdBindingFlags.FlattenHierarchy; } else { if (field.IsPrivate) { return(false); } } } return((attr & bindingAttr) == attr); }
/// <summary> /// Stores a value in a static field or returns false on failure /// </summary> /// <param name="field">Field</param> /// <param name="value">Value to store in the field</param> public abstract bool StoreStaticField(DmdFieldInfo field, ILValue value);
/// <summary> /// Returns the address of a static field or returns null on failure /// </summary> /// <param name="field">Field</param> /// <returns></returns> public abstract ILValue LoadStaticFieldAddress(DmdFieldInfo field);
/// <summary> /// Creates a <see cref="RuntimeFieldHandle"/> value or returns null on failure /// </summary> /// <param name="field">Field</param> /// <returns></returns> public abstract ILValue CreateRuntimeFieldHandle(DmdFieldInfo field);