Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

external/cecil/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs

@@ -10,71 +10,193 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.SymbolStore;
+using System.IO;
+using System.Linq;
+using System.Text;
 
 using Mono.Cecil.Cil;
+using Mono.Cecil.PE;
 using Mono.Collections.Generic;
 
 #if !READ_ONLY
 
 namespace Mono.Cecil.Pdb {
 
-	public class NativePdbWriter : Cil.ISymbolWriter {
+	public class NativePdbWriter : ISymbolWriter, IMetadataSymbolWriter {
 
 		readonly ModuleDefinition module;
 		readonly SymWriter writer;
 		readonly Dictionary<string, SymDocumentWriter> documents;
+		readonly Dictionary<ImportDebugInformation, MetadataToken> import_info_to_parent;
+
+		MetadataBuilder metadata;
 
 		internal NativePdbWriter (ModuleDefinition module, SymWriter writer)
 		{
 			this.module = module;
 			this.writer = writer;
 			this.documents = new Dictionary<string, SymDocumentWriter> ();
+			this.import_info_to_parent = new Dictionary<ImportDebugInformation, MetadataToken> ();
 		}
 
-		public bool GetDebugHeader (out ImageDebugDirectory directory, out byte [] header)
+		public ISymbolReaderProvider GetReaderProvider ()
 		{
-			header = writer.GetDebugInfo (out directory);
-			return true;
+			return new NativePdbReaderProvider ();
+		}
+
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			ImageDebugDirectory directory;
+			var data = writer.GetDebugInfo (out directory);
+			directory.TimeDateStamp = (int) module.timestamp;
+			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
 		}
 
 		public void Write (MethodDebugInformation info)
 		{
 			var method_token = info.method.MetadataToken;
-			var sym_token = new SymbolToken (method_token.ToInt32 ());
+			var sym_token = method_token.ToInt32 ();
+
+			if (!info.HasSequencePoints && info.scope == null && !info.HasCustomDebugInformations && info.StateMachineKickOffMethod == null)
+				return;
 
 			writer.OpenMethod (sym_token);
 
 			if (!info.sequence_points.IsNullOrEmpty ())
 				DefineSequencePoints (info.sequence_points);
 
+			var import_parent = new MetadataToken ();
+
 			if (info.scope != null)
-				DefineScope (info.scope, info);
+				DefineScope (info.scope, info, out import_parent);
+
+			DefineCustomMetadata (info, import_parent);
 
 			writer.CloseMethod ();
 		}
 
-		void DefineScope (ScopeDebugInformation scope, MethodDebugInformation info)
+		void IMetadataSymbolWriter.SetMetadata (MetadataBuilder metadata)
+		{
+			this.metadata = metadata;
+		}
+
+		void DefineCustomMetadata (MethodDebugInformation info, MetadataToken import_parent)
+		{
+			var metadata = new CustomMetadataWriter (this.writer);
+
+			if (import_parent.RID != 0) {
+				metadata.WriteForwardInfo (import_parent);
+			} else if (info.scope != null && info.scope.Import != null && info.scope.Import.HasTargets) {
+				metadata.WriteUsingInfo (info.scope.Import);
+			}
+
+			if (info.Method.HasCustomAttributes) {
+				foreach (var attribute in info.Method.CustomAttributes) {
+					const string compiler_services = "System.Runtime.CompilerServices";
+					var attribute_type = attribute.AttributeType;
+
+					if (!attribute_type.IsTypeOf (compiler_services, "IteratorStateMachineAttribute") && !attribute_type.IsTypeOf (compiler_services, "AsyncStateMachineAttribute"))
+						continue;
+
+					var type = attribute.ConstructorArguments [0].Value as TypeReference;
+					if (type == null)
+						continue;
+
+					metadata.WriteForwardIterator (type);
+				}
+			}
+
+			if (info.HasCustomDebugInformations) {
+				var scopes = info.CustomDebugInformations.OfType<StateMachineScopeDebugInformation> ().ToArray ();
+
+				if (scopes.Length > 0)
+					metadata.WriteIteratorScopes (scopes, info);
+			}
+
+			metadata.WriteCustomMetadata ();
+
+			DefineAsyncCustomMetadata (info);
+		}
+
+		void DefineAsyncCustomMetadata (MethodDebugInformation info)
+		{
+			if (!info.HasCustomDebugInformations)
+				return;
+
+			foreach (var custom_info in info.CustomDebugInformations) {
+				var async_debug_info = custom_info as AsyncMethodBodyDebugInformation;
+				if (async_debug_info == null)
+					continue;
+
+				using (var stream = new MemoryStream ()) {
+					var async_metadata = new BinaryStreamWriter (stream);
+					async_metadata.WriteUInt32 (info.StateMachineKickOffMethod != null ? info.StateMachineKickOffMethod.MetadataToken.ToUInt32 () : 0);
+					async_metadata.WriteUInt32 ((uint) async_debug_info.CatchHandler.Offset);
+					async_metadata.WriteUInt32 ((uint) async_debug_info.Resumes.Count);
+					for (int i = 0; i < async_debug_info.Resumes.Count; ++i) {
+						async_metadata.WriteUInt32 ((uint) async_debug_info.Yields [i].Offset);
+						async_metadata.WriteUInt32 (async_debug_info.MoveNextMethod != null ? async_debug_info.MoveNextMethod.MetadataToken.ToUInt32 () : 0);
+						async_metadata.WriteUInt32 ((uint) async_debug_info.Resumes [i].Offset);
+					}
+
+					writer.DefineCustomMetadata ("asyncMethodInfo", stream.ToArray ());
+				}
+			}
+		}
+
+		void DefineScope (ScopeDebugInformation scope, MethodDebugInformation info, out MetadataToken import_parent)
 		{
 			var start_offset = scope.Start.Offset;
 			var end_offset = scope.End.IsEndOfMethod
 				? info.code_size
 				: scope.End.Offset;
 
+			import_parent = new MetadataToken (0u);
+
 			writer.OpenScope (start_offset);
 
-			var sym_token = new SymbolToken (info.local_var_token.ToInt32 ());
+			if (scope.Import != null && scope.Import.HasTargets && !import_info_to_parent.TryGetValue (info.scope.Import, out import_parent)) {
+				foreach (var target in scope.Import.Targets) {
+					switch (target.Kind) {
+					case ImportTargetKind.ImportNamespace:
+						writer.UsingNamespace ("U" + target.@namespace);
+						break;
+					case ImportTargetKind.ImportType:
+						writer.UsingNamespace ("T" + TypeParser.ToParseable (target.type));
+						break;
+					case ImportTargetKind.DefineNamespaceAlias:
+						writer.UsingNamespace ("A" + target.Alias + " U" + target.@namespace);
+						break;
+					case ImportTargetKind.DefineTypeAlias:
+						writer.UsingNamespace ("A" + target.Alias + " T" + TypeParser.ToParseable (target.type));
+						break;
+					}
+				}
+
+				import_info_to_parent.Add (info.scope.Import, info.method.MetadataToken);
+			}
+
+			var sym_token = info.local_var_token.ToInt32 ();
 
 			if (!scope.variables.IsNullOrEmpty ()) {
 				for (int i = 0; i < scope.variables.Count; i++) {
 					var variable = scope.variables [i];
-					CreateLocalVariable (variable, sym_token, start_offset, end_offset);
+					DefineLocalVariable (variable, sym_token, start_offset, end_offset);
+				}
+			}
+
+			if (!scope.constants.IsNullOrEmpty ()) {
+				for (int i = 0; i < scope.constants.Count; i++) {
+					var constant = scope.constants [i];
+					DefineConstant (constant);
 				}
 			}
 
 			if (!scope.scopes.IsNullOrEmpty ()) {
-				for (int i = 0; i < scope.scopes.Count; i++)
-					DefineScope (scope.scopes [i], info);
+				for (int i = 0; i < scope.scopes.Count; i++) {
+					MetadataToken _;
+					DefineScope (scope.scopes [i], info, out _);
+				}
 			}
 
 			writer.CloseScope (end_offset);
@@ -95,13 +217,12 @@ namespace Mono.Cecil.Pdb {
 			}
 		}
 
-		void CreateLocalVariable (VariableDebugInformation variable, SymbolToken local_var_token, int start_offset, int end_offset)
+		void DefineLocalVariable (VariableDebugInformation variable, int local_var_token, int start_offset, int end_offset)
 		{
 			writer.DefineLocalVariable2 (
 				variable.Name,
 				variable.Attributes,
 				local_var_token,
-				SymAddressKind.ILOffset,
 				variable.Index,
 				0,
 				0,
@@ -109,6 +230,14 @@ namespace Mono.Cecil.Pdb {
 				end_offset);
 		}
 
+		void DefineConstant (ConstantDebugInformation constant)
+		{
+			var row = metadata.AddStandAloneSignature (metadata.GetConstantTypeBlobIndex (constant.ConstantType));
+			var token = new MetadataToken (TokenType.Signature, row);
+
+			writer.DefineConstant2 (constant.Name, constant.Value, token.ToInt32 ());
+		}
+
 		SymDocumentWriter GetDocument (Document document)
 		{
 			if (document == null)
@@ -132,11 +261,110 @@ namespace Mono.Cecil.Pdb {
 		{
 			var entry_point = module.EntryPoint;
 			if (entry_point != null)
-				writer.SetUserEntryPoint (new SymbolToken (entry_point.MetadataToken.ToInt32 ()));
+				writer.SetUserEntryPoint (entry_point.MetadataToken.ToInt32 ());
 
 			writer.Close ();
 		}
 	}
+
+	enum CustomMetadataType : byte {
+		UsingInfo = 0,
+		ForwardInfo = 1,
+		IteratorScopes = 3,
+		ForwardIterator = 4,
+	}
+
+	class CustomMetadataWriter : IDisposable {
+
+		readonly SymWriter sym_writer;
+		readonly MemoryStream stream;
+		readonly BinaryStreamWriter writer;
+
+		int count;
+
+		const byte version = 4;
+
+		public CustomMetadataWriter (SymWriter sym_writer)
+		{
+			this.sym_writer = sym_writer;
+			this.stream = new MemoryStream ();
+			this.writer = new BinaryStreamWriter (stream);
+
+			writer.WriteByte (version);
+			writer.WriteByte (0); // count
+			writer.Align (4);
+		}
+
+		public void WriteUsingInfo (ImportDebugInformation import_info)
+		{
+			Write (CustomMetadataType.UsingInfo, () => {
+				writer.WriteUInt16 ((ushort) 1);
+				writer.WriteUInt16 ((ushort) import_info.Targets.Count);
+			});
+		}
+
+		public void WriteForwardInfo (MetadataToken import_parent)
+		{
+			Write (CustomMetadataType.ForwardInfo, () => writer.WriteUInt32 (import_parent.ToUInt32 ()));
+		}
+
+		public void WriteIteratorScopes (StateMachineScopeDebugInformation [] scopes, MethodDebugInformation debug_info)
+		{
+			Write (CustomMetadataType.IteratorScopes, () => {
+				writer.WriteInt32 (scopes.Length);
+				foreach (var scope in scopes) {
+					var start = scope.Start.Offset;
+					var end = scope.End.IsEndOfMethod ? debug_info.code_size : scope.End.Offset;
+					writer.WriteInt32 (start);
+					writer.WriteInt32 (end - 1);
+				}
+			});
+		}
+
+		public void WriteForwardIterator (TypeReference type)
+		{
+			Write (CustomMetadataType.ForwardIterator, () => writer.WriteBytes(Encoding.Unicode.GetBytes(type.Name)));
+		}
+
+		void Write (CustomMetadataType type, Action write)
+		{
+			count++;
+			writer.WriteByte (version);
+			writer.WriteByte ((byte) type);
+			writer.Align (4);
+
+			var length_position = writer.Position;
+			writer.WriteUInt32 (0);
+
+			write ();
+			writer.Align (4);
+
+			var end = writer.Position;
+			var length = end - length_position + 4; // header is 4 bytes long
+
+			writer.Position = length_position;
+			writer.WriteInt32 (length);
+
+			writer.Position = end;
+		}
+
+		public void WriteCustomMetadata ()
+		{
+			if (count == 0)
+				return;
+
+			writer.BaseStream.Position = 1;
+			writer.WriteByte ((byte) count);
+			writer.Flush ();
+
+			sym_writer.DefineCustomMetadata ("MD2", stream.ToArray ());
+		}
+
+		public void Dispose ()
+		{
+			stream.Dispose ();
+		}
+	}
 }
 
 #endif