public FieldAndOffset(FieldDesc field, int offset) { Field = field; Offset = offset; }
private ISymbolNode CreateFieldHandleHelper(FieldDesc field, SignatureContext signatureContext) { return(new PrecodeHelperImport( _codegenNodeFactory, new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle, field, signatureContext))); }
public PreInitFieldFixupInfo(int offset, FieldDesc field) : base(offset) { FieldFixup = field; }
private string ComputeMangledFieldName(FieldDesc field) { string prependTypeName = null; if (!_compilation.IsCppCodeGen) { prependTypeName = GetMangledTypeName(field.OwningType); } if (field is EcmaField) { var deduplicator = new HashSet <string>(); // Add consistent names for all fields of the type, independent on the order in which // they are compiled lock (this) { foreach (var f in field.OwningType.GetFields()) { string name = SanitizeName(f.Name); if (deduplicator.Contains(name)) { string nameWithIndex; for (int index = 1; ; index++) { nameWithIndex = name + "_" + index.ToString(CultureInfo.InvariantCulture); if (!deduplicator.Contains(nameWithIndex)) { break; } } name = nameWithIndex; } deduplicator.Add(name); if (prependTypeName != null) { name = prependTypeName + "__" + name; } _mangledFieldNames = _mangledFieldNames.Add(f, name); } } return(_mangledFieldNames[field]); } string mangledName = SanitizeName(field.Name); if (prependTypeName != null) { mangledName = prependTypeName + "__" + mangledName; } lock (this) { _mangledFieldNames = _mangledFieldNames.Add(field, mangledName); } return(mangledName); }
public FieldHandleGenericLookupResult(FieldDesc field) { Debug.Assert(field.OwningType.IsRuntimeDeterminedSubtype, "Concrete field in a generic dictionary?"); _field = field; }
public static bool TryGetDependenciesForReflectedField(ref DependencyList dependencies, NodeFactory factory, FieldDesc field, string reason) { FieldDesc typicalField = field.GetTypicalFieldDefinition(); if (factory.MetadataManager.IsReflectionBlocked(typicalField)) { return(false); } dependencies ??= new DependencyList(); // If this is a field on generic type, make sure we at minimum have the metadata // for it. This hedges against the risk that we fail to figure out an instantiated base // for it below. if (typicalField.OwningType.HasInstantiation) { dependencies.Add(factory.ReflectableField(typicalField), reason); } // If there's any genericness involved, try to create a fitting instantiation that would be usable at runtime. // This is not a complete solution to the problem. // If we ever decide that MakeGenericType/MakeGenericMethod should simply be considered unsafe, this code can be deleted // and instantiations that are not fully closed can be ignored. if (field.OwningType.IsGenericDefinition || field.OwningType.ContainsSignatureVariables(treatGenericParameterLikeSignatureVariable: true)) { TypeDesc owningType = field.OwningType.GetTypeDefinition(); Instantiation inst = TypeExtensions.GetInstantiationThatMeetsConstraints(owningType.Instantiation, allowCanon: true); if (inst.IsNull) { return(false); } field = field.Context.GetFieldForInstantiatedType( field.GetTypicalFieldDefinition(), ((MetadataType)owningType).MakeInstantiatedType(inst)); } dependencies.Add(factory.ReflectableField(field), reason); return(true); }
/// <summary> /// Generates IL for the IsSupported property that reads this information from a field initialized by the runtime /// at startup. Returns null for hardware intrinsics whose support level is known at compile time /// (i.e. they're known to be always supported or always unsupported). /// </summary> public static MethodIL EmitIsSupportedIL(MethodDesc method, FieldDesc isSupportedField) { Debug.Assert(IsIsSupportedMethod(method)); Debug.Assert(isSupportedField.IsStatic && isSupportedField.FieldType.IsWellKnownType(WellKnownType.Int32)); TargetDetails target = method.Context.Target; MetadataType owningType = (MetadataType)method.OwningType; // Check for case of nested "X64" types if (owningType.Name == "X64") { if (target.Architecture != TargetArchitecture.X64) { return(null); } // Un-nest the type so that we can do a name match owningType = (MetadataType)owningType.ContainingType; } int flag; if ((target.Architecture == TargetArchitecture.X64 || target.Architecture == TargetArchitecture.X86) && owningType.Namespace == "System.Runtime.Intrinsics.X86") { switch (owningType.Name) { case "Aes": flag = XArchIntrinsicConstants.Aes; break; case "Pclmulqdq": flag = XArchIntrinsicConstants.Pclmulqdq; break; case "Sse3": flag = XArchIntrinsicConstants.Sse3; break; case "Ssse3": flag = XArchIntrinsicConstants.Ssse3; break; case "Lzcnt": flag = XArchIntrinsicConstants.Lzcnt; break; // NOTE: this switch is complemented by IsKnownSupportedIntrinsicAtCompileTime // in the method below. default: return(null); } } else { return(null); } var emit = new ILEmitter(); ILCodeStream codeStream = emit.NewCodeStream(); codeStream.Emit(ILOpcode.ldsfld, emit.NewToken(isSupportedField)); codeStream.EmitLdc(flag); codeStream.Emit(ILOpcode.and); codeStream.EmitLdc(0); codeStream.Emit(ILOpcode.cgt_un); codeStream.Emit(ILOpcode.ret); return(emit.Link(method)); }
public RuntimeFieldHandleNode(FieldDesc targetField) { Debug.Assert(!targetField.OwningType.IsCanonicalSubtype(CanonicalFormKind.Any)); Debug.Assert(!targetField.OwningType.IsRuntimeDeterminedSubtype); _targetField = targetField; }
/// <summary> /// Given that a method is invokable, if it is inserted into the reflection invoke table /// will it use a field token to be referenced, or not? /// </summary> public abstract bool WillUseMetadataTokenToReferenceField(FieldDesc field);
private Object ResolveMemberReference(MemberReferenceHandle handle) { MemberReference memberReference = _metadataReader.GetMemberReference(handle); Object parent = GetObject(memberReference.Parent); TypeDesc parentTypeDesc = parent as TypeDesc; if (parentTypeDesc != null) { BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature); EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader); string name = _metadataReader.GetString(memberReference.Name); if (parser.IsFieldSignature) { FieldDesc field = parentTypeDesc.GetField(name); if (field != null) { return(field); } // TODO: Better error message throw new MissingMemberException("Field not found " + parent.ToString() + "." + name); } else { MethodSignature sig = parser.ParseMethodSignature(); TypeDesc typeDescToInspect = parentTypeDesc; // Try to resolve the name and signature in the current type, or any of the base types. do { // TODO: handle substitutions MethodDesc method = typeDescToInspect.GetMethod(name, sig); if (method != null) { // If this resolved to one of the base types, make sure it's not a constructor. // Instance constructors are not inherited. if (typeDescToInspect != parentTypeDesc && method.IsConstructor) { break; } return(method); } typeDescToInspect = typeDescToInspect.BaseType; } while (typeDescToInspect != null); // TODO: Better error message throw new MissingMemberException("Method not found " + parent.ToString() + "." + name); } } else if (parent is MethodDesc) { throw new NotSupportedException("Vararg methods not supported in .NET Core."); } else if (parent is ModuleDesc) { throw new NotImplementedException("MemberRef to a global function or variable."); } throw new BadImageFormatException(); }
protected internal override int CompareToImpl(FieldDesc other, TypeSystemComparer comparer) { return(comparer.Compare(_managedField, ((NativeStructField)other)._managedField)); }
public BlobNode FieldRvaDataBlob(FieldDesc field) { // Use the typical field definition in case this is an instantiated generic type field = field.GetTypicalFieldDefinition(); return(ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field), ((EcmaField)field).GetFieldRvaData(), Target.PointerSize)); }
protected override int CompareToImpl(FieldDesc other, TypeSystemComparer comparer) { return(_symbolName.CompareTo(((ExternSymbolMappedField)other)._symbolName)); }
/// <summary> /// This method is an extension point that can provide additional metadata-based dependencies to generated RuntimeFieldHandles. /// </summary> public virtual void GetDependenciesDueToLdToken(ref DependencyList dependencies, NodeFactory factory, FieldDesc field) { // MetadataManagers can override this to provide additional dependencies caused by the presence of a // RuntimeFieldHandle data structure. }
public GenericLookupResult FieldHandle(FieldDesc field) { return(_fieldHandles.GetOrAdd(field)); }
public bool CanGenerateMetadata(FieldDesc field) { Debug.Assert(field.IsTypicalFieldDefinition); return((GetMetadataCategory(field) & MetadataCategory.Description) != 0); }
/// <summary> /// Gets an object representing the static data for RVA mapped fields from the PE image. /// </summary> public object GetFieldRvaData(FieldDesc field) { return(_nodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field), ((EcmaField)field).GetFieldRvaData(), _typeSystemContext.Target.PointerSize)); }
protected abstract MetadataCategory GetMetadataCategory(FieldDesc field);
public ISymbolNode GetFieldRvaData(FieldDesc field) => NodeFactory.CopiedFieldRva(field);
public override bool IsBlocked(FieldDesc field) { Debug.Assert(field.IsTypicalFieldDefinition); // TODO: we might need to do something here if we keep this policy. return(false); }
public static bool IsPrivate(this FieldDesc field) { return(field.GetTypicalFieldDefinition() is EcmaField ecmaField && (ecmaField.Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Private); }
public bool GeneratesMetadata(FieldDesc fieldDef) => false;
public bool GeneratesMetadata(FieldDesc fieldDef) { return(true); }
private void ReadRequiredTemplates(MethodIL methodIL, HashSet <TypeDesc> typeTemplates, HashSet <MethodDesc> methodTemplates, HashSet <FieldDesc> fieldTemplates) { ILStreamReader il = new ILStreamReader(methodIL); if (!_typeSystemContext.SupportsUniversalCanon) { return; } // // Types, methods and field tokens listed here are *open* generic definitions determined by the reducer as needing reflection. // Type tokens listed are tokens of generic type definitions that will need reflection support. // Method tokens listed are either tokens of generic method definitions, or non-generic methods on generic containing type definitions, and need reflection support. // Field tokens listed are for fields on generic type definitions that will need reflection support // The canonical form supported by the typesystem context will determine how to instantiate the types/methods/fields listed here, and templatize them for // reflection support at runtime (templates used by the dynamic TypeLoader component of the runtime). // // structure is // REPEAT N TIMES //ldtoken type //pop while (true) { if (il.TryReadRet()) // ret { break; } TypeSystemEntity tse; il.TryReadLdtokenAsTypeSystemEntity(out tse); il.ReadPop(); if (tse == null) { throw new BadImageFormatException(); } if (tse is MetadataType) { MetadataType type = (MetadataType)tse; Debug.Assert(type.IsGenericDefinition && type.HasInstantiation); type = _typeSystemContext.GetInstantiatedType(type, GetUniversalCanonicalInstantiation(type.Instantiation.Length)); typeTemplates.Add(type); } else if (tse is MethodDesc) { MethodDesc method = (MethodDesc)tse; TypeDesc containingType = method.OwningType; Debug.Assert(method.IsTypicalMethodDefinition); Debug.Assert(method.HasInstantiation || method.OwningType.HasInstantiation); if (containingType.HasInstantiation) { containingType = _typeSystemContext.GetInstantiatedType((MetadataType)containingType, GetUniversalCanonicalInstantiation(containingType.Instantiation.Length)); method = containingType.GetMethod(method.Name, method.GetTypicalMethodDefinition().Signature); typeTemplates.Add(containingType); } if (method.HasInstantiation) { method = _typeSystemContext.GetInstantiatedMethod(method, GetUniversalCanonicalInstantiation(method.Instantiation.Length)); } methodTemplates.Add(method); } else if (tse is FieldDesc) { FieldDesc field = (FieldDesc)tse; TypeDesc containingType = field.OwningType; Debug.Assert(containingType.HasInstantiation && containingType.IsGenericDefinition); containingType = _typeSystemContext.GetInstantiatedType((MetadataType)containingType, GetUniversalCanonicalInstantiation(containingType.Instantiation.Length)); field = containingType.GetField(field.Name); typeTemplates.Add(containingType); fieldTemplates.Add(field); } } }
public override ISymbolNode GetTarget(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation, GenericDictionaryNode dictionary) { FieldDesc instantiatedField = _field.InstantiateSignature(typeInstantiation, methodInstantiation); return(factory.RuntimeFieldHandle(instantiatedField)); }
public override bool WillUseMetadataTokenToReferenceField(FieldDesc field) { return(_compilationModuleGroup.ContainsType(field.GetTypicalFieldDefinition().OwningType)); }
/// <summary> /// Extract preinitialize data as byte[] from a RVA field, and perform necessary validations. /// </summary> private static PreInitFieldInfo ConstructPreInitFieldInfo(FieldDesc field, FieldDesc dataField) { if (!dataField.HasRva) { throw new BadImageFormatException(); } var ecmaDataField = dataField as EcmaField; if (ecmaDataField == null) { throw new NotSupportedException(); } var rvaData = ecmaDataField.GetFieldRvaData(); var fieldType = field.FieldType; int elementCount; int realDataOffset; TypeDesc realDataType = null; // // Construct fixups // List <PreInitFixupInfo> fixups = null; var typeFixupAttrs = ecmaDataField.GetDecodedCustomAttributes("System.Runtime.CompilerServices", "TypeHandleFixupAttribute"); foreach (var typeFixupAttr in typeFixupAttrs) { if (typeFixupAttr.FixedArguments[0].Type != field.Context.GetWellKnownType(WellKnownType.Int32)) { throw new BadImageFormatException(); } int offset = (int)typeFixupAttr.FixedArguments[0].Value; var typeArg = typeFixupAttr.FixedArguments[1].Value; var fixupType = typeArg as TypeDesc; if (fixupType == null) { if (typeArg is string fixupTypeName) { fixupType = CustomAttributeTypeNameParser.GetTypeByCustomAttributeTypeName(ecmaDataField.Module, fixupTypeName, throwIfNotFound: true); } else { throw new BadImageFormatException(); } } fixups = fixups ?? new List <PreInitFixupInfo>(); if (offset == 0 && fieldType.IsSzArray) { // For array field, offset 0 is the element type handle followed by the element count realDataType = fixupType; } else { fixups.Add(new PreInitTypeFixupInfo(offset, fixupType)); } } var methodFixupAttrs = ecmaDataField.GetDecodedCustomAttributes("System.Runtime.CompilerServices", "MethodAddrFixupAttribute"); foreach (var methodFixupAttr in methodFixupAttrs) { if (methodFixupAttr.FixedArguments[0].Type != field.Context.GetWellKnownType(WellKnownType.Int32)) { throw new BadImageFormatException(); } int offset = (int)methodFixupAttr.FixedArguments[0].Value; TypeDesc fixupType = methodFixupAttr.FixedArguments[1].Value as TypeDesc; if (fixupType == null) { throw new BadImageFormatException(); } string methodName = methodFixupAttr.FixedArguments[2].Value as string; if (methodName == null) { throw new BadImageFormatException(); } var method = fixupType.GetMethod(methodName, signature: null); if (method == null) { throw new BadImageFormatException(); } fixups = fixups ?? new List <PreInitFixupInfo>(); fixups.Add(new PreInitMethodFixupInfo(offset, method)); } var fieldFixupAttrs = ecmaDataField.GetDecodedCustomAttributes("System.Runtime.CompilerServices", "FieldAddrFixupAttribute"); foreach (var fieldFixupAttr in fieldFixupAttrs) { if (fieldFixupAttr.FixedArguments[0].Type != field.Context.GetWellKnownType(WellKnownType.Int32)) { throw new BadImageFormatException(); } int offset = (int)fieldFixupAttr.FixedArguments[0].Value; TypeDesc fixupType = fieldFixupAttr.FixedArguments[1].Value as TypeDesc; if (fixupType == null) { throw new BadImageFormatException(); } string fieldName = fieldFixupAttr.FixedArguments[2].Value as string; if (fieldName == null) { throw new BadImageFormatException(); } var fixupField = fixupType.GetField(fieldName); if (fixupField == null) { throw new BadImageFormatException(); } if (!fixupField.IsStatic) { throw new BadImageFormatException(); } fixups = fixups ?? new List <PreInitFixupInfo>(); fixups.Add(new PreInitFieldFixupInfo(offset, fixupField)); } if (fieldType.IsValueType || fieldType.IsPointer) { elementCount = -1; realDataOffset = 0; realDataType = fieldType; } else if (fieldType.IsSzArray) { // Offset 0 is the element type handle fixup followed by the element count if (realDataType == null) { throw new BadImageFormatException(); } int ptrSize = fieldType.Context.Target.PointerSize; elementCount = rvaData[ptrSize] | rvaData[ptrSize + 1] << 8 | rvaData[ptrSize + 2] << 16 | rvaData[ptrSize + 3] << 24; realDataOffset = ptrSize * 2; realDataType = realDataType.MakeArrayType(); } else { throw new NotSupportedException(); } return(new PreInitFieldInfo(field, realDataType, rvaData, realDataOffset, elementCount, fixups)); }
protected override MetadataCategory GetMetadataCategory(FieldDesc field) { // Backwards compatible behavior. We might want to tweak this. return(MetadataCategory.RuntimeMapping); }
public ISymbolNode GetFieldRvaData(FieldDesc field) { // Use the typical field definition in case this is an instantiated generic type field = field.GetTypicalFieldDefinition(); throw new NotImplementedException(); }
protected internal override int CompareToImpl(FieldDesc other, TypeSystemComparer comparer) { var otherField = (InlineArrayField)other; return(comparer.CompareWithinClass(OwningType, otherField.OwningType)); }
public bool GetFieldDesc(string name, out int offset, out int tid) { FieldDesc fd = null; if(!fields.TryGetValue(name, out fd)) { // loop over for search of desired property for(int i = 0; i < PropertyCount; i++) { string n = null; int _tid = 0; int _offset = 0; bool is_private = false; bool is_reference = false; GetProperty(i, ref n, ref _tid, ref is_private, ref _offset, ref is_reference); if(n == name) { // if type is reference, denote it in type id if(is_reference) _tid = _tid | (int)asETypeIdFlags.asTYPEID_OBJHANDLE; // memoize the result fd = new FieldDesc(_offset, _tid); fields[name] = fd; break; } } } if(fd != null) { offset = fd.Offset; tid = fd.TypeId; return true; } else { offset = tid = 0; return false; } }
public bool GeneratesMetadata(FieldDesc fieldDef) { return(_parent._typeDefinitionsGenerated.Contains((MetadataType)fieldDef.OwningType)); }