Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

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

@@ -0,0 +1,370 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Collections.Generic;
+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 : 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 ISymbolReaderProvider GetReaderProvider ()
+		{
+			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 = 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, out import_parent);
+
+			DefineCustomMetadata (info, import_parent);
+
+			writer.CloseMethod ();
+		}
+
+		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);
+
+			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];
+					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++) {
+					MetadataToken _;
+					DefineScope (scope.scopes [i], info, out _);
+				}
+			}
+
+			writer.CloseScope (end_offset);
+		}
+
+		void DefineSequencePoints (Collection<SequencePoint> sequence_points)
+		{
+			for (int i = 0; i < sequence_points.Count; i++) {
+				var sequence_point = sequence_points [i];
+
+				writer.DefineSequencePoints (
+					GetDocument (sequence_point.Document),
+					new [] { sequence_point.Offset },
+					new [] { sequence_point.StartLine },
+					new [] { sequence_point.StartColumn },
+					new [] { sequence_point.EndLine },
+					new [] { sequence_point.EndColumn });
+			}
+		}
+
+		void DefineLocalVariable (VariableDebugInformation variable, int local_var_token, int start_offset, int end_offset)
+		{
+			writer.DefineLocalVariable2 (
+				variable.Name,
+				variable.Attributes,
+				local_var_token,
+				variable.Index,
+				0,
+				0,
+				start_offset,
+				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)
+				return null;
+
+			SymDocumentWriter doc_writer;
+			if (documents.TryGetValue (document.Url, out doc_writer))
+				return doc_writer;
+
+			doc_writer = writer.DefineDocument (
+				document.Url,
+				document.Language.ToGuid (),
+				document.LanguageVendor.ToGuid (),
+				document.Type.ToGuid ());
+
+			documents [document.Url] = doc_writer;
+			return doc_writer;
+		}
+
+		public void Dispose ()
+		{
+			var entry_point = module.EntryPoint;
+			if (entry_point != null)
+				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