private void InitializeFieldDefinition(Cts.FieldDesc entity, Field record) { record.Name = HandleString(entity.Name); record.Signature = new FieldSignature { Type = HandleType(entity.FieldType), // TODO: CustomModifiers }; record.Flags = GetFieldAttributes(entity); var ecmaField = entity as Cts.Ecma.EcmaField; if (ecmaField != null) { Ecma.MetadataReader reader = ecmaField.MetadataReader; Ecma.FieldDefinition fieldDef = reader.GetFieldDefinition(ecmaField.Handle); Ecma.ConstantHandle defaultValueHandle = fieldDef.GetDefaultValue(); if (!defaultValueHandle.IsNil) { record.DefaultValue = HandleConstant(ecmaField.Module, defaultValueHandle); } Ecma.CustomAttributeHandleCollection customAttributes = fieldDef.GetCustomAttributes(); if (customAttributes.Count > 0) { record.CustomAttributes = HandleCustomAttributes(ecmaField.Module, customAttributes); } } // TODO: Offset }
private PdbToXmlConverter(XmlWriter writer, ISymUnmanagedReader symReader, MetadataReader metadataReader, PdbToXmlOptions options) { _symReader = symReader; _metadataReader = metadataReader; _writer = writer; _options = options; }
private GenericParameter HandleGenericParameter(Cts.GenericParameterDesc genParam) { var result = new GenericParameter { Kind = genParam.Kind == Cts.GenericParameterKind.Type ? GenericParameterKind.GenericTypeParameter : GenericParameterKind.GenericMethodParameter, Number = checked ((ushort)genParam.Index), }; foreach (Cts.TypeDesc constraint in genParam.TypeConstraints) { result.Constraints.Add(HandleType(constraint)); } var ecmaGenParam = genParam as Cts.Ecma.EcmaGenericParameter; if (ecmaGenParam != null) { Ecma.MetadataReader reader = ecmaGenParam.MetadataReader; Ecma.GenericParameter genParamDef = reader.GetGenericParameter(ecmaGenParam.Handle); result.Flags = genParamDef.Attributes; result.Name = HandleString(reader.GetString(genParamDef.Name)); } else { throw new NotImplementedException(); } // TODO: CustomAttributes return(result); }
public PE(string fileName) { FileName = Path.GetFullPath(fileName); Uri = new Uri(FileName); IsPEFile = false; try { _fs = File.OpenRead(FileName); byte byteRead = (byte)_fs.ReadByte(); if (byteRead != 'M') { return; } byteRead = (byte)_fs.ReadByte(); if (byteRead != 'Z') { return; } _fs.Seek(0, SeekOrigin.Begin); _peReader = new PEReader(_fs); PEHeaders = _peReader.PEHeaders; IsPEFile = true; } catch (IOException e) { LoadException = e; } catch (BadImageFormatException e) { LoadException = e; } catch (UnauthorizedAccessException e) { LoadException = e; } if (IsPEFile) { m_pImage = new SafePointer(_peReader.GetEntireImage().GetContent().ToBuilder().ToArray()); if (IsManaged) { _metadataReader = _peReader.GetMetadataReader(); } } }
private List <CustomAttribute> HandleCustomAttributes(Cts.Ecma.EcmaModule module, Ecma.CustomAttributeHandleCollection attributes) { List <CustomAttribute> customAttributes = new List <CustomAttribute>(attributes.Count); var attributeTypeProvider = new Cts.Ecma.CustomAttributeTypeProvider(module); Ecma.MetadataReader reader = module.MetadataReader; foreach (var attributeHandle in attributes) { if (!_policy.GeneratesMetadata(module, attributeHandle)) { continue; } Ecma.CustomAttribute attribute = reader.GetCustomAttribute(attributeHandle); // TODO-NICE: We can intern the attributes based on the CA constructor and blob bytes Cts.MethodDesc constructor = module.GetMethod(attribute.Constructor); var decodedValue = attribute.DecodeValue(attributeTypeProvider); customAttributes.Add(HandleCustomAttribute(constructor, decodedValue)); } return(customAttributes); }
internal static void VerifyModuleMvid(int generation, MetadataReader previousReader, MetadataReader currentReader) { var previousModule = previousReader.GetModuleDefinition(); var currentModule = currentReader.GetModuleDefinition(); Assert.Equal(previousReader.GetGuid(previousModule.Mvid), currentReader.GetGuid(currentModule.Mvid)); Assert.Equal(generation - 1, previousModule.Generation); Assert.Equal(generation, currentModule.Generation); if (generation == 1) { Assert.True(previousModule.GenerationId.IsNil); Assert.True(previousModule.BaseGenerationId.IsNil); Assert.False(currentModule.GenerationId.IsNil); Assert.True(currentModule.BaseGenerationId.IsNil); } else { Assert.False(currentModule.GenerationId.IsNil); Assert.False(currentModule.BaseGenerationId.IsNil); Assert.Equal(previousReader.GetGuid(previousModule.GenerationId), currentReader.GetGuid(currentModule.BaseGenerationId)); } Assert.NotEqual(default(Guid), currentReader.GetGuid(currentModule.GenerationId)); }
public unsafe PinnedMetadata(ImmutableArray<byte> metadata) { _bytes = GCHandle.Alloc(metadata.DangerousGetUnderlyingArray(), GCHandleType.Pinned); this.Pointer = _bytes.AddrOfPinnedObject(); this.Size = metadata.Length; this.Reader = new MetadataReader((byte*)this.Pointer, this.Size, MetadataReaderOptions.None, null); }
public unsafe static void ToXml(TextWriter xmlWriter, Stream pdbStream, Stream peStream, PdbToXmlOptions options = PdbToXmlOptions.Default, string methodName = null) { IEnumerable<MethodHandle> methodHandles; var headers = new PEHeaders(peStream); byte[] metadata = new byte[headers.MetadataSize]; peStream.Seek(headers.MetadataStartOffset, SeekOrigin.Begin); peStream.Read(metadata, 0, headers.MetadataSize); fixed (byte* metadataPtr = metadata) { var metadataReader = new MetadataReader((IntPtr)metadataPtr, metadata.Length); if (string.IsNullOrEmpty(methodName)) { methodHandles = metadataReader.MethodDefinitions; } else { methodHandles = metadataReader.MethodDefinitions. Where(methodHandle => GetQualifiedMethodName(metadataReader, methodHandle) == methodName); } ToXml(xmlWriter, pdbStream, metadataReader, options, methodHandles); } }
private List <CustomAttribute> HandleCustomAttributes(Cts.Ecma.EcmaModule module, Ecma.CustomAttributeHandleCollection attributes) { List <CustomAttribute> customAttributes = new List <CustomAttribute>(attributes.Count); var attributeTypeProvider = new Cts.Ecma.CustomAttributeTypeProvider(module); foreach (var attributeHandle in attributes) { Ecma.MetadataReader reader = module.MetadataReader; Ecma.CustomAttribute attribute = reader.GetCustomAttribute(attributeHandle); // TODO-NICE: We can intern the attributes based on the CA constructor and blob bytes try { Cts.MethodDesc constructor = module.GetMethod(attribute.Constructor); var decodedValue = attribute.DecodeValue(attributeTypeProvider); if (IsBlockedCustomAttribute(constructor, decodedValue)) { continue; } customAttributes.Add(HandleCustomAttribute(constructor, decodedValue)); } catch (Cts.TypeSystemException) { // TODO: We should emit unresolvable custom attributes instead of skipping these } } return(customAttributes); }
private static ImmutableArray <AssemblyIdentity> ReadReferences( SystemMetadataReader metadataReader ) { var builder = ImmutableArray.CreateBuilder <AssemblyIdentity>(); foreach (var referenceHandle in metadataReader.AssemblyReferences) { var reference = metadataReader.GetAssemblyReference(referenceHandle); var refname = metadataReader.GetString(reference.Name); var refversion = reference.Version; var refcultureName = metadataReader.GetString(reference.Culture); var refpublicKeyOrToken = metadataReader.GetBlobContent(reference.PublicKeyOrToken); var refflags = reference.Flags; var refhasPublicKey = (refflags & AssemblyFlags.PublicKey) != 0; builder.Add( new AssemblyIdentity( refname, refversion, refcultureName, refpublicKeyOrToken, hasPublicKey: refhasPublicKey ) ); } return(builder.ToImmutable()); }
public IType GetTypeFromReference(SRM.MetadataReader reader, SRM.TypeReferenceHandle handle, byte rawTypeKind) { bool?isReferenceType = IsReferenceType(reader, handle, rawTypeKind); var gctr = new GetClassTypeReference(handle.GetFullTypeName(reader), handle.GetDeclaringModule(reader), isReferenceType); return(gctr.Resolve(module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation))); }
//private bool hasInheritedExports = false; //private readonly Dictionary<Handle, bool> inheritedExportTypes = new Dictionary<Handle, bool>(); //private readonly HashSet<string> inheritedExportTypesByName = new HashSet<string>(); public AssemblyCatalogInfo(Discovery discovery, MetadataReader metadataReader, string assemblyFilePath) { Debug.WriteLine("AssemblyCatalogInfo: " + assemblyFilePath); this.discovery = discovery; this.metadataReader = metadataReader; this.assemblyFilePath = assemblyFilePath; }
public DocumentMap(MetadataReader reader) { _reader = reader; // group ignoring case, we will match the case within the group _map = GetDocumentsByFileName(reader).GroupBy(StringComparer.OrdinalIgnoreCase); }
private static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMap( MetadataReader reader, Symbols.Metadata.PE.MetadataDecoder metadataDecoder) { var result = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>(); foreach (var handle in reader.TypeDefinitions) { var def = reader.GetTypeDefinition(handle); if (!def.Namespace.IsNil) { continue; } if (!reader.StringStartsWith(def.Name, GeneratedNames.AnonymousNamePrefix)) { continue; } var metadataName = reader.GetString(def.Name); short arity; var name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out arity); int index; if (GeneratedNames.TryParseAnonymousTypeTemplateName(name, out index)) { var builder = ArrayBuilder<string>.GetInstance(); if (TryGetAnonymousTypeKey(reader, def, builder)) { var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle); var key = new AnonymousTypeKey(builder.ToImmutable()); var value = new AnonymousTypeValue(name, index, type); result.Add(key, value); } builder.Free(); } } return result; }
private PdbToXmlConverter(XmlWriter writer, TempPdbReader pdbReader, MetadataReader metadataReader, PdbToXmlOptions options) { this.pdbReader = pdbReader; this.metadataReader = metadataReader; this.writer = writer; this.options = options; }
private void InitializeMethodDefinition(Cts.MethodDesc entity, Method record) { record.Name = HandleString(entity.Name); record.Signature = HandleMethodSignature(entity.Signature); if (entity.HasInstantiation) { var genericParams = new List <GenericParameter>(entity.Instantiation.Length); foreach (var p in entity.Instantiation) { genericParams.Add(HandleGenericParameter((Cts.GenericParameterDesc)p)); } record.GenericParameters = genericParams; } if (entity.Signature.Length > 0) { List <Parameter> parameters = new List <Parameter>(entity.Signature.Length); for (ushort i = 0; i < entity.Signature.Length; i++) { parameters.Add(new Parameter { Sequence = i }); } var ecmaEntity = entity as Cts.Ecma.EcmaMethod; if (ecmaEntity != null) { Ecma.MetadataReader reader = ecmaEntity.MetadataReader; Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaEntity.Handle); Ecma.ParameterHandleCollection paramHandles = methodDef.GetParameters(); Debug.Assert(paramHandles.Count == entity.Signature.Length); int i = 0; foreach (var paramHandle in paramHandles) { Ecma.Parameter param = reader.GetParameter(paramHandle); parameters[i].Flags = param.Attributes; parameters[i].Name = HandleString(reader.GetString(param.Name)); // TODO: CustomAttributes // TODO: DefaultValue i++; } } record.Parameters = parameters; } record.Flags = GetMethodAttributes(entity); record.ImplFlags = GetMethodImplAttributes(entity); //TODO: MethodImpls //TODO: RVA //TODO: CustomAttributes }
internal ManifestResource(MetadataReader reader, ManifestResourceHandle handle) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal EventDefinition(MetadataReader reader, EventDefinitionHandle handle) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal LocalVariable(MetadataReader reader, LocalVariableHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal Document(MetadataReader reader, DocumentHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal ExportedType(MetadataReader reader, uint rowId) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(rowId != 0); this.reader = reader; this.rowId = rowId; }
internal Parameter(MetadataReader reader, ParameterHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
public OpenedReader(MetadataReaderProvider provider, MetadataReader reader) { Debug.Assert(provider != null); Debug.Assert(reader != null); Provider = provider; Reader = reader; }
internal GenericParameterConstraint(MetadataReader reader, GenericParameterConstraintHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal InterfaceImplementation(MetadataReader reader, InterfaceImplementationHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal StandaloneSignature(MetadataReader reader, StandaloneSignatureHandle handle) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal AssemblyFile(MetadataReader reader, AssemblyFileHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal CustomAttribute(MetadataReader reader, uint treatmentAndRowId) { Debug.Assert(reader != null); Debug.Assert(treatmentAndRowId != 0); _reader = reader; _treatmentAndRowId = treatmentAndRowId; }
internal CustomAttribute(MetadataReader reader, uint treatmentAndRowId) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(treatmentAndRowId != 0); this.reader = reader; this.treatmentAndRowId = treatmentAndRowId; }
internal LocalConstant(MetadataReader reader, LocalConstantHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal PropertyDefinition(MetadataReader reader, PropertyDefinitionHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal DeclarativeSecurityAttribute(MetadataReader reader, uint rowId) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(rowId != 0); this.reader = reader; this.rowId = rowId; }
internal ModuleReference(MetadataReader reader, ModuleReferenceHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); this.reader = reader; this.rowId = handle.RowId; }
internal TypeReference(MetadataReader reader, uint treatmentAndRowId) { DebugCorlib.Assert(reader != null); DebugCorlib.Assert(treatmentAndRowId != 0); this.reader = reader; this.treatmentAndRowId = treatmentAndRowId; }
internal MethodDefinition(MetadataReader reader, uint treatmentAndRowId) { Debug.Assert(reader != null); Debug.Assert(treatmentAndRowId != 0); this.reader = reader; this.treatmentAndRowId = treatmentAndRowId; }
internal ImportScope(MetadataReader reader, ImportScopeHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
internal TypeSpecification(MetadataReader reader, TypeSpecificationHandle handle) { Debug.Assert(reader != null); Debug.Assert(!handle.IsNil); _reader = reader; _rowId = handle.RowId; }
private void InitializeTypeForwarder(ForwarderKey key, TypeForwarder record) { Cts.Ecma.EcmaModule module = key.Module; Ecma.MetadataReader reader = module.MetadataReader; Ecma.ExportedType exportedType = reader.GetExportedType(key.ExportedType); record.Name = HandleString(reader.GetString(exportedType.Name)); switch (exportedType.Implementation.Kind) { case Ecma.HandleKind.AssemblyReference: { string ns = reader.GetString(exportedType.Namespace); NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns); Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation); AssemblyName refName = new AssemblyName { ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9), Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask), CultureName = reader.GetString(assemblyRef.Culture), Name = reader.GetString(assemblyRef.Name), Version = assemblyRef.Version, }; if ((assemblyRef.Flags & AssemblyFlags.PublicKey) != 0) { refName.SetPublicKey(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken)); } else { refName.SetPublicKeyToken(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken)); } record.Scope = HandleScopeReference(refName); namespaceDefinition.TypeForwarders.Add(record); } break; case Ecma.HandleKind.ExportedType: { TypeForwarder scope = HandleTypeForwarder(module, (Ecma.ExportedTypeHandle)exportedType.Implementation); record.Scope = scope.Scope; scope.NestedTypes.Add(record); } break; default: throw new BadImageFormatException(); } }
public IType GetTypeFromDefinition(SRM.MetadataReader reader, SRM.TypeDefinitionHandle handle, byte rawTypeKind) { ITypeDefinition td = module?.GetDefinition(handle); if (td != null) { return(td); } bool?isReferenceType = IsReferenceType(reader, handle, rawTypeKind); return(new UnknownType(handle.GetFullTypeName(reader), isReferenceType)); }
private TypeForwarder HandleTypeForwarder(Cts.Ecma.EcmaModule module, Ecma.ExportedType exportedType) { Ecma.MetadataReader reader = module.MetadataReader; string name = reader.GetString(exportedType.Name); TypeForwarder result; switch (exportedType.Implementation.Kind) { case Ecma.HandleKind.AssemblyReference: { string ns = reader.GetString(exportedType.Namespace); NamespaceDefinition namespaceDefinition = HandleNamespaceDefinition(module, ns); Ecma.AssemblyReference assemblyRef = reader.GetAssemblyReference((Ecma.AssemblyReferenceHandle)exportedType.Implementation); AssemblyName refName = new AssemblyName { ContentType = (AssemblyContentType)((int)(assemblyRef.Flags & AssemblyFlags.ContentTypeMask) >> 9), Flags = (AssemblyNameFlags)(assemblyRef.Flags & ~AssemblyFlags.ContentTypeMask), CultureName = reader.GetString(assemblyRef.Culture), Name = reader.GetString(assemblyRef.Name), Version = assemblyRef.Version, }; result = new TypeForwarder { Name = HandleString(name), Scope = HandleScopeReference(refName), }; namespaceDefinition.TypeForwarders.Add(result); } break; case Ecma.HandleKind.ExportedType: { TypeForwarder scope = HandleTypeForwarder(module, reader.GetExportedType((Ecma.ExportedTypeHandle)exportedType.Implementation)); result = new TypeForwarder { Name = HandleString(name), Scope = scope.Scope, }; scope.NestedTypes.Add(result); } break; default: throw new BadImageFormatException(); } return(result); }
private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader) { var assemblyDefinition = metadataReader.GetAssemblyDefinition(); var name = metadataReader.GetString(assemblyDefinition.Name); var version = assemblyDefinition.Version; var cultureName = metadataReader.GetString(assemblyDefinition.Culture); var publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey); var flags = assemblyDefinition.Flags; var hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey)); }
private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader) { var assemblyDefinition = metadataReader.GetAssemblyDefinition(); string name = metadataReader.GetString(assemblyDefinition.Name); Version version = assemblyDefinition.Version; string cultureName = metadataReader.GetString(assemblyDefinition.Culture); ImmutableArray <byte> publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey); AssemblyFlags flags = assemblyDefinition.Flags; bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0; return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey)); }
private MethodImplAttributes GetMethodImplAttributes(Cts.MethodDesc method) { var ecmaMethod = method as Cts.Ecma.EcmaMethod; if (ecmaMethod != null) { Ecma.MetadataReader reader = ecmaMethod.MetadataReader; Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaMethod.Handle); return methodDef.ImplAttributes; } else throw new NotImplementedException(); }
bool?IsReferenceType(SRM.MetadataReader reader, SRM.EntityHandle handle, byte rawTypeKind) { switch (reader.ResolveSignatureTypeKind(handle, rawTypeKind)) { case SRM.SignatureTypeKind.ValueType: return(false); case SRM.SignatureTypeKind.Class: return(true); default: return(null); } }
public IType GetTypeFromReference(SRM.MetadataReader reader, SRM.TypeReferenceHandle handle, byte rawTypeKind) { IModule resolvedModule = module.GetDeclaringModule(handle); var fullTypeName = handle.GetFullTypeName(reader); IType type; if (resolvedModule != null) { type = resolvedModule.GetTypeDefinition(fullTypeName); } else { type = GetClassTypeReference.ResolveInAllAssemblies(compilation, in fullTypeName); } return(type ?? new UnknownType(fullTypeName, IsReferenceType(reader, handle, rawTypeKind))); }
public void Close() { if (_peReader != null) { _peReader.Dispose(); } if (_assemblyStream != null) { _assemblyStream.Close(); } _attributes = null; _reader = null; _peReader = null; _assemblyStream = null; }
private MetadataReader(string path) { try { _assemblyStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read); if (_assemblyStream != null) { _peReader = new PEReader(_assemblyStream, PEStreamOptions.LeaveOpen); if (_peReader != null) { if (_peReader.HasMetadata) { _reader = _peReader.GetMetadataReader(); } } } } catch (Exception) { Close(); } }
private static Guid ReadMvid(SystemMetadataReader metadataReader) { var mvidHandle = metadataReader.GetModuleDefinition().Mvid; return(metadataReader.GetGuid(mvidHandle)); }
public static IType ApplyAttributesToType( IType inputType, ICompilation compilation, SRM.CustomAttributeHandleCollection?attributes, SRM.MetadataReader metadata, TypeSystemOptions options, bool typeChildrenOnly = false) { bool useDynamicType = (options & TypeSystemOptions.Dynamic) != 0; bool useTupleTypes = (options & TypeSystemOptions.Tuple) != 0; bool hasDynamicAttribute = false; bool[] dynamicAttributeData = null; string[] tupleElementNames = null; if (attributes != null && (useDynamicType || useTupleTypes)) { foreach (var attrHandle in attributes.Value) { var attr = metadata.GetCustomAttribute(attrHandle); var attrType = attr.GetAttributeType(metadata); if (useDynamicType && attrType.IsKnownType(metadata, KnownAttribute.Dynamic)) { hasDynamicAttribute = true; var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is bool)) { dynamicAttributeData = values.SelectArray(v => (bool)v.Value); } } } else if (useTupleTypes && attrType.IsKnownType(metadata, KnownAttribute.TupleElementNames)) { var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is string || v.Value == null)) { tupleElementNames = values.SelectArray(v => (string)v.Value); } } } } } if (hasDynamicAttribute || (options & (TypeSystemOptions.Tuple | TypeSystemOptions.KeepModifiers)) != TypeSystemOptions.KeepModifiers) { var visitor = new ApplyAttributeTypeVisitor( compilation, hasDynamicAttribute, dynamicAttributeData, options, tupleElementNames ); if (typeChildrenOnly) { return(inputType.VisitChildren(visitor)); } else { return(inputType.AcceptVisitor(visitor)); } } else { return(inputType); } }
public IType GetTypeFromSpecification(SRM.MetadataReader reader, GenericContext genericContext, SRM.TypeSpecificationHandle handle, byte rawTypeKind) { return(reader.GetTypeSpecification(handle).DecodeSignature <IType, GenericContext>(this, genericContext)); }
private void InitializeTypeDef(Cts.MetadataType entity, TypeDefinition record) { Debug.Assert(entity.IsTypeDefinition); Cts.MetadataType containingType = (Cts.MetadataType)entity.ContainingType; if (containingType != null) { var enclosingType = (TypeDefinition)HandleType(containingType); record.EnclosingType = enclosingType; enclosingType.NestedTypes.Add(record); var namespaceDefinition = HandleNamespaceDefinition(containingType.Module, entity.ContainingType.Namespace); record.NamespaceDefinition = namespaceDefinition; } else { var namespaceDefinition = HandleNamespaceDefinition(entity.Module, entity.Namespace); record.NamespaceDefinition = namespaceDefinition; namespaceDefinition.TypeDefinitions.Add(record); } record.Name = HandleString(entity.Name); Cts.ClassLayoutMetadata layoutMetadata = entity.GetClassLayout(); record.Size = checked ((uint)layoutMetadata.Size); record.PackingSize = checked ((ushort)layoutMetadata.PackingSize); record.Flags = GetTypeAttributes(entity); if (entity.HasBaseType) { record.BaseType = HandleType(entity.BaseType); } record.Interfaces.Capacity = entity.ExplicitlyImplementedInterfaces.Length; foreach (var interfaceType in entity.ExplicitlyImplementedInterfaces) { if (IsBlocked(interfaceType)) { continue; } record.Interfaces.Add(HandleType(interfaceType)); } if (entity.HasInstantiation) { record.GenericParameters.Capacity = entity.Instantiation.Length; foreach (var p in entity.Instantiation) { record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p)); } } foreach (var field in entity.GetFields()) { if (_policy.GeneratesMetadata(field)) { record.Fields.Add(HandleFieldDefinition(field)); } } foreach (var method in entity.GetMethods()) { if (_policy.GeneratesMetadata(method)) { record.Methods.Add(HandleMethodDefinition(method)); } } var ecmaEntity = entity as Cts.Ecma.EcmaType; if (ecmaEntity != null) { Ecma.TypeDefinition ecmaRecord = ecmaEntity.MetadataReader.GetTypeDefinition(ecmaEntity.Handle); foreach (var e in ecmaRecord.GetEvents()) { Event evt = HandleEvent(ecmaEntity.EcmaModule, e); if (evt != null) { record.Events.Add(evt); } } foreach (var property in ecmaRecord.GetProperties()) { Property prop = HandleProperty(ecmaEntity.EcmaModule, property); if (prop != null) { record.Properties.Add(prop); } } Ecma.CustomAttributeHandleCollection customAttributes = ecmaRecord.GetCustomAttributes(); if (customAttributes.Count > 0) { record.CustomAttributes = HandleCustomAttributes(ecmaEntity.EcmaModule, customAttributes); } foreach (var miHandle in ecmaRecord.GetMethodImplementations()) { Ecma.MetadataReader reader = ecmaEntity.EcmaModule.MetadataReader; Ecma.MethodImplementation miDef = reader.GetMethodImplementation(miHandle); Cts.MethodDesc methodBody = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodBody); if (_policy.IsBlocked(methodBody)) { continue; } Cts.MethodDesc methodDecl = (Cts.MethodDesc)ecmaEntity.EcmaModule.GetObject(miDef.MethodDeclaration); if (_policy.IsBlocked(methodDecl.GetTypicalMethodDefinition())) { continue; } MethodImpl methodImplRecord = new MethodImpl { MethodBody = HandleQualifiedMethod(methodBody), MethodDeclaration = HandleQualifiedMethod(methodDecl) }; record.MethodImpls.Add(methodImplRecord); } } }
public static IType ApplyAttributesToType( IType inputType, ICompilation compilation, SRM.CustomAttributeHandleCollection?attributes, SRM.MetadataReader metadata, TypeSystemOptions options, Nullability nullableContext, bool typeChildrenOnly = false) { bool hasDynamicAttribute = false; bool[] dynamicAttributeData = null; bool hasNativeIntegersAttribute = false; bool[] nativeIntegersAttributeData = null; string[] tupleElementNames = null; Nullability nullability; Nullability[] nullableAttributeData = null; if ((options & TypeSystemOptions.NullabilityAnnotations) != 0) { nullability = nullableContext; } else { nullability = Nullability.Oblivious; } const TypeSystemOptions relevantOptions = TypeSystemOptions.Dynamic | TypeSystemOptions.Tuple | TypeSystemOptions.NullabilityAnnotations | TypeSystemOptions.NativeIntegers; if (attributes != null && (options & relevantOptions) != 0) { foreach (var attrHandle in attributes.Value) { var attr = metadata.GetCustomAttribute(attrHandle); var attrType = attr.GetAttributeType(metadata); if ((options & TypeSystemOptions.Dynamic) != 0 && attrType.IsKnownType(metadata, KnownAttribute.Dynamic)) { hasDynamicAttribute = true; var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is bool)) { dynamicAttributeData = values.SelectArray(v => (bool)v.Value); } } } else if ((options & TypeSystemOptions.NativeIntegers) != 0 && attrType.IsKnownType(metadata, KnownAttribute.NativeInteger)) { hasNativeIntegersAttribute = true; var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is bool)) { nativeIntegersAttributeData = values.SelectArray(v => (bool)v.Value); } } } else if ((options & TypeSystemOptions.Tuple) != 0 && attrType.IsKnownType(metadata, KnownAttribute.TupleElementNames)) { var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is string || v.Value == null)) { tupleElementNames = values.SelectArray(v => (string)v.Value); } } } else if ((options & TypeSystemOptions.NullabilityAnnotations) != 0 && attrType.IsKnownType(metadata, KnownAttribute.Nullable)) { var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); if (ctor.FixedArguments.Length == 1) { var arg = ctor.FixedArguments[0]; if (arg.Value is ImmutableArray <SRM.CustomAttributeTypedArgument <IType> > values && values.All(v => v.Value is byte b && b <= 2)) { nullableAttributeData = values.SelectArray(v => (Nullability)(byte)v.Value); } else if (arg.Value is byte b && b <= 2) { nullability = (Nullability)b; } } } } }
private void InitializeScopeDefinition(Cts.ModuleDesc module, ScopeDefinition scopeDefinition) { var assemblyDesc = module as Cts.IAssemblyDesc; if (assemblyDesc != null) { var assemblyName = assemblyDesc.GetName(); scopeDefinition.Name = HandleString(assemblyName.Name); #if NETFX_45 // With NET 4.5 contract System.Reflection 4.0.0.0 EcmaModule has no way // to set Culture in its AssemblyName. scopeDefinition.Culture = HandleString(assemblyName.CultureName ?? ""); #else scopeDefinition.Culture = HandleString(assemblyName.CultureName); #endif scopeDefinition.MajorVersion = checked ((ushort)assemblyName.Version.Major); scopeDefinition.MinorVersion = checked ((ushort)assemblyName.Version.Minor); scopeDefinition.BuildNumber = checked ((ushort)assemblyName.Version.Build); scopeDefinition.RevisionNumber = checked ((ushort)assemblyName.Version.Revision); Debug.Assert((int)AssemblyFlags.PublicKey == (int)AssemblyNameFlags.PublicKey); Debug.Assert((int)AssemblyFlags.Retargetable == (int)AssemblyNameFlags.Retargetable); scopeDefinition.Flags = (AssemblyFlags)assemblyName.Flags; if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime) { scopeDefinition.Flags |= (AssemblyFlags)((int)AssemblyContentType.WindowsRuntime << 9); } if ((scopeDefinition.Flags & AssemblyFlags.PublicKey) != 0) { scopeDefinition.PublicKey = assemblyName.GetPublicKey(); } else { scopeDefinition.PublicKey = assemblyName.GetPublicKeyToken(); } Cts.MetadataType moduleType = module.GetGlobalModuleType(); if (moduleType != null && _policy.GeneratesMetadata(moduleType)) { scopeDefinition.GlobalModuleType = (TypeDefinition)HandleType(moduleType); } Cts.Ecma.EcmaAssembly ecmaAssembly = module as Cts.Ecma.EcmaAssembly; if (ecmaAssembly != null) { Ecma.CustomAttributeHandleCollection customAttributes = ecmaAssembly.AssemblyDefinition.GetCustomAttributes(); if (customAttributes.Count > 0) { scopeDefinition.CustomAttributes = HandleCustomAttributes(ecmaAssembly, customAttributes); } Cts.MethodDesc entryPoint = ecmaAssembly.EntryPoint; if (entryPoint != null && _policy.GeneratesMetadata(entryPoint)) { scopeDefinition.EntryPoint = (QualifiedMethod)HandleQualifiedMethod(entryPoint); } Ecma.MetadataReader reader = ecmaAssembly.MetadataReader; Ecma.ModuleDefinition moduleDefinition = reader.GetModuleDefinition(); scopeDefinition.ModuleName = HandleString(reader.GetString(moduleDefinition.Name)); scopeDefinition.Mvid = reader.GetGuid(moduleDefinition.Mvid).ToByteArray(); // This is rather awkward because ModuleDefinition doesn't offer means to get to the custom attributes Ecma.CustomAttributeHandleCollection moduleAttributes = reader.GetCustomAttributes(Ecma.Ecma335.MetadataTokens.EntityHandle(0x1)); if (moduleAttributes.Count > 0) { scopeDefinition.ModuleCustomAttributes = HandleCustomAttributes(ecmaAssembly, moduleAttributes); } HandleTypeForwarders(ecmaAssembly); } } else { throw new NotSupportedException("Multi-module assemblies"); } }
private Event HandleEvent(Cts.Ecma.EcmaModule module, Ecma.EventDefinitionHandle eventHandle) { Ecma.MetadataReader reader = module.MetadataReader; Ecma.EventDefinition eventDef = reader.GetEventDefinition(eventHandle); Ecma.EventAccessors acc = eventDef.GetAccessors(); Cts.MethodDesc adderMethod = acc.Adder.IsNil ? null : module.GetMethod(acc.Adder); Cts.MethodDesc raiserMethod = acc.Raiser.IsNil ? null : module.GetMethod(acc.Raiser); Cts.MethodDesc removerMethod = acc.Remover.IsNil ? null : module.GetMethod(acc.Remover); bool adderHasMetadata = adderMethod != null && _policy.GeneratesMetadata(adderMethod); bool raiserHasMetadata = raiserMethod != null && _policy.GeneratesMetadata(raiserMethod); bool removerHasMetadata = removerMethod != null && _policy.GeneratesMetadata(removerMethod); // Policy: If none of the accessors has metadata, event doesn't have metadata if (!adderHasMetadata && !raiserHasMetadata && !removerHasMetadata) { return(null); } Event result = new Event { Name = HandleString(reader.GetString(eventDef.Name)), Flags = eventDef.Attributes, Type = HandleType(module.GetType(eventDef.Type)), }; if (adderHasMetadata) { result.MethodSemantics.Add(new MethodSemantics { Attributes = MethodSemanticsAttributes.AddOn, Method = HandleMethodDefinition(adderMethod), }); } if (raiserHasMetadata) { result.MethodSemantics.Add(new MethodSemantics { Attributes = MethodSemanticsAttributes.Fire, Method = HandleMethodDefinition(raiserMethod), }); } if (removerHasMetadata) { result.MethodSemantics.Add(new MethodSemantics { Attributes = MethodSemanticsAttributes.RemoveOn, Method = HandleMethodDefinition(removerMethod), }); } Ecma.CustomAttributeHandleCollection customAttributes = eventDef.GetCustomAttributes(); if (customAttributes.Count > 0) { result.CustomAttributes = HandleCustomAttributes(module, customAttributes); } return(result); }
static bool IsSameType(SRM.MetadataReader referenceMetadata, SRM.EntityHandle typeRef, SRM.MetadataReader definitionMetadata, SRM.TypeDefinitionHandle typeDef) { // FullName contains only namespace, name and type parameter count, therefore this should suffice. return(typeRef.GetFullTypeName(referenceMetadata) == typeDef.GetFullTypeName(definitionMetadata)); }
public TypeDesc GetTypeFromSpecification(MetadataReader reader, GenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { return(new TypeDesc()); }
public TypeDesc GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) => TypeDesc.FromInfo(_resolver.ResolveReference(_resolver.GetInfoFromReader(reader), handle));
private void InitializeMethodDefinition(Cts.MethodDesc entity, Method record) { record.Name = HandleString(entity.Name); record.Signature = HandleMethodSignature(entity.Signature); if (entity.HasInstantiation) { record.GenericParameters.Capacity = entity.Instantiation.Length; foreach (var p in entity.Instantiation) { record.GenericParameters.Add(HandleGenericParameter((Cts.GenericParameterDesc)p)); } } var ecmaEntity = entity as Cts.Ecma.EcmaMethod; if (ecmaEntity != null) { Ecma.MetadataReader reader = ecmaEntity.MetadataReader; Ecma.MethodDefinition methodDef = reader.GetMethodDefinition(ecmaEntity.Handle); Ecma.ParameterHandleCollection paramHandles = methodDef.GetParameters(); record.Parameters.Capacity = paramHandles.Count; foreach (var paramHandle in paramHandles) { Ecma.Parameter param = reader.GetParameter(paramHandle); Parameter paramRecord = new Parameter { Flags = param.Attributes, Name = HandleString(reader.GetString(param.Name)), Sequence = checked ((ushort)param.SequenceNumber) }; Ecma.ConstantHandle defaultValue = param.GetDefaultValue(); if (!defaultValue.IsNil) { paramRecord.DefaultValue = HandleConstant(ecmaEntity.Module, defaultValue); } Ecma.CustomAttributeHandleCollection paramAttributes = param.GetCustomAttributes(); if (paramAttributes.Count > 0) { paramRecord.CustomAttributes = HandleCustomAttributes(ecmaEntity.Module, paramAttributes); } record.Parameters.Add(paramRecord); } Ecma.CustomAttributeHandleCollection attributes = methodDef.GetCustomAttributes(); if (attributes.Count > 0) { record.CustomAttributes = HandleCustomAttributes(ecmaEntity.Module, attributes); } } else { throw new NotImplementedException(); } record.Flags = GetMethodAttributes(entity); record.ImplFlags = GetMethodImplAttributes(entity); //TODO: RVA }
private Property HandleProperty(Cts.Ecma.EcmaModule module, Ecma.PropertyDefinitionHandle property) { Ecma.MetadataReader reader = module.MetadataReader; Ecma.PropertyDefinition propDef = reader.GetPropertyDefinition(property); Ecma.PropertyAccessors acc = propDef.GetAccessors(); Cts.MethodDesc getterMethod = acc.Getter.IsNil ? null : module.GetMethod(acc.Getter); Cts.MethodDesc setterMethod = acc.Setter.IsNil ? null : module.GetMethod(acc.Setter); bool getterHasMetadata = getterMethod != null && _policy.GeneratesMetadata(getterMethod); bool setterHasMetadata = setterMethod != null && _policy.GeneratesMetadata(setterMethod); // Policy: If neither the getter nor setter have metadata, property doesn't have metadata if (!getterHasMetadata && !setterHasMetadata) { return(null); } Ecma.BlobReader sigBlobReader = reader.GetBlobReader(propDef.Signature); Cts.PropertySignature sig = new Cts.Ecma.EcmaSignatureParser(module, sigBlobReader, Cts.NotFoundBehavior.Throw).ParsePropertySignature(); Property result = new Property { Name = HandleString(reader.GetString(propDef.Name)), Flags = propDef.Attributes, Signature = new PropertySignature { CallingConvention = sig.IsStatic ? CallingConventions.Standard : CallingConventions.HasThis, Type = HandleType(sig.ReturnType) }, }; result.Signature.Parameters.Capacity = sig.Length; for (int i = 0; i < sig.Length; i++) { result.Signature.Parameters.Add(HandleType(sig[i])); } if (getterHasMetadata) { result.MethodSemantics.Add(new MethodSemantics { Attributes = MethodSemanticsAttributes.Getter, Method = HandleMethodDefinition(getterMethod), }); } if (setterHasMetadata) { result.MethodSemantics.Add(new MethodSemantics { Attributes = MethodSemanticsAttributes.Setter, Method = HandleMethodDefinition(setterMethod), }); } Ecma.ConstantHandle defaultValue = propDef.GetDefaultValue(); if (!defaultValue.IsNil) { result.DefaultValue = HandleConstant(module, defaultValue); } Ecma.CustomAttributeHandleCollection customAttributes = propDef.GetCustomAttributes(); if (customAttributes.Count > 0) { result.CustomAttributes = HandleCustomAttributes(module, customAttributes); } return(result); }
private MetadataRecord HandleConstant(Cts.Ecma.EcmaModule module, Ecma.ConstantHandle constantHandle) { Ecma.MetadataReader reader = module.MetadataReader; Ecma.Constant constant = reader.GetConstant(constantHandle); Ecma.BlobReader blob = reader.GetBlobReader(constant.Value); switch (constant.TypeCode) { case ConstantTypeCode.Boolean: return(new ConstantBooleanValue { Value = blob.ReadBoolean() }); case ConstantTypeCode.Byte: return(new ConstantByteValue { Value = blob.ReadByte() }); case ConstantTypeCode.Char: return(new ConstantCharValue { Value = blob.ReadChar() }); case ConstantTypeCode.Double: return(new ConstantDoubleValue { Value = blob.ReadDouble() }); case ConstantTypeCode.Int16: return(new ConstantInt16Value { Value = blob.ReadInt16() }); case ConstantTypeCode.Int32: return(new ConstantInt32Value { Value = blob.ReadInt32() }); case ConstantTypeCode.Int64: return(new ConstantInt64Value { Value = blob.ReadInt64() }); case ConstantTypeCode.SByte: return(new ConstantSByteValue { Value = blob.ReadSByte() }); case ConstantTypeCode.Single: return(new ConstantSingleValue { Value = blob.ReadSingle() }); case ConstantTypeCode.String: return(HandleString(blob.ReadUTF16(blob.Length))); case ConstantTypeCode.UInt16: return(new ConstantUInt16Value { Value = blob.ReadUInt16() }); case ConstantTypeCode.UInt32: return(new ConstantUInt32Value { Value = blob.ReadUInt32() }); case ConstantTypeCode.UInt64: return(new ConstantUInt64Value { Value = blob.ReadUInt64() }); case ConstantTypeCode.NullReference: return(new ConstantReferenceValue()); default: throw new BadImageFormatException(); } }