Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

external/linker/cecil/Mono.Cecil.Cil/CodeReader.cs

@@ -159,17 +159,20 @@ namespace Mono.Cecil.Cil {
 
 		void ReadScope (ScopeDebugInformation scope)
 		{
-			scope.Start = new InstructionOffset (GetInstruction (scope.Start.Offset));
+			var start_instruction = GetInstruction (scope.Start.Offset);
+			if (start_instruction != null)
+				scope.Start = new InstructionOffset (start_instruction);
 
 			var end_instruction = GetInstruction (scope.End.Offset);
-			scope.End = end_instruction == null
-				? new InstructionOffset ()
-				: new InstructionOffset (end_instruction);
+			if (end_instruction != null)
+				scope.End = new InstructionOffset (end_instruction);
 
 			if (!scope.variables.IsNullOrEmpty ()) {
 				for (int i = 0; i < scope.variables.Count; i++) {
-					var variable = scope.variables [i];
-					variable.index = new VariableIndex (GetVariable (variable.Index));
+					var variable_info = scope.variables [i];
+					var variable = GetVariable (variable_info.Index);
+					if (variable != null)
+						variable_info.index = new VariableIndex (variable);
 				}
 			}
 
@@ -315,9 +318,7 @@ namespace Mono.Cecil.Cil {
 				switch (instruction.opcode.OperandType) {
 				case OperandType.ShortInlineBrTarget:
 				case OperandType.InlineBrTarget:
-					var targetInstruction = GetInstruction ((int) instruction.operand);
-					if (targetInstruction != null)
-						instruction.operand = targetInstruction;
+					instruction.operand = GetInstruction ((int) instruction.operand);
 					break;
 				case OperandType.InlineSwitch:
 					var offsets = (int []) instruction.operand;
@@ -435,13 +436,6 @@ namespace Mono.Cecil.Cil {
 			}
 		}
 
-		void Align (int align)
-		{
-			align--;
-			var position = Position;
-			Advance (((position + align) & ~align) - position);
-		}
-
 		public MetadataToken ReadToken ()
 		{
 			return new MetadataToken (ReadUInt32 ());

external/linker/cecil/Mono.Cecil.Cil/CodeWriter.cs

@@ -27,38 +27,35 @@ namespace Mono.Cecil.Cil {
 		readonly RVA code_base;
 		internal readonly MetadataBuilder metadata;
 		readonly Dictionary<uint, MetadataToken> standalone_signatures;
+		readonly Dictionary<ByteBuffer, RVA> tiny_method_bodies;
 
-		RVA current;
 		MethodBody body;
 
 		public CodeWriter (MetadataBuilder metadata)
 			: base (0)
 		{
 			this.code_base = metadata.text_map.GetNextRVA (TextSegment.CLIHeader);
-			this.current = code_base;
 			this.metadata = metadata;
 			this.standalone_signatures = new Dictionary<uint, MetadataToken> ();
+			this.tiny_method_bodies = new Dictionary<ByteBuffer, RVA> (new ByteBufferEqualityComparer ());
 		}
 
 		public RVA WriteMethodBody (MethodDefinition method)
 		{
-			var rva = BeginMethod ();
+			RVA rva;
 
 			if (IsUnresolved (method)) {
 				if (method.rva == 0)
 					return 0;
 
-				WriteUnresolvedMethodBody (method);
+				rva = WriteUnresolvedMethodBody (method);
 			} else {
 				if (IsEmptyMethodBody (method.Body))
 					return 0;
 
-				WriteResolvedMethodBody (method);
+				rva = WriteResolvedMethodBody (method);
 			}
 
-			Align (4);
-
-			EndMethod ();
 			return rva;
 		}
 
@@ -73,18 +70,25 @@ namespace Mono.Cecil.Cil {
 			return method.HasBody && method.HasImage && method.body == null;
 		}
 
-		void WriteUnresolvedMethodBody (MethodDefinition method)
+		RVA WriteUnresolvedMethodBody (MethodDefinition method)
 		{
 			var code_reader = metadata.module.reader.code;
 
 			int code_size;
 			MetadataToken local_var_token;
-			var buffer = code_reader.PatchRawMethodBody (method, this, out code_size, out local_var_token);
+			var raw_body = code_reader.PatchRawMethodBody (method, this, out code_size, out local_var_token);
+			var fat_header = (raw_body.buffer [0] & 0x3) == 0x3;
+			if (fat_header)
+				Align (4);
 
-			WriteBytes (buffer);
+			var rva = BeginMethod ();
+
+			if (fat_header || !GetOrMapTinyMethodBody (raw_body, ref rva))  {
+				WriteBytes (raw_body);
+			}
 
 			if (method.debug_info == null)
-				return;
+				return rva;
 
 			var symbol_writer = metadata.symbol_writer;
 			if (symbol_writer != null) {
@@ -92,21 +96,38 @@ namespace Mono.Cecil.Cil {
 				method.debug_info.local_var_token = local_var_token;
 				symbol_writer.Write (method.debug_info);
 			}
+
+			return rva;
 		}
 
-		void WriteResolvedMethodBody (MethodDefinition method)
+		RVA WriteResolvedMethodBody(MethodDefinition method)
 		{
+			RVA rva;
+
 			body = method.Body;
 			ComputeHeader ();
-			if (RequiresFatHeader ())
+			if (RequiresFatHeader ()) {
+				Align (4);
+				rva = BeginMethod ();
 				WriteFatHeader ();
-			else
+				WriteInstructions ();
+
+				if (body.HasExceptionHandlers)
+					WriteExceptionHandlers ();
+			} else {
+				rva = BeginMethod ();
 				WriteByte ((byte) (0x2 | (body.CodeSize << 2))); // tiny
+				WriteInstructions ();
 
-			WriteInstructions ();
+				var start_position = (int) (rva - code_base);
+				var body_size = position - start_position;
+				var body_bytes = new byte [body_size];
 
-			if (body.HasExceptionHandlers)
-				WriteExceptionHandlers ();
+				Array.Copy (buffer, start_position, body_bytes, 0, body_size);
+
+				if (GetOrMapTinyMethodBody (new ByteBuffer (body_bytes), ref rva))
+					position = start_position;
+			}
 
 			var symbol_writer = metadata.symbol_writer;
 			if (symbol_writer != null && method.debug_info != null) {
@@ -114,6 +135,20 @@ namespace Mono.Cecil.Cil {
 				method.debug_info.local_var_token = body.local_var_token;
 				symbol_writer.Write (method.debug_info);
 			}
+
+			return rva;
+		}
+
+		bool GetOrMapTinyMethodBody (ByteBuffer body, ref RVA rva)
+		{
+			RVA existing_rva;
+			if (tiny_method_bodies.TryGetValue (body, out existing_rva)) {
+				rva = existing_rva;
+				return true;
+			}
+
+			tiny_method_bodies.Add (body, rva);
+			return false;
 		}
 
 		void WriteFatHeader ()
@@ -166,8 +201,9 @@ namespace Mono.Cecil.Cil {
 				return;
 
 			var operand = instruction.operand;
-			if (operand == null)
+			if (operand == null && !(operand_type == OperandType.InlineBrTarget || operand_type == OperandType.ShortInlineBrTarget)) {
 				throw new ArgumentException ();
+			}
 
 			switch (operand_type) {
 			case OperandType.InlineSwitch: {
@@ -179,11 +215,15 @@ namespace Mono.Cecil.Cil {
 				break;
 			}
 			case OperandType.ShortInlineBrTarget: {
-				WriteSByte ((sbyte) (GetTargetOffset (operand) - (instruction.Offset + opcode.Size + 1)));
+				var target = (Instruction) operand;
+				var offset = target != null ? GetTargetOffset (target) : body.code_size;
+				WriteSByte ((sbyte) (offset - (instruction.Offset + opcode.Size + 1)));
 				break;
 			}
 			case OperandType.InlineBrTarget: {
-				WriteInt32 (GetTargetOffset (operand) - (instruction.Offset + opcode.Size + 4));
+				var target = (Instruction) operand;
+				var offset = target != null ? GetTargetOffset (target) : body.code_size;
+				WriteInt32 (offset - (instruction.Offset + opcode.Size + 4));
 				break;
 			}
 			case OperandType.ShortInlineVar:
@@ -236,12 +276,8 @@ namespace Mono.Cecil.Cil {
 			}
 		}
 
-		int GetTargetOffset (object o)
+		int GetTargetOffset (Instruction instruction)
 		{
-			if (o is int)
-				return (int) o;
-
-			Instruction instruction = o as Instruction;
 			if (instruction == null) {
 				var last = body.instructions [body.instructions.size - 1];
 				return last.offset + last.GetSize ();
@@ -365,7 +401,7 @@ namespace Mono.Cecil.Cil {
 				CopyBranchStackSize (ref stack_sizes, (Instruction) instruction.operand, stack_size);
 				break;
 			case OperandType.InlineSwitch:
-				var targets = (Instruction[]) instruction.operand;
+				var targets = (Instruction []) instruction.operand;
 				for (int i = 0; i < targets.Length; i++)
 					CopyBranchStackSize (ref stack_sizes, targets [i], stack_size);
 				break;
@@ -604,7 +640,7 @@ namespace Mono.Cecil.Cil {
 
 		RVA BeginMethod ()
 		{
-			return current;
+			return (RVA)(code_base + position);
 		}
 
 		void WriteMetadataToken (MetadataToken token)
@@ -617,11 +653,6 @@ namespace Mono.Cecil.Cil {
 			align--;
 			WriteBytes (((position + align) & ~align) - position);
 		}
-
-		void EndMethod ()
-		{
-			current = (RVA) (code_base + position);
-		}
 	}
 }
 

external/linker/cecil/Mono.Cecil.Cil/Instruction.cs

@@ -109,7 +109,7 @@ namespace Mono.Cecil.Cil {
 			switch (opcode.OperandType) {
 			case OperandType.ShortInlineBrTarget:
 			case OperandType.InlineBrTarget:
-				AppendLabel (instruction, operand);
+				AppendLabel (instruction, (Instruction) operand);
 				break;
 			case OperandType.InlineSwitch:
 				var labels = (Instruction []) operand;
@@ -133,15 +133,10 @@ namespace Mono.Cecil.Cil {
 			return instruction.ToString ();
 		}
 
-		static void AppendLabel (StringBuilder builder, object o)
+		static void AppendLabel (StringBuilder builder, Instruction instruction)
 		{
 			builder.Append ("IL_");
-			if (o is Instruction)
-				builder.Append ((o as Instruction).offset.ToString ("x4"));
-			else if (o is int) {
-				builder.Append (((int)o).ToString ("x4"));
-				builder.Append (" (invalid)");
-			}
+			builder.Append (instruction.offset.ToString ("x4"));
 		}
 
 		public static Instruction Create (OpCode opcode)

external/linker/cecil/Mono.Cecil.Cil/PortablePdb.cs

@@ -11,6 +11,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.IO.Compression;
 
 using Mono.Cecil.Metadata;
 using Mono.Cecil.PE;
@@ -19,7 +20,6 @@ namespace Mono.Cecil.Cil {
 
 	public sealed class PortablePdbReaderProvider : ISymbolReaderProvider {
 
-#if !PCL
 		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
 		{
 			Mixin.CheckModule (module);
@@ -28,7 +28,6 @@ namespace Mono.Cecil.Cil {
 			var file = File.OpenRead (Mixin.GetPdbFileName (fileName));
 			return GetSymbolReader (module, Disposable.Owned (file as Stream), file.Name);
 		}
-#endif
 
 		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
 		{
@@ -61,20 +60,31 @@ namespace Mono.Cecil.Cil {
 			this.debug_reader = new MetadataReader (image, module, this.reader);
 		}
 
-		public bool ProcessDebugHeader (ImageDebugDirectory directory, byte [] header)
+		public ISymbolWriterProvider GetWriterProvider ()
+		{
+			return new PortablePdbWriterProvider ();
+		}
+
+		public bool ProcessDebugHeader (ImageDebugHeader header)
 		{
 			if (image == module.Image)
 				return true;
 
-			if (header.Length < 24)
+			var entry = header.GetCodeViewEntry ();
+			if (entry == null)
 				return false;
 
-			var magic = ReadInt32 (header, 0);
+			var data = entry.Data;
+
+			if (data.Length < 24)
+				return false;
+
+			var magic = ReadInt32 (data, 0);
 			if (magic != 0x53445352)
 				return false;
 
 			var buffer = new byte [16];
-			Buffer.BlockCopy (header, 4, buffer, 0, 16);
+			Buffer.BlockCopy (data, 4, buffer, 0, 16);
 
 			var module_guid = new Guid (buffer);
 
@@ -132,11 +142,80 @@ namespace Mono.Cecil.Cil {
 		}
 	}
 
+	public sealed class EmbeddedPortablePdbReaderProvider : ISymbolReaderProvider {
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckFileName (fileName);
+
+			var header = module.GetDebugHeader ();
+			var entry = header.GetEmbeddedPortablePdbEntry ();
+			if (entry == null)
+				throw new InvalidOperationException ();
+
+			return new EmbeddedPortablePdbReader (
+				(PortablePdbReader) new PortablePdbReaderProvider ().GetSymbolReader (module, GetPortablePdbStream (entry)));
+		}
+
+		static Stream GetPortablePdbStream (ImageDebugHeaderEntry entry)
+		{
+			var compressed_stream = new MemoryStream (entry.Data);
+			var reader = new BinaryStreamReader (compressed_stream);
+			reader.ReadInt32 (); // signature
+			var length = reader.ReadInt32 ();
+			var decompressed_stream = new MemoryStream (length);
+
+			using (var deflate_stream = new DeflateStream (compressed_stream, CompressionMode.Decompress, leaveOpen: true))
+				deflate_stream.CopyTo (decompressed_stream);
+
+			return decompressed_stream;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbReader : ISymbolReader
+	{
+		private readonly PortablePdbReader reader;
+
+		internal EmbeddedPortablePdbReader (PortablePdbReader reader)
+		{
+			if (reader == null)
+				throw new ArgumentNullException ();
+
+			this.reader = reader;
+		}
+
+		public ISymbolWriterProvider GetWriterProvider ()
+		{
+			return new EmbeddedPortablePdbWriterProvider ();
+		}
+
+		public bool ProcessDebugHeader (ImageDebugHeader header)
+		{
+			return reader.ProcessDebugHeader (header);
+		}
+
+		public MethodDebugInformation Read (MethodDefinition method)
+		{
+			return reader.Read (method);
+		}
+
+		public void Dispose ()
+		{
+			reader.Dispose ();
+		}
+	}
+
+
 #if !READ_ONLY
 
 	public sealed class PortablePdbWriterProvider : ISymbolWriterProvider
 	{
-#if !PCL
 		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
 		{
 			Mixin.CheckModule (module);
@@ -145,7 +224,6 @@ namespace Mono.Cecil.Cil {
 			var file = File.OpenWrite (Mixin.GetPdbFileName (fileName));
 			return GetSymbolWriter (module, Disposable.Owned (file as Stream));
 		}
-#endif
 
 		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
 		{
@@ -164,7 +242,11 @@ namespace Mono.Cecil.Cil {
 		}
 	}
 
-	sealed class PortablePdbWriter : ISymbolWriter {
+	interface IMetadataSymbolWriter : ISymbolWriter {
+		void SetMetadata (MetadataBuilder metadata);
+	}
+
+	public sealed class PortablePdbWriter : ISymbolWriter, IMetadataSymbolWriter {
 
 		readonly MetadataBuilder pdb_metadata;
 		readonly ModuleDefinition module;
@@ -174,19 +256,19 @@ namespace Mono.Cecil.Cil {
 
 		bool IsEmbedded { get { return writer == null; } }
 
-		public PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module)
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module)
 		{
 			this.pdb_metadata = pdb_metadata;
 			this.module = module;
 		}
 
-		public PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer)
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer)
 			: this (pdb_metadata, module)
 		{
 			this.writer = writer;
 		}
 
-		public void SetModuleMetadata (MetadataBuilder metadata)
+		void IMetadataSymbolWriter.SetMetadata (MetadataBuilder metadata)
 		{
 			this.module_metadata = metadata;
 
@@ -194,18 +276,21 @@ namespace Mono.Cecil.Cil {
 				this.pdb_metadata.metadata_builder = metadata;
 		}
 
-		public bool GetDebugHeader (out ImageDebugDirectory directory, out byte [] header)
+		public ISymbolReaderProvider GetReaderProvider ()
 		{
-			if (IsEmbedded) {
-				directory = new ImageDebugDirectory ();
-				header = Empty<byte>.Array;
-				return false;
-			}
+			return new PortablePdbReaderProvider ();
+		}
 
-			directory = new ImageDebugDirectory () {
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			if (IsEmbedded)
+				return new ImageDebugHeader ();
+
+			var directory = new ImageDebugDirectory () {
 				MajorVersion = 256,
-				MinorVersion = 20577,
-				Type = 2,
+				MinorVersion = 20557,
+				Type = ImageDebugType.CodeView,
+				TimeDateStamp = (int) module.timestamp,
 			};
 
 			var buffer = new ByteBuffer ();
@@ -219,10 +304,11 @@ namespace Mono.Cecil.Cil {
 			buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (writer.BaseStream.GetFileName ()));
 			buffer.WriteByte (0);
 
-			header = new byte [buffer.length];
-			Buffer.BlockCopy (buffer.buffer, 0, header, 0, buffer.length);
-			directory.SizeOfData = header.Length;
-			return true;
+			var data = new byte [buffer.length];
+			Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
+			directory.SizeOfData = data.Length;
+
+			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
 		}
 
 		public void Write (MethodDebugInformation info)
@@ -248,13 +334,20 @@ namespace Mono.Cecil.Cil {
 			if (IsEmbedded)
 				return;
 
+			WritePdbFile ();
+		}
+
+		void WritePdbFile ()
+		{
 			WritePdbHeap ();
+
 			WriteTableHeap ();
 
 			writer.BuildMetadataTextMap ();
 			writer.WriteMetadataHeader ();
 			writer.WriteMetadata ();
 
+			writer.Flush ();
 			writer.stream.Dispose ();
 		}
 
@@ -263,7 +356,7 @@ namespace Mono.Cecil.Cil {
 			var pdb_heap = pdb_metadata.pdb_heap;
 
 			pdb_heap.WriteBytes (module.Mvid.ToByteArray ());
-			pdb_heap.WriteUInt32 (module_metadata.time_stamp);
+			pdb_heap.WriteUInt32 (module_metadata.timestamp);
 
 			pdb_heap.WriteUInt32 (module_metadata.entry_point.ToUInt32 ());
 
@@ -290,10 +383,92 @@ namespace Mono.Cecil.Cil {
 
 		void WriteTableHeap ()
 		{
+			pdb_metadata.table_heap.string_offsets = pdb_metadata.string_heap.WriteStrings ();
+			pdb_metadata.table_heap.ComputeTableInformations ();
 			pdb_metadata.table_heap.WriteTableHeap ();
 		}
 	}
 
+	public sealed class EmbeddedPortablePdbWriterProvider : ISymbolWriterProvider {
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
+		{
+			Mixin.CheckModule (module);
+			Mixin.CheckFileName (fileName);
+
+			var stream = new MemoryStream ();
+			var pdb_writer = (PortablePdbWriter) new PortablePdbWriterProvider ().GetSymbolWriter (module, stream);
+			return new EmbeddedPortablePdbWriter (stream, pdb_writer);
+		}
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	public sealed class EmbeddedPortablePdbWriter : ISymbolWriter, IMetadataSymbolWriter {
+
+		readonly Stream stream;
+		readonly PortablePdbWriter writer;
+
+		internal EmbeddedPortablePdbWriter (Stream stream, PortablePdbWriter writer)
+		{
+			this.stream = stream;
+			this.writer = writer;
+		}
+
+		public ISymbolReaderProvider GetReaderProvider ()
+		{
+			return new EmbeddedPortablePdbReaderProvider ();
+		}
+
+		public ImageDebugHeader GetDebugHeader ()
+		{
+			writer.Dispose ();
+
+			var directory = new ImageDebugDirectory {
+				Type = ImageDebugType.EmbeddedPortablePdb,
+			};
+
+			var data = new MemoryStream ();
+
+			var w = new BinaryStreamWriter (data);
+			w.WriteByte (0x4d);
+			w.WriteByte (0x50);
+			w.WriteByte (0x44);
+			w.WriteByte (0x42);
+
+			w.WriteInt32 ((int) stream.Length);
+
+			stream.Position = 0;
+
+			using (var compress_stream = new DeflateStream (data, CompressionMode.Compress, leaveOpen: true))
+				stream.CopyTo (compress_stream);
+
+			directory.SizeOfData = (int) data.Length;
+
+			return new ImageDebugHeader (new [] {
+				writer.GetDebugHeader ().Entries [0],
+				new ImageDebugHeaderEntry (directory, data.ToArray ())
+			});
+		}
+
+		public void Write (MethodDebugInformation info)
+		{
+			writer.Write (info);
+		}
+
+		public void Dispose ()
+		{
+		}
+
+		void IMetadataSymbolWriter.SetMetadata (MetadataBuilder metadata)
+		{
+			((IMetadataSymbolWriter) writer).SetMetadata (metadata);
+		}
+	}
+
 #endif
 
 	static class PdbGuidMapping {

external/linker/cecil/Mono.Cecil.Cil/SequencePoint.cs

@@ -47,7 +47,7 @@ namespace Mono.Cecil.Cil {
 		}
 
 		public bool IsHidden {
-			get { return start_line == 0xfeefee && start_line == start_column; }
+			get { return start_line == 0xfeefee && start_line == end_line; }
 		}
 
 		public Document Document {

external/linker/cecil/Mono.Cecil.Cil/Symbols.cs

@@ -15,21 +15,79 @@ using System.Runtime.InteropServices;
 using SR = System.Reflection;
 
 using Mono.Collections.Generic;
+using Mono.Cecil.Cil;
 
 namespace Mono.Cecil.Cil {
 
 	[StructLayout (LayoutKind.Sequential)]
 	public struct ImageDebugDirectory {
+		public const int Size = 28;
+
 		public int Characteristics;
 		public int TimeDateStamp;
 		public short MajorVersion;
 		public short MinorVersion;
-		public int Type;
+		public ImageDebugType Type;
 		public int SizeOfData;
 		public int AddressOfRawData;
 		public int PointerToRawData;
 	}
 
+	public enum ImageDebugType {
+		CodeView = 2,
+		Deterministic = 16,
+		EmbeddedPortablePdb = 17,
+	}
+
+	public sealed class ImageDebugHeader {
+
+		readonly ImageDebugHeaderEntry [] entries;
+
+		public bool HasEntries {
+			get { return !entries.IsNullOrEmpty (); }
+		}
+
+		public ImageDebugHeaderEntry [] Entries {
+			get { return entries; }
+		}
+
+		public ImageDebugHeader (ImageDebugHeaderEntry [] entries)
+		{
+			this.entries = entries ?? Empty<ImageDebugHeaderEntry>.Array;
+		}
+
+		public ImageDebugHeader ()
+			: this (Empty<ImageDebugHeaderEntry>.Array)
+		{
+		}
+
+		public ImageDebugHeader (ImageDebugHeaderEntry entry)
+			: this (new [] { entry })
+		{
+		}
+	}
+
+	public sealed class ImageDebugHeaderEntry {
+
+		ImageDebugDirectory directory;
+		readonly byte [] data;
+
+		public ImageDebugDirectory Directory {
+			get { return directory; }
+			internal set { directory = value; }
+		}
+
+		public byte [] Data {
+			get { return data; }
+		}
+
+		public ImageDebugHeaderEntry (ImageDebugDirectory directory, byte [] data)
+		{
+			this.directory = directory;
+			this.data = data ?? Empty<byte>.Array;
+		}
+	}
+
 	public sealed class ScopeDebugInformation : DebugInformation {
 
 		internal InstructionOffset start;
@@ -364,7 +422,7 @@ namespace Mono.Cecil.Cil {
 		}
 	}
 
-	interface ICustomDebugInformationProvider : IMetadataTokenProvider {
+	public interface ICustomDebugInformationProvider : IMetadataTokenProvider {
 		bool HasCustomDebugInformations { get; }
 		Collection<CustomDebugInformation> CustomDebugInformations { get; }
 	}
@@ -381,8 +439,10 @@ namespace Mono.Cecil.Cil {
 
 		Guid identifier;
 
-		public Guid Identifier { get { return identifier; } }
-		
+		public Guid Identifier {
+			get { return identifier; }
+		}
+
 		public abstract CustomDebugInformationKind Kind { get; }
 
 		internal CustomDebugInformation (Guid identifier)
@@ -454,6 +514,12 @@ namespace Mono.Cecil.Cil {
 		{
 			this.catch_handler = new InstructionOffset (catchHandler);
 		}
+
+		public AsyncMethodBodyDebugInformation ()
+			: base (KindIdentifier)
+		{
+			this.catch_handler = new InstructionOffset (-1);
+		}
 	}
 
 	public sealed class StateMachineScopeDebugInformation : CustomDebugInformation {
@@ -488,7 +554,7 @@ namespace Mono.Cecil.Cil {
 			: base (KindIdentifier)
 		{
 			this.start = new InstructionOffset (start);
-			this.end = new InstructionOffset (end);
+			this.end = end != null ? new InstructionOffset (end) : new InstructionOffset ();
 		}
 	}
 
@@ -618,28 +684,85 @@ namespace Mono.Cecil.Cil {
 
 	public interface ISymbolReader : IDisposable {
 
-		bool ProcessDebugHeader (ImageDebugDirectory directory, byte [] header);
+		ISymbolWriterProvider GetWriterProvider ();
+		bool ProcessDebugHeader (ImageDebugHeader header);
 		MethodDebugInformation Read (MethodDefinition method);
 	}
 
 	public interface ISymbolReaderProvider {
-#if !PCL
 		ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName);
-#endif
 		ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream);
 	}
 
-#if !PCL
+	public class DefaultSymbolReaderProvider : ISymbolReaderProvider {
+
+		readonly bool throw_if_no_symbol;
+
+		public DefaultSymbolReaderProvider ()
+			: this (throwIfNoSymbol: true)
+		{
+		}
+
+		public DefaultSymbolReaderProvider (bool throwIfNoSymbol)
+		{
+			throw_if_no_symbol = throwIfNoSymbol;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
+		{
+			if (module.Image.HasDebugTables ())
+				return null;
+
+			if (module.HasDebugHeader) {
+				var header = module.GetDebugHeader ();
+				var entry = header.GetEmbeddedPortablePdbEntry ();
+				if (entry != null)
+					return new EmbeddedPortablePdbReaderProvider ().GetSymbolReader (module, fileName);
+			}
+
+			var pdb_file_name = Mixin.GetPdbFileName (fileName);
+
+			if (File.Exists (pdb_file_name))
+				return Mixin.IsPortablePdb (Mixin.GetPdbFileName (fileName))
+					? new PortablePdbReaderProvider ().GetSymbolReader (module, fileName)
+					: SymbolProvider.GetReaderProvider (SymbolKind.NativePdb).GetSymbolReader (module, fileName);
+
+			var mdb_file_name = Mixin.GetMdbFileName (fileName);
+			if (File.Exists (mdb_file_name))
+				return SymbolProvider.GetReaderProvider (SymbolKind.Mdb).GetSymbolReader (module, fileName);
+
+			if (throw_if_no_symbol)
+				throw new FileNotFoundException (string.Format ("No symbol found for file: {0}", fileName));
+
+			return null;
+		}
+
+		public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
+	enum SymbolKind {
+		NativePdb,
+		PortablePdb,
+		EmbeddedPortablePdb,
+		Mdb,
+	}
+
 	static class SymbolProvider {
 
-		static readonly string symbol_kind = Type.GetType ("Mono.Runtime") != null ? "Mdb" : "Pdb";
-
-		static SR.AssemblyName GetPlatformSymbolAssemblyName ()
+		static SR.AssemblyName GetSymbolAssemblyName (SymbolKind kind)
 		{
-			var cecil_name = typeof (SymbolProvider).GetAssembly ().GetName ();
+			if (kind == SymbolKind.PortablePdb)
+				throw new ArgumentException ();
+
+			var suffix = GetSymbolNamespace (kind);
+
+			var cecil_name = typeof (SymbolProvider).Assembly ().GetName ();
 
 			var name = new SR.AssemblyName {
-				Name = "Mono.Cecil." + symbol_kind,
+				Name = cecil_name.Name + "." + suffix,
 				Version = cecil_name.Version,
 			};
 
@@ -648,13 +771,13 @@ namespace Mono.Cecil.Cil {
 			return name;
 		}
 
-		static Type GetPlatformType (string fullname)
+		static Type GetSymbolType (SymbolKind kind, string fullname)
 		{
 			var type = Type.GetType (fullname);
 			if (type != null)
 				return type;
 
-			var assembly_name = GetPlatformSymbolAssemblyName ();
+			var assembly_name = GetSymbolAssemblyName (kind);
 
 			type = Type.GetType (fullname + ", " + assembly_name.FullName);
 			if (type != null)
@@ -671,70 +794,122 @@ namespace Mono.Cecil.Cil {
 			return null;
 		}
 
-		static ISymbolReaderProvider reader_provider;
-
-		public static ISymbolReaderProvider GetPlatformReaderProvider ()
+		public static ISymbolReaderProvider GetReaderProvider (SymbolKind kind)
 		{
-			if (reader_provider != null)
-				return reader_provider;
+			if (kind == SymbolKind.PortablePdb)
+				return new PortablePdbReaderProvider ();
+			if (kind == SymbolKind.EmbeddedPortablePdb)
+				return new EmbeddedPortablePdbReaderProvider ();
 
-			var type = GetPlatformType (GetProviderTypeName ("ReaderProvider"));
+			var provider_name = GetSymbolTypeName (kind, "ReaderProvider");
+			var type = GetSymbolType (kind, provider_name);
 			if (type == null)
-				return null;
+				throw new TypeLoadException ("Could not find symbol provider type " + provider_name);
 
-			return reader_provider = (ISymbolReaderProvider) Activator.CreateInstance (type);
+			return (ISymbolReaderProvider) Activator.CreateInstance (type);
 		}
 
-		static string GetProviderTypeName (string name)
+		static string GetSymbolTypeName (SymbolKind kind, string name)
 		{
-			return "Mono.Cecil." + symbol_kind + "." + symbol_kind + name;
+			return "Mono.Cecil" + "." + GetSymbolNamespace (kind) + "." + kind + name;
 		}
 
-#if !READ_ONLY
-
-		static ISymbolWriterProvider writer_provider;
-
-		public static ISymbolWriterProvider GetPlatformWriterProvider ()
+		static string GetSymbolNamespace (SymbolKind kind)
 		{
-			if (writer_provider != null)
-				return writer_provider;
+			if (kind == SymbolKind.PortablePdb || kind == SymbolKind.EmbeddedPortablePdb)
+				return "Cil";
+			if (kind == SymbolKind.NativePdb)
+				return "Pdb";
+			if (kind == SymbolKind.Mdb)
+				return "Mdb";
 
-			var type = GetPlatformType (GetProviderTypeName ("WriterProvider"));
-			if (type == null)
-				return null;
-
-			return writer_provider = (ISymbolWriterProvider) Activator.CreateInstance (type);
+			throw new ArgumentException ();
 		}
-
-#endif
 	}
-#endif
 
 #if !READ_ONLY
 
 	public interface ISymbolWriter : IDisposable {
 
-		bool GetDebugHeader (out ImageDebugDirectory directory, out byte [] header);
+		ISymbolReaderProvider GetReaderProvider ();
+		ImageDebugHeader GetDebugHeader ();
 		void Write (MethodDebugInformation info);
 	}
 
 	public interface ISymbolWriterProvider {
 
-#if !PCL
 		ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName);
-#endif
 		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream);
 	}
 
+	public class DefaultSymbolWriterProvider : ISymbolWriterProvider {
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
+		{
+			var reader = module.SymbolReader;
+			if (reader == null)
+				throw new InvalidOperationException ();
+
+			if (module.Image != null && module.Image.HasDebugTables ())
+				return null;
+
+			return reader.GetWriterProvider ().GetSymbolWriter (module, fileName);
+		}
+
+		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
+		{
+			throw new NotSupportedException ();
+		}
+	}
+
 #endif
 }
 
-#if !PCL
-
 namespace Mono.Cecil {
 
 	static partial class Mixin {
 
+		public static ImageDebugHeaderEntry GetCodeViewEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.CodeView);
+		}
+
+		public static ImageDebugHeaderEntry GetDeterministicEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.Deterministic);
+		}
+
+		public static ImageDebugHeader AddDeterministicEntry (this ImageDebugHeader header)
+		{
+			var entry = new ImageDebugHeaderEntry (new ImageDebugDirectory { Type = ImageDebugType.Deterministic }, Empty<byte>.Array);
+			if (header == null)
+				return new ImageDebugHeader (entry);
+
+			var entries = new ImageDebugHeaderEntry [header.Entries.Length + 1];
+			Array.Copy (header.Entries, entries, header.Entries.Length);
+			entries [entries.Length - 1] = entry;
+			return new ImageDebugHeader (entries);
+		}
+
+		public static ImageDebugHeaderEntry GetEmbeddedPortablePdbEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.EmbeddedPortablePdb);
+		}
+
+		private static ImageDebugHeaderEntry GetEntry (this ImageDebugHeader header, ImageDebugType type)
+		{
+			if (!header.HasEntries)
+				return null;
+
+			for (var i = 0; i < header.Entries.Length; i++) {
+				var entry = header.Entries [i];
+				if (entry.Directory.Type == type)
+					return entry;
+			}
+
+			return null;
+		}
+
 		public static string GetPdbFileName (string assemblyFileName)
 		{
 			return Path.ChangeExtension (assemblyFileName, ".pdb");
@@ -744,7 +919,24 @@ namespace Mono.Cecil {
 		{
 			return assemblyFileName + ".mdb";
 		}
+
+		public static bool IsPortablePdb (string fileName)
+		{
+			using (var file = new FileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
+				return IsPortablePdb (file);
+		}
+
+		public static bool IsPortablePdb (Stream stream)
+		{
+			const uint ppdb_signature = 0x424a5342;
+
+			var position = stream.Position;
+			try {
+				var reader = new BinaryReader (stream);
+				return reader.ReadUInt32 () == ppdb_signature;
+			} finally {
+				stream.Position = position;
+			}
+		}
 	}
 }
-
-#endif