Merge remote-tracking branch 'upstream/master'

Author: marek-safar

Mono.Cecil.PE/ImageReader.cs

@@ -350,7 +350,7 @@ void ReadDebugHeader ()
 					PointerToRawData = ReadInt32 (),
 				};
 
-				if (directory.AddressOfRawData == 0) {
+				if (directory.PointerToRawData == 0) {
 					entries [i] = new ImageDebugHeaderEntry (directory, Empty<byte>.Array);
 					continue;
 				}

Mono.Cecil.PE/ImageWriter.cs

@@ -814,14 +814,6 @@ public uint GetHeaderSize ()
 			return pe_header_size + SizeOfOptionalHeader () + (sections * section_header_size);
 		}
 
-		public void PatchMvid (Guid guid)
-		{
-			uint offset = GetRVAFileOffset (text, text_map.GetRVA (TextSegment.GuidHeap));
-			BaseStream.Seek (offset, SeekOrigin.Begin);
-			var arr = guid.ToByteArray ();
-			BaseStream.Write (arr, 0, arr.Length);
-		}
-
 		void PatchWin32Resources (ByteBuffer resources)
 		{
 			PatchResourceDirectoryTable (resources);

Mono.Cecil.csproj

@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="Current">
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net40</TargetFrameworks>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="ProjectInfo.cs" />

Mono.Cecil/AssemblyReader.cs

@@ -103,8 +103,14 @@ static void ReadSymbols (ModuleDefinition module, ReaderParameters parameters)
 					? symbol_reader_provider.GetSymbolReader (module, parameters.SymbolStream)
 					: symbol_reader_provider.GetSymbolReader (module, module.FileName);
 
-				if (reader != null)
-					module.ReadSymbols (reader, parameters.ThrowIfSymbolsAreNotMatching);
+				if (reader != null) {
+					try {
+						module.ReadSymbols (reader, parameters.ThrowIfSymbolsAreNotMatching);
+					} catch (Exception) {
+						reader.Dispose ();
+						throw;
+					}
+				}
 			}
 
 			if (module.Image.HasDebugTables ())
@@ -237,12 +243,20 @@ void ReadGenericParameters (IGenericParameterProvider provider)
 				var parameter = parameters [i];
 
 				if (parameter.HasConstraints)
-					Mixin.Read (parameter.Constraints);
+					ReadGenericParameterConstraints (parameter);
 
 				ReadCustomAttributes (parameter);
 			}
 		}
 
+		void ReadGenericParameterConstraints (GenericParameter parameter)
+		{
+			var constraints = parameter.Constraints;
+
+			for (int i = 0; i < constraints.Count; i++)
+				ReadCustomAttributes (constraints [i]);
+		}
+
 		void ReadSecurityDeclarations (ISecurityDeclarationProvider provider)
 		{
 			if (!provider.HasSecurityDeclarations)
@@ -1987,27 +2001,31 @@ public bool HasGenericConstraints (GenericParameter generic_parameter)
 		{
 			InitializeGenericConstraints ();
 
-			Collection<MetadataToken> mapping;
+			Collection<Row<uint, MetadataToken>> mapping;
 			if (!metadata.TryGetGenericConstraintMapping (generic_parameter, out mapping))
 				return false;
 
 			return mapping.Count > 0;
 		}
 
-		public Collection<TypeReference> ReadGenericConstraints (GenericParameter generic_parameter)
+		public GenericParameterConstraintCollection ReadGenericConstraints (GenericParameter generic_parameter)
 		{
 			InitializeGenericConstraints ();
 
-			Collection<MetadataToken> mapping;
+			Collection<Row<uint, MetadataToken>> mapping;
 			if (!metadata.TryGetGenericConstraintMapping (generic_parameter, out mapping))
-				return new Collection<TypeReference> ();
+				return new GenericParameterConstraintCollection (generic_parameter);
 
-			var constraints = new Collection<TypeReference> (mapping.Count);
+			var constraints = new GenericParameterConstraintCollection (generic_parameter, mapping.Count);
 
 			this.context = (IGenericContext) generic_parameter.Owner;
 
-			for (int i = 0; i < mapping.Count; i++)
-				constraints.Add (GetTypeDefOrRef (mapping [i]));
+			for (int i = 0; i < mapping.Count; i++) {
+				constraints.Add (
+					new GenericParameterConstraint (
+						GetTypeDefOrRef (mapping [i].Col2),
+						new MetadataToken (TokenType.GenericParamConstraint, mapping [i].Col1)));
+			}
 
 			metadata.RemoveGenericConstraintMapping (generic_parameter);
 
@@ -2021,15 +2039,16 @@ void InitializeGenericConstraints ()
 
 			var length = MoveTo (Table.GenericParamConstraint);
 
-			metadata.GenericConstraints = new Dictionary<uint, Collection<MetadataToken>> (length);
+			metadata.GenericConstraints = new Dictionary<uint, Collection<Row<uint, MetadataToken>>> (length);
 
-			for (int i = 1; i <= length; i++)
+			for (uint i = 1; i <= length; i++) {
 				AddGenericConstraintMapping (
 					ReadTableIndex (Table.GenericParam),
-					ReadMetadataToken (CodedIndex.TypeDefOrRef));
+					new Row<uint, MetadataToken> (i, ReadMetadataToken (CodedIndex.TypeDefOrRef)));
+			}
 		}
 
-		void AddGenericConstraintMapping (uint generic_parameter, MetadataToken constraint)
+		void AddGenericConstraintMapping (uint generic_parameter, Row<uint, MetadataToken> constraint)
 		{
 			metadata.SetGenericConstraintMapping (
 				generic_parameter,

Mono.Cecil/AssemblyWriter.cs

@@ -109,6 +109,7 @@ static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterPar
 
 			if (parameters.DeterministicMvid)
 				module.Mvid = Guid.Empty;
+
 			var metadata = new MetadataBuilder (module, fq_name, timestamp, symbol_writer_provider);
 			try {
 				module.metadata_builder = metadata;
@@ -117,62 +118,21 @@ static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterPar
 					metadata.SetSymbolWriter (symbol_writer);
 					BuildMetadata (module, metadata);
 
+					if (parameters.DeterministicMvid)
+						metadata.ComputeDeterministicMvid ();
+
 					var writer = ImageWriter.CreateWriter (module, metadata, stream);
 					stream.value.SetLength (0);
 					writer.WriteImage ();
 
 					if (parameters.StrongNameKeyPair != null)
 						CryptoService.StrongName (stream.value, writer, parameters.StrongNameKeyPair);
-					if (parameters.DeterministicMvid) {
-						module.Mvid = ComputeGuid (stream.value);
-						writer.PatchMvid (module.Mvid);
-					}
 				}
 			} finally {
 				module.metadata_builder = null;
 			}
 		}
 
-		static void CopyStreamChunk (Stream stream, Stream dest_stream, byte [] buffer, int length)
-		{
-			while (length > 0) {
-				int read = stream.Read (buffer, 0, System.Math.Min (buffer.Length, length));
-				dest_stream.Write (buffer, 0, read);
-				length -= read;
-			}
-		}
-
-		static byte [] ComputeHash (Stream stream)
-		{
-			const int buffer_size = 8192;
-
-			var sha1 = new SHA1Managed ();
-
-			stream.Seek (0, SeekOrigin.Begin);
-			var buffer = new byte [buffer_size];
-
-			using (var crypto_stream = new CryptoStream (Stream.Null, sha1, CryptoStreamMode.Write))
-				CopyStreamChunk (stream, crypto_stream, buffer, (int) stream.Length);
-			return sha1.Hash;
-		}
-
-		static unsafe Guid ComputeGuid (Stream stream)
-		{
-			byte[] hashCode = ComputeHash (stream);
-
-			// From corefx/src/System.Reflection.Metadata/src/System/Reflection/Metadata/BlobContentId.cs
-			Guid guid = default(Guid);
-			byte* guidPtr = (byte*)&guid;
-			for (var i = 0; i < 16; i++) {
-				guidPtr[i] = hashCode[i];
-			}
-			// modify the guid data so it decodes to the form of a "random" guid ala rfc4122
-			guidPtr[7] = (byte)((guidPtr[7] & 0x0f) | (4 << 4));
-			guidPtr[8] = (byte)((guidPtr[8] & 0x3f) | (2 << 6));
-
-			return guid;
-		}
-
 		static void BuildMetadata (ModuleDefinition module, MetadataBuilder metadata)
 		{
 			if (!module.HasImage) {
@@ -1559,12 +1519,20 @@ void AddConstraints (GenericParameter generic_parameter, GenericParamConstraintT
 		{
 			var constraints = generic_parameter.Constraints;
 
-			var rid = generic_parameter.token.RID;
+			var gp_rid = generic_parameter.token.RID;
+
+			for (int i = 0; i < constraints.Count; i++) {
+				var constraint = constraints [i];
+
+				var rid = table.AddRow (new GenericParamConstraintRow (
+					gp_rid,
+					MakeCodedRID (GetTypeToken (constraint.ConstraintType), CodedIndex.TypeDefOrRef)));
+
+				constraint.token = new MetadataToken (TokenType.GenericParamConstraint, rid);
 
-			for (int i = 0; i < constraints.Count; i++)
-				table.AddRow (new GenericParamConstraintRow (
-					rid,
-					MakeCodedRID (GetTypeToken (constraints [i]), CodedIndex.TypeDefOrRef)));
+				if (constraint.HasCustomAttributes)
+					AddCustomAttributes (constraint);
+			}
 		}
 
 		void AddInterfaces (TypeDefinition type)
@@ -2690,6 +2658,25 @@ void AddSequencePoints (MethodDebugInformation info)
 
 			method_debug_information_table.rows [rid - 1].Col2 = GetBlobIndex (signature);
 		}
+
+		public void ComputeDeterministicMvid ()
+		{
+			var guid = CryptoService.ComputeGuid (CryptoService.ComputeHash (
+				data,
+				resources,
+				string_heap,
+				user_string_heap,
+				blob_heap,
+				table_heap,
+				code));
+
+			var position = guid_heap.position;
+			guid_heap.position = 0;
+			guid_heap.WriteBytes (guid.ToByteArray ());
+			guid_heap.position = position;
+
+			module.Mvid = guid;
+		}
 	}
 
 	sealed class SignatureWriter : ByteBuffer {

Mono.Cecil/GenericParameter.cs

@@ -23,7 +23,7 @@ public sealed class GenericParameter : TypeReference, ICustomAttributeProvider {
 		internal IGenericParameterProvider owner;
 
 		ushort attributes;
-		Collection<TypeReference> constraints;
+		GenericParameterConstraintCollection constraints;
 		Collection<CustomAttribute> custom_attributes;
 
 		public GenericParameterAttributes Attributes {
@@ -52,15 +52,15 @@ public bool HasConstraints {
 			}
 		}
 
-		public Collection<TypeReference> Constraints {
+		public Collection<GenericParameterConstraint> Constraints {
 			get {
 				if (constraints != null)
 					return constraints;
 
 				if (HasImage)
 					return Module.Read (ref constraints, this, (generic_parameter, reader) => reader.ReadGenericConstraints (generic_parameter));
 
-				return constraints = new Collection<TypeReference> ();
+				return constraints = new GenericParameterConstraintCollection (this);
 			}
 		}
 
@@ -265,4 +265,94 @@ protected override void OnRemove (GenericParameter item, int index)
 				items[i].position = i - 1;
 		}
 	}
+
+	public sealed class GenericParameterConstraint : ICustomAttributeProvider {
+
+		internal GenericParameter generic_parameter;
+		internal MetadataToken token;
+
+		TypeReference constraint_type;
+		Collection<CustomAttribute> custom_attributes;
+
+		public TypeReference ConstraintType {
+			get { return constraint_type; }
+			set { constraint_type = value; }
+		}
+
+		public bool HasCustomAttributes {
+			get {
+				if (custom_attributes != null)
+					return custom_attributes.Count > 0;
+
+				if (generic_parameter == null)
+					return false;
+
+				return this.GetHasCustomAttributes (generic_parameter.Module);
+			}
+		}
+
+		public Collection<CustomAttribute> CustomAttributes {
+			get {
+				if (generic_parameter == null)
+					return custom_attributes = new Collection<CustomAttribute> ();
+
+				return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, generic_parameter.Module));
+			}
+		}
+
+		public MetadataToken MetadataToken {
+			get { return token; }
+			set { token = value; }
+		}
+
+		internal GenericParameterConstraint (TypeReference constraintType, MetadataToken token)
+		{
+			this.constraint_type = constraintType;
+			this.token = token;
+		}
+
+		public GenericParameterConstraint (TypeReference constraintType)
+		{
+			Mixin.CheckType (constraintType, Mixin.Argument.constraintType);
+
+			this.constraint_type = constraintType;
+			this.token = new MetadataToken (TokenType.GenericParamConstraint);
+		}
+	}
+
+	class GenericParameterConstraintCollection : Collection<GenericParameterConstraint>
+	{
+		readonly GenericParameter generic_parameter;
+
+		internal GenericParameterConstraintCollection (GenericParameter genericParameter)
+		{
+			this.generic_parameter = genericParameter;
+		}
+
+		internal GenericParameterConstraintCollection (GenericParameter genericParameter, int length)
+			: base (length)
+		{
+			this.generic_parameter = genericParameter;
+		}
+
+		protected override void OnAdd (GenericParameterConstraint item, int index)
+		{
+			item.generic_parameter = generic_parameter;
+		}
+
+		protected override void OnInsert (GenericParameterConstraint item, int index)
+		{
+			item.generic_parameter = generic_parameter;
+		}
+
+		protected override void OnSet (GenericParameterConstraint item, int index)
+		{
+			item.generic_parameter = generic_parameter;
+		}
+
+		protected override void OnRemove (GenericParameterConstraint item, int index)
+		{
+			item.generic_parameter = null;
+		}
+	}
 }