public CodeReader(Section section, MetadataReader reader, Dictionary<uint, DumpedMethod> dumpedMethods = null) : base(section.Data) { this.code_section = section; this.reader = reader; this.dumpedMethods = dumpedMethods; }
public static bool IsTypeDefRefOrSpecHandle(this Handle handle, MetadataReader reader) { HandleType handleType = handle.HandleType; return handleType == HandleType.TypeDefinition || handleType == HandleType.TypeReference || handleType == HandleType.TypeSpecification; }
//wicky.patch.start: add support to read directly from bytes, contributed by HaRpy public CodeReader(MethodDefinition method, byte[] bytes):base(bytes) { this.method = method; this.reader = method.DeclaringType.Module.reader; this.code_section = null; //code_section could be null for obfuscated assembly this.isReadFromBytes = true; }
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata( MetadataReader reader, ConstantStringValueHandle name, ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revisionNumber, ConstantStringValueHandle culture, IEnumerable<byte> publicKeyOrToken, AssemblyFlags assemblyFlags) { AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None; if (0 != (assemblyFlags & AssemblyFlags.PublicKey)) assemblyNameFlags |= AssemblyNameFlags.PublicKey; if (0 != (assemblyFlags & AssemblyFlags.Retargetable)) assemblyNameFlags |= AssemblyNameFlags.Retargetable; int contentType = ((int)assemblyFlags) & 0x00000E00; assemblyNameFlags |= (AssemblyNameFlags)contentType; ArrayBuilder<byte> keyOrTokenArrayBuilder = new ArrayBuilder<byte>(); foreach (byte b in publicKeyOrToken) keyOrTokenArrayBuilder.Add(b); return new RuntimeAssemblyName( name.GetString(reader), new Version(majorVersion, minorVersion, buildNumber, revisionNumber), culture.GetStringOrNull(reader), assemblyNameFlags, keyOrTokenArrayBuilder.ToArray() ); }
internal RuntimeGenericParameterType(MetadataReader reader, GenericParameterHandle genericParameterHandle) { _reader = reader; _genericParameterHandle = genericParameterHandle; _genericParameter = _genericParameterHandle.GetGenericParameter(_reader); _position = _genericParameter.Number; }
public static bool GetDefaultValueIfAny(MemberType memberType, MetadataReader reader, Handle constantHandle, Type declaredType, IEnumerable<CustomAttributeData> customAttributes, out Object defaultValue) { if (!(constantHandle.IsNull(reader))) { defaultValue = ParseMetadataConstant(reader, constantHandle); if (declaredType.GetTypeInfo().IsEnum) defaultValue = Enum.ToObject(declaredType, defaultValue); return true; } if (memberType != MemberType.Property) // the attributes in question cannot be applied to properties. { // Legacy: If there are multiple default value attribute, the desktop picks one at random (and so do we...) foreach (CustomAttributeData cad in customAttributes) { Type attributeType = cad.AttributeType; TypeInfo attributeTypeInfo = attributeType.GetTypeInfo(); if (attributeTypeInfo.IsSubclassOf(typeof(CustomConstantAttribute))) { CustomConstantAttribute customConstantAttribute = (CustomConstantAttribute)(cad.Instantiate()); defaultValue = customConstantAttribute.Value; return true; } if (attributeType.Equals(typeof(DecimalConstantAttribute))) { DecimalConstantAttribute decimalConstantAttribute = (DecimalConstantAttribute)(cad.Instantiate()); defaultValue = decimalConstantAttribute.Value; return true; } } } defaultValue = null; return false; }
public static bool CompareTypeReferenceToDefinition(TypeReferenceHandle tr1, MetadataReader mr1, TypeDefinitionHandle td2, MetadataReader mr2) { // TODO! The correct implementation here is probably to call into the assembly binder, but that's not available due to layering. // For now, just implement comparison, which will be equivalent in all cases until we support loading multiple copies of the same assembly TypeReference trData1 = mr1.GetTypeReference(tr1); TypeDefinition tdData2 = mr2.GetTypeDefinition(td2); if (!trData1.TypeName.StringEquals(tdData2.Name.GetConstantStringValue(mr2).Value, mr1)) return false; switch (trData1.ParentNamespaceOrType.HandleType) { case HandleType.TypeReference: if (tdData2.EnclosingType.IsNull(mr2)) return false; return CompareTypeReferenceToDefinition(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, tdData2.EnclosingType, mr2); case HandleType.NamespaceReference: return CompareNamespaceReferenceToDefinition(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, tdData2.NamespaceDefinition, mr2); default: Debug.Assert(false); throw new BadImageFormatException(); } }
public CodeReader (MethodDefinition method, MetadataReader reader) : base (reader.image.Stream) { this.reader = reader; this.reader.context = method; this.Position = (int) reader.image.ResolveVirtualAddress ((uint) method.RVA); }
private RuntimeFatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position, reflectionDomain, reader, typeHandle, typeContext) { _methodHandle = methodHandle; _parameterHandle = parameterHandle; _parameter = parameterHandle.GetParameter(reader); }
public static string GetFullName(this Handle handle, MetadataReader reader) { switch (handle.HandleType) { case HandleType.TypeDefinition: return handle.ToTypeDefinitionHandle(reader).GetFullName(reader); case HandleType.TypeReference: return handle.ToTypeReferenceHandle(reader).GetFullName(reader); case HandleType.NamespaceDefinition: return handle.ToNamespaceDefinitionHandle(reader).GetFullName(reader); case HandleType.NamespaceReference: return handle.ToNamespaceReferenceHandle(reader).GetFullName(reader); case HandleType.TypeSpecification: return handle.ToTypeSpecificationHandle(reader).GetFullName(reader); case HandleType.TypeInstantiationSignature: return handle.ToTypeInstantiationSignatureHandle(reader).GetFullName(reader); case HandleType.ArraySignature: return handle.ToArraySignatureHandle(reader).GetFullName(reader); case HandleType.SZArraySignature: return handle.ToSZArraySignatureHandle(reader).GetFullName(reader); case HandleType.PointerSignature: return handle.ToPointerSignatureHandle(reader).GetFullName(reader); case HandleType.ByReferenceSignature: return handle.ToByReferenceSignatureHandle(reader).GetFullName(reader); } return null; }
public static string GetFullName(this ArraySignatureHandle handle, MetadataReader reader) { ArraySignature array = handle.GetArraySignature(reader); var result = array.ElementType.GetFullName(reader); if (result == null) return null; return result + "[" + (new string(',', array.Rank - 1)) + "]"; }
public static TypeDefinitionHandle FindTestType(MetadataReader reader, Type type) { if (type.DeclaringType == null) { foreach (TypeDefinitionHandle handle in reader.TypeDefinitions) { TypeDefinition definition = reader.GetTypeDefinition(handle); if (reader.StringComparer.Equals(definition.Namespace, type.Namespace) && reader.StringComparer.Equals(definition.Name, type.Name)) { return handle; } } } else { TypeDefinitionHandle declaringHandle = FindTestType(reader, type.DeclaringType); TypeDefinition declaringDefinition = reader.GetTypeDefinition(declaringHandle); foreach (TypeDefinitionHandle handle in declaringDefinition.GetNestedTypes()) { TypeDefinition definition = reader.GetTypeDefinition(handle); if (reader.StringComparer.Equals(definition.Name, type.Name)) { return handle; } } } Assert.True(false, "Cannot find test type:" + type); return default(TypeDefinitionHandle); }
protected RuntimeMethodParameterInfo(MethodBase member, int position, ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position) { _reflectionDomain = reflectionDomain; Reader = reader; _typeHandle = typeHandle; _typeContext = typeContext; }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeType Resolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext) { Exception exception = null; RuntimeType runtimeType = reflectionDomain.TryResolve(reader, typeDefRefOrSpec, typeContext, ref exception); if (runtimeType == null) throw exception; return runtimeType; }
public static bool StringOrNullEquals(this ConstantStringValueHandle handle, String valueOrNull, MetadataReader reader) { if (valueOrNull == null) return handle.IsNull(reader); if (handle.IsNull(reader)) return false; return handle.StringEquals(valueOrNull, reader); }
public static MethodBody ReadMethodBody (MethodDefinition method, MetadataReader metadata) { var reader = new CodeReader (method, metadata); reader.body = new MethodBody (method); reader.ReadMethodBody (); return reader.body; }
public static string GetFullName(this TypeSpecificationHandle typeSpecHandle, MetadataReader reader) { var typeSpec = typeSpecHandle.GetTypeSpecification(reader); if (typeSpec.Signature.IsNull(reader)) return null; return typeSpec.Signature.GetFullName(reader); }
private List<CustomAttributeHandle> GetCustomAttributes(MetadataReader reader, int token) { var attributes = new List<CustomAttributeHandle>(); foreach (var caHandle in reader.GetCustomAttributes(new EntityHandle((uint)token))) { attributes.Add(caHandle); } return attributes; }
internal NamespaceChain(MetadataReader reader, NamespaceDefinitionHandle innerMostNamespaceHandle) { NamespaceDefinition currentNamespaceDefinition = innerMostNamespaceHandle.GetNamespaceDefinition(reader); ConstantStringValueHandle currentNameHandle = currentNamespaceDefinition.Name; Handle currentNamespaceHandle = innerMostNamespaceHandle.ToHandle(reader); LowLevelList<String> names = new LowLevelList<String>(); for (; ;) { String name = currentNameHandle.GetStringOrNull(reader); names.Add(name); currentNamespaceHandle = currentNamespaceDefinition.ParentScopeOrNamespace; HandleType handleType = currentNamespaceHandle.HandleType; if (handleType == HandleType.ScopeDefinition) break; if (handleType == HandleType.NamespaceDefinition) { NamespaceDefinitionHandle nsHandle = currentNamespaceHandle.ToNamespaceDefinitionHandle(reader); currentNamespaceDefinition = nsHandle.GetNamespaceDefinition(reader); currentNameHandle = currentNamespaceDefinition.Name; continue; } throw new BadImageFormatException(SR.Bif_InvalidMetadata); } DefiningScope = currentNamespaceHandle.ToScopeDefinitionHandle(reader); int count = names.Count; if (count == 0) { // Every namespace chain has to start with the root namespace. throw new BadImageFormatException(); } else if (count == 1) { // The root namespace. For compat with the desktop, TypeInfo.NameSpaces returns null in this case. NameSpace = null; } else { // Namespace has at least one non-root component. StringBuilder sb = new StringBuilder(); int idx = count - 1; while (idx-- != 0) { String name = names[idx]; if (name == null) throw new BadImageFormatException(); // null namespace fragment found in middle. sb.Append(name); if (idx != 0) sb.Append('.'); } NameSpace = sb.ToString(); } }
/// <summary> /// Locate reflection blob in a given module and construct its metadata reader. /// </summary> /// <param name="moduleHandle">Module handle to register</param> unsafe void CreateMetadataReader(IntPtr moduleHandle) { uint* pBlob; uint cbBlob; if (RuntimeAugments.FindBlob(moduleHandle, (int)ReflectionMapBlob.EmbeddedMetadata, (IntPtr)(&pBlob), (IntPtr)(&cbBlob))) { MetadataReader reader = new MetadataReader((IntPtr)pBlob, (int)cbBlob); _moduleToMetadataReader.Add(moduleHandle, reader); } }
// // Creates the appropriate flavor of Invoker depending on the calling convention "shape" (static, instance or virtual.) // internal static MethodInvoker CreateMethodInvoker(MetadataReader reader, RuntimeTypeHandle declaringTypeHandle, MethodHandle methodHandle, MethodInvokeInfo methodInvokeInfo) { Method method = methodHandle.GetMethod(reader); MethodAttributes methodAttributes = method.Flags; if (0 != (methodAttributes & MethodAttributes.Static)) return new StaticMethodInvoker(methodInvokeInfo); else if (methodInvokeInfo.VirtualResolveData != IntPtr.Zero) return new VirtualMethodInvoker(methodInvokeInfo, declaringTypeHandle); else return new InstanceMethodInvoker(methodInvokeInfo, declaringTypeHandle); }
internal static RuntimeType TryResolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext, ref Exception exception) { HandleType handleType = typeDefRefOrSpec.HandleType; if (handleType == HandleType.TypeDefinition) return reflectionDomain.ResolveTypeDefinition(reader, typeDefRefOrSpec.ToTypeDefinitionHandle(reader)); else if (handleType == HandleType.TypeReference) return reflectionDomain.TryResolveTypeReference(reader, typeDefRefOrSpec.ToTypeReferenceHandle(reader), ref exception); else if (handleType == HandleType.TypeSpecification) return reflectionDomain.TryResolveTypeSignature(reader, typeDefRefOrSpec.ToTypeSpecificationHandle(reader), typeContext, ref exception); else throw new BadImageFormatException(); // Expected TypeRef, Def or Spec. }
public NullableInstanceMethodInvoker(MetadataReader reader, MethodHandle methodHandle, RuntimeTypeHandle nullableTypeHandle, MethodInvokeInfo methodInvokeInfo) { _id = NullableMethodId.None; _nullableTypeHandle = nullableTypeHandle; Method method = methodHandle.GetMethod(reader); if (MethodAttributes.Public == (method.Flags & MethodAttributes.MemberAccessMask)) { // Note: Since we control the definition of Nullable<>, we're not checking signatures here. String name = method.Name.GetConstantStringValue(reader).Value; switch (name) { case "GetType": _id = NullableMethodId.GetType; break; case "ToString": _id = NullableMethodId.ToString; break; case "Equals": _id = NullableMethodId.Equals; break; case "GetHashCode": _id = NullableMethodId.GetHashCode; break; case ".ctor": _id = NullableMethodId.Ctor; break; case "get_HasValue": _id = NullableMethodId.get_HasValue; break; case "get_Value": _id = NullableMethodId.get_Value; break; case "GetValueOrDefault": IEnumerator<ParameterTypeSignatureHandle> parameters = method.Signature.GetMethodSignature(reader).Parameters.GetEnumerator(); if (parameters.MoveNext()) _id = NullableMethodId.GetValueOrDefault_1; else _id = NullableMethodId.GetValueOrDefault_0; break; default: break; } } }
private static Object ParseMetadataConstant(MetadataReader reader, Handle handle) { switch (handle.HandleType) { case HandleType.ConstantBooleanValue: return handle.ToConstantBooleanValueHandle(reader).GetConstantBooleanValue(reader).Value; case HandleType.ConstantStringValue: return handle.ToConstantStringValueHandle(reader).GetConstantStringValue(reader).Value; case HandleType.ConstantCharValue: return handle.ToConstantCharValueHandle(reader).GetConstantCharValue(reader).Value; case HandleType.ConstantByteValue: return handle.ToConstantByteValueHandle(reader).GetConstantByteValue(reader).Value; case HandleType.ConstantSByteValue: return handle.ToConstantSByteValueHandle(reader).GetConstantSByteValue(reader).Value; case HandleType.ConstantInt16Value: return handle.ToConstantInt16ValueHandle(reader).GetConstantInt16Value(reader).Value; case HandleType.ConstantUInt16Value: return handle.ToConstantUInt16ValueHandle(reader).GetConstantUInt16Value(reader).Value; case HandleType.ConstantInt32Value: return handle.ToConstantInt32ValueHandle(reader).GetConstantInt32Value(reader).Value; case HandleType.ConstantUInt32Value: return handle.ToConstantUInt32ValueHandle(reader).GetConstantUInt32Value(reader).Value; case HandleType.ConstantInt64Value: return handle.ToConstantInt64ValueHandle(reader).GetConstantInt64Value(reader).Value; case HandleType.ConstantUInt64Value: return handle.ToConstantUInt64ValueHandle(reader).GetConstantUInt64Value(reader).Value; case HandleType.ConstantSingleValue: return handle.ToConstantSingleValueHandle(reader).GetConstantSingleValue(reader).Value; case HandleType.ConstantDoubleValue: return handle.ToConstantDoubleValueHandle(reader).GetConstantDoubleValue(reader).Value; case HandleType.ConstantReferenceValue: return null; default: throw new BadImageFormatException(); } }
public static bool CompareTypeReferenceAcrossModules(TypeReferenceHandle tr1, MetadataReader mr1, TypeReferenceHandle tr2, MetadataReader mr2) { TypeReference trData1 = mr1.GetTypeReference(tr1); TypeReference trData2 = mr2.GetTypeReference(tr2); if (!trData1.TypeName.StringEquals(trData2.TypeName.GetConstantStringValue(mr2).Value, mr1)) return false; if (trData1.ParentNamespaceOrType.HandleType != trData2.ParentNamespaceOrType.HandleType) return false; if (trData1.ParentNamespaceOrType.HandleType == HandleType.TypeReference) return CompareTypeReferenceAcrossModules(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, trData2.ParentNamespaceOrType.ToTypeReferenceHandle(mr2), mr2); return CompareNamespaceReferenceAcrossModules(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, trData2.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr2), mr2); }
/// <summary> /// Construct a comparer between NativeFormat metadata methods and native layouts /// </summary> /// <param name="metadataReader">Metadata reader for the method declaring type</param> /// <param name="methodHandle">Handle of method to compare</param> public MethodSignatureComparer( MetadataReader metadataReader, MethodHandle methodHandle) { _metadataReader = metadataReader; _methodHandle = methodHandle; _method = methodHandle.GetMethod(metadataReader); _methodSignature = _method.Signature.GetMethodSignature(_metadataReader); _isGeneric = (_methodSignature.GenericParameterCount != 0); // Precalculate initial method attributes used in signature queries _isStatic = (_method.Flags & MethodAttributes.Static) != 0; }
public static RuntimeAssemblyName ToRuntimeAssemblyName(this ScopeDefinitionHandle scopeDefinitionHandle, MetadataReader reader) { ScopeDefinition scopeDefinition = scopeDefinitionHandle.GetScopeDefinition(reader); return CreateRuntimeAssemblyNameFromMetadata( reader, scopeDefinition.Name, scopeDefinition.MajorVersion, scopeDefinition.MinorVersion, scopeDefinition.BuildNumber, scopeDefinition.RevisionNumber, scopeDefinition.Culture, scopeDefinition.PublicKey, scopeDefinition.Flags ); }
protected RuntimeInspectionOnlyNamedType(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle) : base() { #if DEBUG if (!(this.InternalViolatesTypeIdentityRules)) { RuntimeTypeHandle runtimeTypeHandle; if (ReflectionCoreExecution.ExecutionEnvironment.TryGetNamedTypeForMetadata(reader, typeDefinitionHandle, out runtimeTypeHandle)) Debug.Assert(false, "Type identity violation: You must use a RuntimeEENamedType to represent this type as RH has generated an EEType for it."); } #endif _reader = reader; _typeDefinitionHandle = typeDefinitionHandle; _typeDefinition = _typeDefinitionHandle.GetTypeDefinition(_reader); }
private static int MapVirtualHandleRowId(MetadataReader reader, Handle handle) { switch (handle.Kind) { case HandleKind.AssemblyReference: // pretend that virtual rows immediately follow real rows: return reader.AssemblyRefTable.NumberOfNonVirtualRows + 1 + handle.RowId; case HandleKind.String: case HandleKind.Blob: // We could precalculate offsets for virtual strings and blobs as we are creating them // if we wanted to implement this. throw new NotSupportedException(SR.CantGetOffsetForVirtualHeapHandle); default: throw new ArgumentException(SR.InvalidHandle, "handle"); } }
// // This is a port of the desktop CLR's RuntimeType.FormatTypeName() routine. This routine is used by various Reflection ToString() methods // to display the name of a type. Do not use for any other purpose as it inherits some pretty quirky desktop behavior. // // The Project N version takes a raw metadata handle rather than a completed type so that it remains robust in the face of missing metadata. // public static String FormatTypeName(this Handle typeDefRefOrSpecHandle, MetadataReader reader, TypeContext typeContext, ReflectionDomain reflectionDomain) { try { // Though we wrap this in a try-catch as a failsafe, this code must still strive to avoid triggering MissingMetadata exceptions // (non-error exceptions are very annoying when debugging.) Exception exception = null; RuntimeType runtimeType = reflectionDomain.TryResolve(reader, typeDefRefOrSpecHandle, typeContext, ref exception); if (runtimeType == null) return UnavailableType; // Because this runtimeType came from a successful TryResolve() call, it is safe to querying the TypeInfo's of the type and its component parts. // If we're wrong, we do have the safety net of a try-catch. return runtimeType.FormatTypeName(); } catch (Exception) { return UnavailableType; } }
public override bool HasCustomAttribute(string attributeNamespace, string attributeName) { return(MetadataReader.HasCustomAttribute(MetadataReader.GetMethod(_handle).CustomAttributes, attributeNamespace, attributeName)); }
public MemberMetadataInfo GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code) { return(GetTypeFromDefinition(handle)); }
public DummyTypeProvider(MetadataReader reader) { Reader = reader; }
private static Handle GetAttributeTypeHandle(this CustomAttribute customAttribute, MetadataReader reader) { HandleType constructorHandleType = customAttribute.Constructor.HandleType; if (constructorHandleType == HandleType.QualifiedMethod) { return(customAttribute.Constructor.ToQualifiedMethodHandle(reader).GetQualifiedMethod(reader).EnclosingType); } else if (constructorHandleType == HandleType.MemberReference) { return(customAttribute.Constructor.ToMemberReferenceHandle(reader).GetMemberReference(reader).Parent); } else { throw new BadImageFormatException(); } }
private static string GetTargetFrameworkString(CustomAttribute targetFrameworkAttribute, MetadataReader metadataReader) { var blobReader = metadataReader.GetBlobReader(targetFrameworkAttribute.Value); // I'm not sure if this is IL, or just a list of arguments, but the first value is a 16-bit number with the value 1 blobReader.ReadInt16(); // Next is the string passed to the TargetFrameworkAttribute constructor return(blobReader.ReadSerializedString()); }
public string GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) => handle.ToTypeString(reader);
public VarInfo(Parameter p, MetadataReader pdbReader) { this.Name = pdbReader.GetString(p.Name); this.Index = (p.SequenceNumber) * -1; }
public VarInfo(LocalVariable v, MetadataReader pdbReader) { this.Name = pdbReader.GetString(v.Name); this.Index = v.Index; }
public TypeInfo(MetadataReader metadataReader, THandle handle) { MetadataReader = metadataReader; Handle = handle; }
private void AddScopesFromReaderToGroups(LowLevelDictionaryWithIEnumerable <string, ScopeDefinitionGroup> groups, MetadataReader reader) { foreach (ScopeDefinitionHandle scopeDefinitionHandle in reader.ScopeDefinitions) { AssemblyName defName = this.CreateAssemblyNameFromMetadata(reader, scopeDefinitionHandle); string defFullName = defName.FullName; ScopeDefinitionGroup scopeDefinitionGroup; if (groups.TryGetValue(defFullName, out scopeDefinitionGroup)) { scopeDefinitionGroup.AddOverflowScope(new QScopeDefinition(reader, scopeDefinitionHandle)); } else { scopeDefinitionGroup = new ScopeDefinitionGroup(new QScopeDefinition(reader, scopeDefinitionHandle)); groups.Add(defFullName, scopeDefinitionGroup); } } }
public string GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind) => handle.ToTypeString(reader);
internal new AssemblyName CreateAssemblyNameFromMetadata(MetadataReader reader, ScopeDefinitionHandle scopeDefinitionHandle) { return(base.CreateAssemblyNameFromMetadata(reader, scopeDefinitionHandle)); }
public MethodInfo(AssemblyInfo assembly, MethodDefinitionHandle methodDefHandle, int token, SourceFile source, TypeInfo type, MetadataReader asmMetadataReader, MetadataReader pdbMetadataReader) { this.Assembly = assembly; this.methodDef = asmMetadataReader.GetMethodDefinition(methodDefHandle); this.DebugInformation = pdbMetadataReader.GetMethodDebugInformation(methodDefHandle.ToDebugInformationHandle()); this.source = source; this.Token = token; this.methodDefHandle = methodDefHandle; this.Name = asmMetadataReader.GetString(methodDef.Name); this.pdbMetadataReader = pdbMetadataReader; this.IsEnCMethod = false; if (!DebugInformation.SequencePointsBlob.IsNil) { var sps = DebugInformation.GetSequencePoints(); SequencePoint start = sps.First(); SequencePoint end = sps.First(); foreach (SequencePoint sp in sps) { if (sp.StartLine < start.StartLine) { start = sp; } else if (sp.StartLine == start.StartLine && sp.StartColumn < start.StartColumn) { start = sp; } if (sp.EndLine > end.EndLine) { end = sp; } else if (sp.EndLine == end.EndLine && sp.EndColumn > end.EndColumn) { end = sp; } } StartLocation = new SourceLocation(this, start); EndLocation = new SourceLocation(this, end); } localScopes = pdbMetadataReader.GetLocalScopes(methodDefHandle); }
public MemberMetadataInfo GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, SignatureTypeHandleCode code) { return(GetFullName(handle)); }
IAssemblyMetadata IAssemblyResolver.FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile) { EcmaAssembly ecmaAssembly = (EcmaAssembly)this.GetModuleForSimpleName(metadataReader.GetString(metadataReader.GetAssemblyReference(assemblyReferenceHandle).Name), false); return(new StandaloneAssemblyMetadata(ecmaAssembly.PEReader)); }
protected sealed override AssemblyNameData ComputeNameData() { MetadataReader reader = Reader; AssemblyDefinition ad = AssemblyDefinition; AssemblyNameData data = new AssemblyNameData(); data.Name = ad.Name.GetString(reader); data.Version = ad.Version; data.CultureName = ad.Culture.GetStringOrNull(reader) ?? string.Empty; byte[] pk = ad.PublicKey.GetBlobBytes(reader); data.PublicKey = pk; if (pk.Length != 0) { // AssemblyName will automatically compute the PKT on demand but given that we're doing all this work and caching it, we might // as well do this now. data.PublicKeyToken = pk.ComputePublicKeyToken(); } AssemblyNameFlags anFlagsAndContentType = ad.Flags.ToAssemblyNameFlags() | AssemblyNameFlags.PublicKey; data.Flags = anFlagsAndContentType.ExtractAssemblyNameFlags(); // We've finished setting the AssemblyName properties that actually pertain to binding and the Ecma-355 // concept of an assembly name. // // The rest of the properties are properties historically set by the runtime Reflection and thumbtacked // onto the AssemblyName object in the CLR tradition of treating AssemblyName as a dumping ground for all // kinds of info. Nevertheless, some of this info is potentially useful and not exposed elsewhere on Assembly // so we'll be nice and set it. data.HashAlgorithm = ad.HashAlgorithm.ToConfigurationAssemblyHashAlgorithm(); data.ContentType = anFlagsAndContentType.ExtractAssemblyContentType(); ManifestModule.GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine); switch (machine) { case ImageFileMachine.AMD64: data.ProcessorArchitecture = ProcessorArchitecture.Amd64; break; case ImageFileMachine.ARM: data.ProcessorArchitecture = ProcessorArchitecture.Arm; break; case ImageFileMachine.IA64: data.ProcessorArchitecture = ProcessorArchitecture.IA64; break; case ImageFileMachine.I386: if ((peKind & PortableExecutableKinds.Required32Bit) != 0) { data.ProcessorArchitecture = ProcessorArchitecture.X86; } else { data.ProcessorArchitecture = ProcessorArchitecture.MSIL; } break; default: // No real precedent for what to do here - CLR will never get as far as giving you an Assembly object // if the PE file specifies an unsupported machine. Since this Reflection implementation is a metadata inspection // layer, and the library will never make any decisions based on this value, throwing isn't really the best response here. data.ProcessorArchitecture = ProcessorArchitecture.None; break; } return(data); }
private EcmaModule AddModule(string filePath, string expectedSimpleName, bool useForBinding) { MemoryMappedViewAccessor mappedViewAccessor = null; PdbSymbolReader pdbReader = null; try { PEReader peReader = OpenPEFile(filePath, out mappedViewAccessor); pdbReader = OpenAssociatedSymbolFile(filePath, peReader); EcmaModule module = EcmaModule.Create(this, peReader, pdbReader); MetadataReader metadataReader = module.MetadataReader; string simpleName = metadataReader.GetString(metadataReader.GetAssemblyDefinition().Name); if (expectedSimpleName != null && !simpleName.Equals(expectedSimpleName, StringComparison.OrdinalIgnoreCase)) { throw new FileNotFoundException("Assembly name does not match filename " + filePath); } ModuleData moduleData = new ModuleData() { SimpleName = simpleName, FilePath = filePath, Module = module, MappedViewAccessor = mappedViewAccessor }; lock (this) { if (useForBinding) { ModuleData actualModuleData = _simpleNameHashtable.AddOrGetExisting(moduleData); if (actualModuleData != moduleData) { if (actualModuleData.FilePath != filePath) { throw new FileNotFoundException("Module with same simple name already exists " + filePath); } return(actualModuleData.Module); } } mappedViewAccessor = null; // Ownership has been transfered pdbReader = null; // Ownership has been transferred _moduleHashtable.AddOrGetExisting(moduleData); } return(module); } finally { if (mappedViewAccessor != null) { mappedViewAccessor.Dispose(); } if (pdbReader != null) { pdbReader.Dispose(); } } }
private static unsafe void VisualizeGenerationIL(MetadataVisualizer visualizer, int generationIndex, GenerationData generation, MetadataReader mdReader) { if (generation.PEReaderOpt != null) { foreach (var methodHandle in mdReader.MethodDefinitions) { var method = mdReader.GetMethodDefinition(methodHandle); var rva = method.RelativeVirtualAddress; if (rva != 0) { var body = generation.PEReaderOpt.GetMethodBody(rva); visualizer.VisualizeMethodBody(body, methodHandle); } } } else if (generation.DeltaILOpt != null) { fixed(byte *deltaILPtr = generation.DeltaILOpt) { foreach (var generationHandle in mdReader.MethodDefinitions) { var method = mdReader.GetMethodDefinition(generationHandle); var rva = method.RelativeVirtualAddress; if (rva != 0) { var body = MethodBodyBlock.Create(new BlobReader(deltaILPtr + rva, generation.DeltaILOpt.Length - rva)); visualizer.VisualizeMethodBody(body, generationHandle, generationIndex); } } } } }
private OpenedReader TryOpenReaderFromCodeView(PEReader peReader, DebugDirectoryEntry codeViewEntry, string assemblyPath) { OpenedReader result = null; MetadataReaderProvider provider = null; try { CodeViewDebugDirectoryData data = peReader.ReadCodeViewDebugDirectoryData(codeViewEntry); string pdbPath = data.Path; Stream pdbStream = null; if (assemblyPath != null) { try { pdbPath = Path.Combine(Path.GetDirectoryName(assemblyPath), GetFileName(pdbPath)); } catch { // invalid characters in CodeView path return(null); } pdbStream = TryOpenFile(pdbPath); } if (pdbStream == null) { if (_symbolService.IsSymbolStoreEnabled) { Debug.Assert(codeViewEntry.MinorVersion == ImageDebugDirectory.PortablePDBMinorVersion); SymbolStoreKey key = PortablePDBFileKeyGenerator.GetKey(pdbPath, data.Guid); pdbStream = _symbolService.GetSymbolStoreFile(key)?.Stream; } if (pdbStream == null) { return(null); } // Make sure the stream is at the beginning of the pdb. pdbStream.Position = 0; } provider = MetadataReaderProvider.FromPortablePdbStream(pdbStream); MetadataReader reader = provider.GetMetadataReader(); // Validate that the PDB matches the assembly version if (data.Age == 1 && new BlobContentId(reader.DebugMetadataHeader.Id) == new BlobContentId(data.Guid, codeViewEntry.Stamp)) { result = new OpenedReader(provider, reader); } } catch (Exception e) when(e is BadImageFormatException || e is IOException) { return(null); } finally { if (result == null) { provider?.Dispose(); } } return(result); }
protected override TypeAnnotations CreateValueFromKey(TypeDesc key) { // We scan the entire type at this point; the reason for doing that is properties. // // We allow annotating properties, but those annotations need to flow onto individual get/set methods // and backing fields. Without scanning all properties, we can't answer questions about fields/methods. // And if we're going over all properties, we might as well go over everything else to keep things simple. Debug.Assert(key.IsTypeDefinition); if (key is not EcmaType ecmaType) { return(new TypeAnnotations(key, DynamicallyAccessedMemberTypes.None, null, null, null)); } MetadataReader reader = ecmaType.MetadataReader; // class, interface, struct can have annotations TypeDefinition typeDef = reader.GetTypeDefinition(ecmaType.Handle); DynamicallyAccessedMemberTypes typeAnnotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, typeDef.GetCustomAttributes()); try { // Also inherit annotation from bases TypeDesc baseType = key.BaseType; while (baseType != null) { TypeDefinition baseTypeDef = reader.GetTypeDefinition(((EcmaType)baseType.GetTypeDefinition()).Handle); typeAnnotation |= GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, baseTypeDef.GetCustomAttributes()); baseType = baseType.BaseType; } // And inherit them from interfaces foreach (DefType runtimeInterface in key.RuntimeInterfaces) { TypeDefinition interfaceTypeDef = reader.GetTypeDefinition(((EcmaType)runtimeInterface.GetTypeDefinition()).Handle); typeAnnotation |= GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, interfaceTypeDef.GetCustomAttributes()); } } catch (TypeSystemException) { // If the class hierarchy is not walkable, just stop collecting the annotations. } var annotatedFields = new ArrayBuilder <FieldAnnotation>(); // First go over all fields with an explicit annotation foreach (EcmaField field in ecmaType.GetFields()) { FieldDefinition fieldDef = reader.GetFieldDefinition(field.Handle); DynamicallyAccessedMemberTypes annotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, fieldDef.GetCustomAttributes()); if (annotation == DynamicallyAccessedMemberTypes.None) { continue; } if (!IsTypeInterestingForDataflow(field.FieldType)) { // Already know that there's a non-empty annotation on a field which is not System.Type/String and we're about to ignore it _logger.LogWarning(field, DiagnosticId.DynamicallyAccessedMembersOnFieldCanOnlyApplyToTypesOrStrings, field.GetDisplayName()); continue; } annotatedFields.Add(new FieldAnnotation(field, annotation)); } var annotatedMethods = new ArrayBuilder <MethodAnnotations>(); // Next go over all methods with an explicit annotation foreach (EcmaMethod method in ecmaType.GetMethods()) { DynamicallyAccessedMemberTypes[] paramAnnotations = null; // We convert indices from metadata space to IL space here. // IL space assigns index 0 to the `this` parameter on instance methods. DynamicallyAccessedMemberTypes methodMemberTypes = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, reader.GetMethodDefinition(method.Handle).GetCustomAttributes()); MethodSignature signature; try { signature = method.Signature; } catch (TypeSystemException) { // If we cannot resolve things in the signature, just move along. continue; } int offset; if (!signature.IsStatic) { offset = 1; } else { offset = 0; } // If there's an annotation on the method itself and it's one of the special types (System.Type for example) // treat that annotation as annotating the "this" parameter. if (methodMemberTypes != DynamicallyAccessedMemberTypes.None) { if (IsTypeInterestingForDataflow(method.OwningType) && !signature.IsStatic) { paramAnnotations = new DynamicallyAccessedMemberTypes[signature.Length + offset]; paramAnnotations[0] = methodMemberTypes; } else { _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersIsNotAllowedOnMethods); } } MethodDefinition methodDef = reader.GetMethodDefinition(method.Handle); ParameterHandleCollection parameterHandles = methodDef.GetParameters(); DynamicallyAccessedMemberTypes returnAnnotation = DynamicallyAccessedMemberTypes.None; foreach (ParameterHandle parameterHandle in parameterHandles) { Parameter parameter = reader.GetParameter(parameterHandle); if (parameter.SequenceNumber == 0) { // this is the return parameter returnAnnotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, parameter.GetCustomAttributes()); if (returnAnnotation != DynamicallyAccessedMemberTypes.None && !IsTypeInterestingForDataflow(signature.ReturnType)) { _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStrings, method.GetDisplayName()); } } else { DynamicallyAccessedMemberTypes pa = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, parameter.GetCustomAttributes()); if (pa == DynamicallyAccessedMemberTypes.None) { continue; } if (!IsTypeInterestingForDataflow(signature[parameter.SequenceNumber - 1])) { _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersOnMethodParameterCanOnlyApplyToTypesOrStrings, $"#{parameter.SequenceNumber}", method.GetDisplayName()); continue; } if (paramAnnotations == null) { paramAnnotations = new DynamicallyAccessedMemberTypes[signature.Length + offset]; } paramAnnotations[parameter.SequenceNumber - 1 + offset] = pa; } } DynamicallyAccessedMemberTypes[] genericParameterAnnotations = null; foreach (EcmaGenericParameter genericParameter in method.Instantiation) { GenericParameter genericParameterDef = reader.GetGenericParameter(genericParameter.Handle); var annotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, genericParameterDef.GetCustomAttributes()); if (annotation != DynamicallyAccessedMemberTypes.None) { if (genericParameterAnnotations == null) { genericParameterAnnotations = new DynamicallyAccessedMemberTypes[method.Instantiation.Length]; } genericParameterAnnotations[genericParameter.Index] = annotation; } } if (returnAnnotation != DynamicallyAccessedMemberTypes.None || paramAnnotations != null || genericParameterAnnotations != null) { annotatedMethods.Add(new MethodAnnotations(method, paramAnnotations, returnAnnotation, genericParameterAnnotations)); } } // Next up are properties. Annotations on properties are kind of meta because we need to // map them to annotations on methods/fields. They're syntactic sugar - what they do is expressible // by placing attribute on the accessor/backing field. For complex properties, that's what people // will need to do anyway. Like so: // // [field: Attribute] // Type MyProperty // { // [return: Attribute] // get; // [value: Attribute] // set; // } foreach (PropertyDefinitionHandle propertyHandle in reader.GetTypeDefinition(ecmaType.Handle).GetProperties()) { DynamicallyAccessedMemberTypes annotation = GetMemberTypesForDynamicallyAccessedMembersAttribute( reader, reader.GetPropertyDefinition(propertyHandle).GetCustomAttributes()); if (annotation == DynamicallyAccessedMemberTypes.None) { continue; } PropertyPseudoDesc property = new PropertyPseudoDesc(ecmaType, propertyHandle); if (!IsTypeInterestingForDataflow(property.Signature.ReturnType)) { _logger.LogWarning(property, DiagnosticId.DynamicallyAccessedMembersOnPropertyCanOnlyApplyToTypesOrStrings, property.GetDisplayName()); continue; } FieldDesc backingFieldFromSetter = null; // Propagate the annotation to the setter method MethodDesc setMethod = property.SetMethod; if (setMethod != null) { // Abstract property backing field propagation doesn't make sense, and any derived property will be validated // to have the exact same annotations on getter/setter, and thus if it has a detectable backing field that will be validated as well. MethodIL methodBody = _ilProvider.GetMethodIL(setMethod); if (methodBody != null) { // Look for the compiler generated backing field. If it doesn't work out simply move on. In such case we would still // propagate the annotation to the setter/getter and later on when analyzing the setter/getter we will warn // that the field (which ever it is) must be annotated as well. ScanMethodBodyForFieldAccess(methodBody, write: true, out backingFieldFromSetter); } if (annotatedMethods.Any(a => a.Method == setMethod)) { _logger.LogWarning(setMethod, DiagnosticId.DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessor, property.GetDisplayName(), setMethod.GetDisplayName()); } else { int offset = setMethod.Signature.IsStatic ? 0 : 1; if (setMethod.Signature.Length > 0) { DynamicallyAccessedMemberTypes[] paramAnnotations = new DynamicallyAccessedMemberTypes[setMethod.Signature.Length + offset]; paramAnnotations[paramAnnotations.Length - 1] = annotation; annotatedMethods.Add(new MethodAnnotations(setMethod, paramAnnotations, DynamicallyAccessedMemberTypes.None, null)); } } } FieldDesc backingFieldFromGetter = null; // Propagate the annotation to the getter method MethodDesc getMethod = property.GetMethod; if (getMethod != null) { // Abstract property backing field propagation doesn't make sense, and any derived property will be validated // to have the exact same annotations on getter/setter, and thus if it has a detectable backing field that will be validated as well. MethodIL methodBody = _ilProvider.GetMethodIL(getMethod); if (methodBody != null) { // Look for the compiler generated backing field. If it doesn't work out simply move on. In such case we would still // propagate the annotation to the setter/getter and later on when analyzing the setter/getter we will warn // that the field (which ever it is) must be annotated as well. ScanMethodBodyForFieldAccess(methodBody, write: false, out backingFieldFromGetter); } if (annotatedMethods.Any(a => a.Method == getMethod)) { _logger.LogWarning(getMethod, DiagnosticId.DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessor, property.GetDisplayName(), getMethod.GetDisplayName()); } else { annotatedMethods.Add(new MethodAnnotations(getMethod, null, annotation, null)); } } FieldDesc backingField; if (backingFieldFromGetter != null && backingFieldFromSetter != null && backingFieldFromGetter != backingFieldFromSetter) { _logger.LogWarning(property, DiagnosticId.DynamicallyAccessedMembersCouldNotFindBackingField, property.GetDisplayName()); backingField = null; } else { backingField = backingFieldFromGetter ?? backingFieldFromSetter; } if (backingField != null) { if (annotatedFields.Any(a => a.Field == backingField)) { _logger.LogWarning(backingField, DiagnosticId.DynamicallyAccessedMembersOnPropertyConflictsWithBackingField, property.GetDisplayName(), backingField.GetDisplayName()); } else { annotatedFields.Add(new FieldAnnotation(backingField, annotation)); } } } DynamicallyAccessedMemberTypes[] typeGenericParameterAnnotations = null; foreach (EcmaGenericParameter genericParameter in ecmaType.Instantiation) { GenericParameter genericParameterDef = reader.GetGenericParameter(genericParameter.Handle); var annotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, genericParameterDef.GetCustomAttributes()); if (annotation != DynamicallyAccessedMemberTypes.None) { if (typeGenericParameterAnnotations == null) { typeGenericParameterAnnotations = new DynamicallyAccessedMemberTypes[ecmaType.Instantiation.Length]; } typeGenericParameterAnnotations[genericParameter.Index] = annotation; } } return(new TypeAnnotations(ecmaType, typeAnnotation, annotatedMethods.ToArray(), annotatedFields.ToArray(), typeGenericParameterAnnotations)); }
internal EmbeddedResource(string name, ManifestResourceAttributes attributes, uint offset, MetadataReader reader) : base(name, attributes) { this.offset = offset; this.reader = reader; }
private void Init(byte[] data) { #region Parse PE & Strong name hash RawFile = new BinaryReader(new MemoryStream(data)); BinaryReader r = new BinaryReader(new MemoryStream(data)); DosHeader = ReadDOSHeader(r); PeHeader = ReadPEHeader(DosHeader.COFFHeaderAddress, r); //Read all of the data PeHeader.Directories = ReadDirectoriesList(PeHeader.DirectoryLength, r); PeHeader.Sections = ReadSectionsList(PeHeader.NumberOfSections, r); try { ClrHeader = ReadCLRHeader(r, PeHeader); } catch (Exception ex) { throw new Exception("Error: Invaild metadata: " + ex.Message); } //Read the strong name hash ClrStrongNameHash = ReadStrongNameHash(r, ClrHeader.StrongNameSignatureAddress, ClrHeader.StrongNameSignatureSize, PeHeader.Sections); #endregion #region Parse metadata header //Skip past all of the IL Code, and get tto the metadata header long pos = (long)RelativeVirtualAddressToFileOffset(ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); r.BaseStream.Position = pos; ClrMetaDataHeader = new MetadataHeader(); ClrMetaDataHeader.Signature = r.ReadUInt32(); ClrMetaDataHeader.MajorVersion = r.ReadUInt16(); ClrMetaDataHeader.MinorVersion = r.ReadUInt16(); ClrMetaDataHeader.Reserved1 = r.ReadUInt32(); ClrMetaDataHeader.VersionStringLength = r.ReadUInt32(); ClrMetaDataHeader.VersionString = r.ReadNullTermString((int)ClrMetaDataHeader.VersionStringLength); ClrMetaDataHeader.Flags = r.ReadUInt16(); //reserved ClrMetaDataHeader.NumberOfStreams = r.ReadUInt16(); //Simple checks //Debug.Assert(ClrMetaDataHeader.Signature == 0x424A5342); //Debug.Assert(ClrMetaDataHeader.Reserved1 == 0); //Debug.Assert(ClrMetaDataHeader.Flags == 0); #endregion #region Parse streams //Read all of the tabels List <StreamHeader> Streams = new List <StreamHeader>(); //Parse the StreamHeader(s) for (int i = 0; i < ClrMetaDataHeader.NumberOfStreams; i++) { var hdr = new StreamHeader(); hdr.Offset = r.ReadUInt32(); hdr.Size = r.ReadUInt32(); hdr.Name = r.ReadNullTermString(); //#~ Stream if (hdr.Name.Length == 2) { r.BaseStream.Position += 1; //Skip past the 4 zeros } //#Strings stream else if (hdr.Name.Length == 8) { r.BaseStream.Position += 3; } //#US Stream else if (hdr.Name.Length == 3) { } //#GUID Stream else if (hdr.Name.Length == 5) { r.BaseStream.Position += 2; } Console.WriteLine("Stream: " + hdr.Name + " Size: " + hdr.Size + " Offset: " + hdr.Offset); Streams.Add(hdr); } //Parse the #String stream var bytes = GetStreamBytes(r, Streams[1], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); ClrStringsStream = new StringsStreamReader(bytes).Read(); //Parse the #US Stream var bytes2 = GetStreamBytes(r, Streams[2], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections); ClrUsStream = new USStreamReader(bytes2).Read(); #endregion #region Parse #~ Stream //Parse the #~ stream BinaryReader TableStreamR = new BinaryReader(new MemoryStream( GetStreamBytes(r, Streams[0], ClrHeader.MetaDataDirectoryAddress, PeHeader.Sections))); ClrMetaDataStreamHeader = ReadHeader(TableStreamR); //Parse the tabels data var numberOfTables = GetTableCount(ClrMetaDataStreamHeader.TablesFlags); ClrMetaDataStreamHeader.TableSizes = new uint[numberOfTables]; for (var i = 0; i < numberOfTables; i++) { ClrMetaDataStreamHeader.TableSizes[i] = TableStreamR.ReadUInt32(); } MetadataReader = new MetadataReader(TableStreamR.BaseStream); //Parse the tabels tabels = new Tabels(this); #endregion }
public MethodDebugInformationTableTreeNode(PEFile module, MetadataReader metadata, bool isEmbedded) : base(HandleKind.MethodDebugInformation, module, metadata) { this.isEmbedded = isEmbedded; }
private int InitializeMethodFlags(int mask) { int flags = 0; if ((mask & MethodFlags.BasicMetadataCache) != 0) { var methodAttributes = Attributes; var methodImplAttributes = ImplAttributes; if ((methodAttributes & MethodAttributes.Virtual) != 0) { flags |= MethodFlags.Virtual; } if ((methodAttributes & MethodAttributes.NewSlot) != 0) { flags |= MethodFlags.NewSlot; } if ((methodAttributes & MethodAttributes.Abstract) != 0) { flags |= MethodFlags.Abstract; } if ((methodAttributes & MethodAttributes.Final) != 0) { flags |= MethodFlags.Final; } if ((methodImplAttributes & MethodImplAttributes.NoInlining) != 0) { flags |= MethodFlags.NoInlining; } if ((methodImplAttributes & MethodImplAttributes.AggressiveInlining) != 0) { flags |= MethodFlags.AggressiveInlining; } if ((methodImplAttributes & MethodImplAttributes.Runtime) != 0) { flags |= MethodFlags.RuntimeImplemented; } if ((methodImplAttributes & MethodImplAttributes.InternalCall) != 0) { flags |= MethodFlags.InternalCall; } if ((methodImplAttributes & MethodImplAttributes.Synchronized) != 0) { flags |= MethodFlags.Synchronized; } flags |= MethodFlags.BasicMetadataCache; } // Fetching custom attribute based properties is more expensive, so keep that under // a separate cache that might not be accessed very frequently. if ((mask & MethodFlags.AttributeMetadataCache) != 0) { var metadataReader = this.MetadataReader; var methodDefinition = MetadataReader.GetMethod(_handle); foreach (var attributeHandle in methodDefinition.CustomAttributes) { ConstantStringValueHandle nameHandle; string namespaceName; if (!metadataReader.GetAttributeNamespaceAndName(attributeHandle, out namespaceName, out nameHandle)) { continue; } if (namespaceName.Equals("System.Runtime.CompilerServices")) { if (nameHandle.StringEquals("IntrinsicAttribute", metadataReader)) { flags |= MethodFlags.Intrinsic; } } else if (namespaceName.Equals("System.Runtime.InteropServices")) { if (nameHandle.StringEquals("UnmanagedCallersOnlyAttribute", metadataReader)) { flags |= MethodFlags.UnmanagedCallersOnly; } } else if (namespaceName.Equals("System.Runtime")) { if (nameHandle.StringEquals("RuntimeExportAttribute", metadataReader)) { flags |= MethodFlags.RuntimeExport; } } } flags |= MethodFlags.AttributeMetadataCache; } Debug.Assert((flags & mask) != 0); _methodFlags.AddFlags(flags); return(flags & mask); }
public unsafe static MethodDebugInfo <TTypeSymbol, TLocalSymbol> ReadMethodDebugInfo( ISymUnmanagedReader symReader, EESymbolProvider <TTypeSymbol, TLocalSymbol> symbolProviderOpt, // TODO: only null in DTEE case where we looking for default namesapace int methodToken, int methodVersion, int ilOffset, bool isVisualBasicMethod) { // no symbols if (symReader == null) { return(None); } var symReader4 = symReader as ISymUnmanagedReader4; if (symReader4 != null) // TODO: VB Portable PDBs { byte *metadata; int size; // TODO: version int hr = symReader4.GetPortableDebugMetadata(out metadata, out size); SymUnmanagedReaderExtensions.ThrowExceptionForHR(hr); if (metadata != null) { var mdReader = new MetadataReader(metadata, size); try { return(ReadFromPortable(mdReader, methodToken, ilOffset, symbolProviderOpt, isVisualBasicMethod)); } catch (BadImageFormatException) { // bad CDI, ignore return(None); } } } var allScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance(); var containingScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance(); try { ImmutableArray <HoistedLocalScopeRecord> hoistedLocalScopeRecords; ImmutableArray <ImmutableArray <ImportRecord> > importRecordGroups; ImmutableArray <ExternAliasRecord> externAliasRecords; ImmutableDictionary <int, ImmutableArray <bool> > dynamicLocalMap; ImmutableDictionary <string, ImmutableArray <bool> > dynamicLocalConstantMap; string defaultNamespaceName; var symMethod = symReader.GetMethodByVersion(methodToken, methodVersion); if (symMethod != null) { symMethod.GetAllScopes(allScopes, containingScopes, ilOffset, isScopeEndInclusive: isVisualBasicMethod); } if (isVisualBasicMethod) { ReadVisualBasicImportsDebugInfo( symReader, methodToken, methodVersion, out importRecordGroups, out defaultNamespaceName); hoistedLocalScopeRecords = ImmutableArray <HoistedLocalScopeRecord> .Empty; externAliasRecords = ImmutableArray <ExternAliasRecord> .Empty; dynamicLocalMap = null; dynamicLocalConstantMap = null; } else { Debug.Assert(symbolProviderOpt != null); ReadCSharpNativeImportsInfo( symReader, symbolProviderOpt, methodToken, methodVersion, out importRecordGroups, out externAliasRecords); ReadCSharpNativeCustomDebugInfo( symReader, methodToken, methodVersion, allScopes, out hoistedLocalScopeRecords, out dynamicLocalMap, out dynamicLocalConstantMap); defaultNamespaceName = ""; } var constantsBuilder = ArrayBuilder <TLocalSymbol> .GetInstance(); if (symbolProviderOpt != null) // TODO { GetConstants(constantsBuilder, symbolProviderOpt, containingScopes, dynamicLocalConstantMap); } var reuseSpan = GetReuseSpan(allScopes, ilOffset, isVisualBasicMethod); return(new MethodDebugInfo <TTypeSymbol, TLocalSymbol>( hoistedLocalScopeRecords, importRecordGroups, externAliasRecords, dynamicLocalMap, defaultNamespaceName, containingScopes.GetLocalNames(), constantsBuilder.ToImmutableAndFree(), reuseSpan)); } catch (InvalidOperationException) { // bad CDI, ignore return(None); } finally { allScopes.Free(); containingScopes.Free(); } }
public MemberMetadataInfoTypeProvider(MetadataReader reader) { Reader = reader; }
protected void ReadModuleManifest(MetadataReader reader) { reader.Populate(this.module); this.ReadAssembly(reader); }
public static unsafe MethodDebugInfo <TTypeSymbol, TLocalSymbol> ReadMethodDebugInfo( ISymUnmanagedReader3?symReader, EESymbolProvider <TTypeSymbol, TLocalSymbol>?symbolProvider, // TODO: only null in DTEE case where we looking for default namesapace int methodToken, int methodVersion, int ilOffset, bool isVisualBasicMethod) { // no symbols if (symReader == null) { return(None); } if (symReader is ISymUnmanagedReader5 symReader5) { int hr = symReader5.GetPortableDebugMetadataByVersion(methodVersion, out byte *metadata, out int size); ThrowExceptionForHR(hr); if (hr == S_OK) { var mdReader = new MetadataReader(metadata, size); try { return(ReadFromPortable(mdReader, methodToken, ilOffset, symbolProvider, isVisualBasicMethod)); } catch (BadImageFormatException) { // bad CDI, ignore return(None); } } } var allScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance(); var containingScopes = ArrayBuilder <ISymUnmanagedScope> .GetInstance(); try { var symMethod = symReader.GetMethodByVersion(methodToken, methodVersion); symMethod?.GetAllScopes(allScopes, containingScopes, ilOffset, isScopeEndInclusive: isVisualBasicMethod); ImmutableArray <ImmutableArray <ImportRecord> > importRecordGroups; ImmutableArray <ExternAliasRecord> externAliasRecords; string defaultNamespaceName; if (isVisualBasicMethod) { ReadVisualBasicImportsDebugInfo( symReader, methodToken, methodVersion, out importRecordGroups, out defaultNamespaceName); externAliasRecords = ImmutableArray <ExternAliasRecord> .Empty; } else { RoslynDebug.AssertNotNull(symbolProvider); ReadCSharpNativeImportsInfo( symReader, symbolProvider, methodToken, methodVersion, out importRecordGroups, out externAliasRecords); defaultNamespaceName = ""; } // VB should read hoisted scope information from local variables: var hoistedLocalScopeRecords = isVisualBasicMethod ? default : ImmutableArray <HoistedLocalScopeRecord> .Empty; ImmutableDictionary <int, ImmutableArray <bool> >? dynamicLocalMap = null; ImmutableDictionary <string, ImmutableArray <bool> >?dynamicLocalConstantMap = null; ImmutableDictionary <int, ImmutableArray <string?> >?tupleLocalMap = null; ImmutableDictionary <LocalNameAndScope, ImmutableArray <string?> >?tupleLocalConstantMap = null; byte[]? customDebugInfo = GetCustomDebugInfoBytes(symReader, methodToken, methodVersion); if (customDebugInfo != null) { if (!isVisualBasicMethod) { var customDebugInfoRecord = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(customDebugInfo, CustomDebugInfoKind.StateMachineHoistedLocalScopes); if (!customDebugInfoRecord.IsDefault) { hoistedLocalScopeRecords = CustomDebugInfoReader.DecodeStateMachineHoistedLocalScopesRecord(customDebugInfoRecord) .SelectAsArray(s => new HoistedLocalScopeRecord(s.StartOffset, s.Length)); } GetCSharpDynamicLocalInfo( customDebugInfo, allScopes, out dynamicLocalMap, out dynamicLocalConstantMap); } GetTupleElementNamesLocalInfo( customDebugInfo, out tupleLocalMap, out tupleLocalConstantMap); } var constantsBuilder = ArrayBuilder <TLocalSymbol> .GetInstance(); if (symbolProvider != null) // TODO { GetConstants(constantsBuilder, symbolProvider, containingScopes, dynamicLocalConstantMap, tupleLocalConstantMap); } var reuseSpan = GetReuseSpan(allScopes, ilOffset, isVisualBasicMethod); return(new MethodDebugInfo <TTypeSymbol, TLocalSymbol>( hoistedLocalScopeRecords, importRecordGroups, externAliasRecords, dynamicLocalMap, tupleLocalMap, defaultNamespaceName, containingScopes.GetLocalNames(), constantsBuilder.ToImmutableAndFree(), reuseSpan)); } catch (InvalidOperationException) { // bad CDI, ignore return(None); } finally { allScopes.Free(); containingScopes.Free(); } }
public string GetTypeFromSpecification(MetadataReader reader, TypeContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) => handle.ToTypeString(reader, genericContext);
public DummyMetadataImport(MetadataReader metadataReaderOpt, IDisposable metadataOwnerOpt) { _metadataReaderOpt = metadataReaderOpt; _pinnedBuffers = new List <GCHandle>(); _metadataOwnerOpt = metadataOwnerOpt; }