From 6ef0b758c9252b8e89688acf61252a9bb31e256b Mon Sep 17 00:00:00 2001 From: Tomas Matousek Date: Thu, 15 Jun 2017 15:09:53 -0700 Subject: [PATCH] Add Mono.Cecil.WindowsPdb --- .gitignore | 1 + Mono.Cecil.Cil/PortablePdb.cs | 13 +- Mono.Cecil.Cil/Symbols.cs | 22 + Mono.Cecil.Windows.nuspec | 37 ++ Mono.Cecil.props | 4 +- Mono.Cecil.sln | 53 ++- Mono.Cecil/AssemblyInfo.cs | 1 + .../Mono.Cecil.Pdb/AssemblyInfo.cs | 8 + .../Mono.Cecil.Pdb/ModuleMetadata.cs | 102 +++++ .../Mono.Cecil.Pdb/NativePdbWriter.cs | 403 ++++++++++++++++++ .../pdb.windows/Mono.Cecil.Pdb/PdbHelper.cs | 114 +++++ .../pdb.windows/Mono.Cecil.Pdb/ProjectInfo.cs | 13 + .../pdb.windows/Mono.Cecil.WindowsPdb.csproj | 34 ++ .../pdb.windows/Resources/assemblies/test.exe | Bin 0 -> 4096 bytes .../pdb.windows/Resources/assemblies/test.pdb | Bin 0 -> 11776 bytes .../Test/Mono.Cecil.Tests/WindowsPdbTests.cs | 63 +++ .../Test/Mono.Cecil.WindowsPdb.Tests.csproj | 38 ++ symbols/pdb/Mono.Cecil.Pdb/AssemblyInfo.cs | 3 + 18 files changed, 885 insertions(+), 24 deletions(-) create mode 100644 Mono.Cecil.Windows.nuspec create mode 100644 symbols/pdb.windows/Mono.Cecil.Pdb/AssemblyInfo.cs create mode 100644 symbols/pdb.windows/Mono.Cecil.Pdb/ModuleMetadata.cs create mode 100644 symbols/pdb.windows/Mono.Cecil.Pdb/NativePdbWriter.cs create mode 100644 symbols/pdb.windows/Mono.Cecil.Pdb/PdbHelper.cs create mode 100644 symbols/pdb.windows/Mono.Cecil.Pdb/ProjectInfo.cs create mode 100644 symbols/pdb.windows/Mono.Cecil.WindowsPdb.csproj create mode 100644 symbols/pdb.windows/Resources/assemblies/test.exe create mode 100644 symbols/pdb.windows/Resources/assemblies/test.pdb create mode 100644 symbols/pdb.windows/Test/Mono.Cecil.Tests/WindowsPdbTests.cs create mode 100644 symbols/pdb.windows/Test/Mono.Cecil.WindowsPdb.Tests.csproj diff --git a/.gitignore b/.gitignore index 08c8509f5..187dfc831 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ bin obj +packages *.suo *.iml *.user diff --git a/Mono.Cecil.Cil/PortablePdb.cs b/Mono.Cecil.Cil/PortablePdb.cs index 717249e90..c9ff26ad9 100644 --- a/Mono.Cecil.Cil/PortablePdb.cs +++ b/Mono.Cecil.Cil/PortablePdb.cs @@ -311,23 +311,12 @@ public ImageDebugHeader GetDebugHeader () TimeDateStamp = (int) module.timestamp, }; - var buffer = new ByteBuffer (); - // RSDS - buffer.WriteUInt32 (0x53445352); - // Module ID - buffer.WriteBytes (module.Mvid.ToByteArray ()); - // PDB Age - buffer.WriteUInt32 (1); - // PDB Path var filename = writer.BaseStream.GetFileName (); if (!string.IsNullOrEmpty (filename)) filename = Path.GetFileName (filename); - buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (filename)); - buffer.WriteByte (0); + var data = Mixin.GetCodeViewData (module.Mvid, filename, age: 1); - 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)); diff --git a/Mono.Cecil.Cil/Symbols.cs b/Mono.Cecil.Cil/Symbols.cs index 3efc9e236..eb40f4442 100644 --- a/Mono.Cecil.Cil/Symbols.cs +++ b/Mono.Cecil.Cil/Symbols.cs @@ -16,6 +16,7 @@ using Mono.Collections.Generic; using Mono.Cecil.Cil; +using Mono.Cecil.PE; namespace Mono.Cecil.Cil { @@ -939,6 +940,27 @@ public static ImageDebugHeaderEntry GetCodeViewEntry (this ImageDebugHeader head return GetEntry (header, ImageDebugType.CodeView); } +#if !READ_ONLY + + public static byte[] GetCodeViewData (Guid pdb_id, string pdb_path, int age) + { + var buffer = new ByteBuffer (); + // RSDS + buffer.WriteUInt32 (0x53445352); + // Module ID + buffer.WriteBytes (pdb_id.ToByteArray ()); + // PDB Age + buffer.WriteInt32 (age); + // PDB Path + buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (pdb_path)); + buffer.WriteByte (0); + + var data = new byte[buffer.length]; + Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length); + return data; + } +#endif + public static ImageDebugHeaderEntry GetDeterministicEntry (this ImageDebugHeader header) { return GetEntry (header, ImageDebugType.Deterministic); diff --git a/Mono.Cecil.Windows.nuspec b/Mono.Cecil.Windows.nuspec new file mode 100644 index 000000000..a7bf482d4 --- /dev/null +++ b/Mono.Cecil.Windows.nuspec @@ -0,0 +1,37 @@ + + + + Mono.Cecil.Windows + 0.10.0.0-beta6 + Mono.Cecil.Windows + Jb Evain, Microsoft + Jb Evain + http://opensource.org/licenses/mit-license.php + false + http://github.com/jbevain/cecil/ + Adds full Windows PDB support to Mono.Cecil + Cecil is a library written by Jb Evain to generate and inspect programs and libraries in the ECMA CIL format. It has full support for generics, and support some debugging symbol format. In simple English, with Cecil, you can load existing managed assemblies, browse all the contained types, modify them on the fly and save back to the disk the modified assembly. + en-US + assembly assemblies module modules il cil msil bytecode reflection injection cecil mono aop + + + + + + + + + + + + + + + + + + + + + + diff --git a/Mono.Cecil.props b/Mono.Cecil.props index e002c3fb9..70042c2a8 100644 --- a/Mono.Cecil.props +++ b/Mono.Cecil.props @@ -46,9 +46,9 @@ net462 netstandard1.3 - + - + diff --git a/Mono.Cecil.sln b/Mono.Cecil.sln index c37774ef5..b786068ff 100644 --- a/Mono.Cecil.sln +++ b/Mono.Cecil.sln @@ -1,6 +1,6 @@ Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 14 -VisualStudioVersion = 14.0.25420.1 +# Visual Studio 15 +VisualStudioVersion = 15.0.26612.0 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{74E5ECE0-06B4-401C-AEBA-E8DD53E17943}" EndProject @@ -22,6 +22,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil.Rocks.Tests", "r EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil.Rocks", "rocks\Mono.Cecil.Rocks.csproj", "{FBC6DD59-D09D-499C-B03C-99C1C78FF2AC}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil.WindowsPdb", "symbols\pdb.windows\Mono.Cecil.WindowsPdb.csproj", "{1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil.WindowsPdb.Tests", "symbols\pdb.windows\Test\Mono.Cecil.WindowsPdb.Tests.csproj", "{77E8A7D2-4DC4-43E1-94FF-002B33FF2397}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution net_3_5_Debug_ReadOnly|Any CPU = net_3_5_Debug_ReadOnly|Any CPU @@ -79,11 +83,9 @@ Global {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.net_4_0_Release|Any CPU.Build.0 = net_4_0_Release|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU - {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU - {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU {8559DD7F-A16F-46D0-A05A-9139FAEBA8FD}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU @@ -127,11 +129,9 @@ Global {AC71DF9C-99FA-4A63-990A-66C8010355A6}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.net_4_0_Release|Any CPU.Build.0 = net_4_0_Release|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU - {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU - {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU {AC71DF9C-99FA-4A63-990A-66C8010355A6}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU {63E6915C-7EA4-4D76-AB28-0D7191EEA626}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU @@ -175,11 +175,9 @@ Global {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.net_4_0_Release|Any CPU.Build.0 = net_4_0_Release|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU - {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU - {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU @@ -199,11 +197,9 @@ Global {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.net_4_0_Release|Any CPU.Build.0 = net_4_0_Release|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU - {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU - {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU {FBC6DD59-D09D-499C-B03C-99C1C78FF2AC}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU @@ -230,6 +226,38 @@ Global {FBC6DD59-D09D-499C-B03C-99C1C78FF2AC}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU {FBC6DD59-D09D-499C-B03C-99C1C78FF2AC}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU {FBC6DD59-D09D-499C-B03C-99C1C78FF2AC}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_3_5_Debug|Any CPU.ActiveCfg = net_3_5_Debug|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_3_5_Release_ReadOnly|Any CPU.ActiveCfg = net_3_5_Release_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_3_5_Release|Any CPU.ActiveCfg = net_3_5_Release|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_4_0_Debug_ReadOnly|Any CPU.ActiveCfg = net_4_0_Debug_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_4_0_Debug|Any CPU.ActiveCfg = net_4_0_Debug|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_4_0_Release_ReadOnly|Any CPU.ActiveCfg = net_4_0_Release_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_3_5_Debug_ReadOnly|Any CPU.ActiveCfg = net_3_5_Debug_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_3_5_Debug|Any CPU.ActiveCfg = net_3_5_Debug|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_3_5_Release_ReadOnly|Any CPU.ActiveCfg = net_3_5_Release_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_3_5_Release|Any CPU.ActiveCfg = net_3_5_Release|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_4_0_Debug_ReadOnly|Any CPU.ActiveCfg = net_4_0_Debug_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_4_0_Debug|Any CPU.ActiveCfg = net_4_0_Debug|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_4_0_Release_ReadOnly|Any CPU.ActiveCfg = net_4_0_Release_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.net_4_0_Release|Any CPU.ActiveCfg = net_4_0_Release|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Debug_ReadOnly|Any CPU.ActiveCfg = netstandard_Debug_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Debug_ReadOnly|Any CPU.Build.0 = netstandard_Debug_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Debug|Any CPU.ActiveCfg = netstandard_Debug|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Debug|Any CPU.Build.0 = netstandard_Debug|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Release_ReadOnly|Any CPU.ActiveCfg = netstandard_Release_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Release_ReadOnly|Any CPU.Build.0 = netstandard_Release_ReadOnly|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Release|Any CPU.ActiveCfg = netstandard_Release|Any CPU + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397}.netstandard_Release|Any CPU.Build.0 = netstandard_Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -241,5 +269,10 @@ Global {63E6915C-7EA4-4D76-AB28-0D7191EEA626} = {929D5B3B-E29A-40CC-93D8-0FF43A6F9FA1} {29300103-CB76-4A1D-B6FD-FFD91C1EC8AA} = {74E5ECE0-06B4-401C-AEBA-E8DD53E17943} {C6CFD7E1-B855-44DC-B4CE-9CD72984AF52} = {74E5ECE0-06B4-401C-AEBA-E8DD53E17943} + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE} = {929D5B3B-E29A-40CC-93D8-0FF43A6F9FA1} + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397} = {74E5ECE0-06B4-401C-AEBA-E8DD53E17943} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {9F99F5B5-3BEF-4AC3-8E6A-94BA9CFA9381} EndGlobalSection EndGlobal diff --git a/Mono.Cecil/AssemblyInfo.cs b/Mono.Cecil/AssemblyInfo.cs index 5571093b6..5cc8fa682 100644 --- a/Mono.Cecil/AssemblyInfo.cs +++ b/Mono.Cecil/AssemblyInfo.cs @@ -18,6 +18,7 @@ [assembly: Guid ("fd225bb4-fa53-44b2-a6db-85f5e48dcb54")] #endif +[assembly: InternalsVisibleTo ("Mono.Cecil.WindowsPdb, PublicKey=" + Consts.PublicKey)] [assembly: InternalsVisibleTo ("Mono.Cecil.Pdb, PublicKey=" + Consts.PublicKey)] [assembly: InternalsVisibleTo ("Mono.Cecil.Mdb, PublicKey=" + Consts.PublicKey)] [assembly: InternalsVisibleTo ("Mono.Cecil.Rocks, PublicKey=" + Consts.PublicKey)] diff --git a/symbols/pdb.windows/Mono.Cecil.Pdb/AssemblyInfo.cs b/symbols/pdb.windows/Mono.Cecil.Pdb/AssemblyInfo.cs new file mode 100644 index 000000000..d3a01b08f --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.Pdb/AssemblyInfo.cs @@ -0,0 +1,8 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Reflection; + +[assembly: AssemblyTitle ("Mono.Cecil.WindowsPdb")] + +[assembly: CLSCompliant (false)] diff --git a/symbols/pdb.windows/Mono.Cecil.Pdb/ModuleMetadata.cs b/symbols/pdb.windows/Mono.Cecil.Pdb/ModuleMetadata.cs new file mode 100644 index 000000000..fa86e9738 --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.Pdb/ModuleMetadata.cs @@ -0,0 +1,102 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +#if !READ_ONLY + +using System.Collections.Generic; +using System.Reflection; +using Microsoft.DiaSymReader; + +namespace Mono.Cecil.WindowsPdb { + + class ModuleMetadata : ISymWriterMetadataProvider { + + readonly ModuleDefinition module; + + Dictionary types; + Dictionary methods; + + public ModuleMetadata (ModuleDefinition module) + { + this.module = module; + } + + bool TryGetType (uint token, out TypeDefinition type) + { + if (types == null) + InitializeMetadata (module); + + return types.TryGetValue (token, out type); + } + + bool TryGetMethod (uint token, out MethodDefinition method) + { + if (methods == null) + InitializeMetadata (module); + + return methods.TryGetValue (token, out method); + } + + void InitializeMetadata (ModuleDefinition module) + { + types = new Dictionary (); + methods = new Dictionary (); + + foreach (var type in module.GetTypes ()) { + types.Add (type.MetadataToken.ToUInt32 (), type); + InitializeMethods (type); + } + } + + void InitializeMethods (TypeDefinition type) + { + foreach (var method in type.Methods) + methods.Add (method.MetadataToken.ToUInt32 (), method); + } + + public bool TryGetTypeDefinitionInfo (int typeDefinitionToken, out string namespaceName, out string typeName, out System.Reflection.TypeAttributes attributes, out int baseTypeToken) + { + TypeDefinition type; + if (!TryGetType ((uint)typeDefinitionToken, out type)) { + namespaceName = null; + typeName = null; + attributes = 0; + baseTypeToken = 0; + return false; + } + + typeName = type.IsNested ? type.Name : type.FullName; + namespaceName = type.Namespace; + attributes = (System.Reflection.TypeAttributes)type.Attributes; + baseTypeToken = type.BaseType.MetadataToken.ToInt32 (); + return true; + } + + public bool TryGetEnclosingType (int nestedTypeToken, out int enclosingTypeToken) + { + TypeDefinition type; + if (!TryGetType ((uint)nestedTypeToken, out type) || !type.IsNested) { + enclosingTypeToken = 0; + return false; + } + + enclosingTypeToken = type.DeclaringType.MetadataToken.ToInt32 (); + return true; + } + + public bool TryGetMethodInfo (int methodDefinitionToken, out string methodName, out int declaringTypeToken) + { + MethodDefinition method; + if (!TryGetMethod ((uint)methodDefinitionToken, out method)) { + methodName = null; + declaringTypeToken = 0; + return false; + } + + declaringTypeToken = method.DeclaringType.MetadataToken.ToInt32 (); + methodName = method.Name; + return true; + } + } +} + +#endif diff --git a/symbols/pdb.windows/Mono.Cecil.Pdb/NativePdbWriter.cs b/symbols/pdb.windows/Mono.Cecil.Pdb/NativePdbWriter.cs new file mode 100644 index 000000000..56dc1fd69 --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.Pdb/NativePdbWriter.cs @@ -0,0 +1,403 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +#if !READ_ONLY + +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; + +using Microsoft.DiaSymReader; + +namespace Mono.Cecil.WindowsPdb { + + public class NativePdbWriter : ISymbolWriter, IMetadataSymbolWriter { + const int Age = 1; + + readonly ModuleDefinition module; + readonly SymUnmanagedWriter writer; + readonly SymUnmanagedSequencePointsWriter sequence_point_writer; + readonly string pdb_path; + readonly Dictionary documents; + readonly Dictionary import_info_to_parent; + readonly Guid id; + readonly uint timestamp; + + MetadataBuilder metadata; + + internal NativePdbWriter (ModuleDefinition module, SymUnmanagedWriter writer, string pdb_path) + { + this.module = module; + this.writer = writer; + this.sequence_point_writer = new SymUnmanagedSequencePointsWriter (writer, capacity: 64); + this.pdb_path = pdb_path; + this.documents = new Dictionary (); + this.import_info_to_parent = new Dictionary (); + + // TODO: calculate id based on the content to produce deterministic output + this.id = Guid.NewGuid (); + this.timestamp = module.timestamp; + } + + public ISymbolReaderProvider GetReaderProvider () + { + return new NativePdbReaderProvider (); + } + + public ImageDebugHeader GetDebugHeader () + { + var data = Mixin.GetCodeViewData (id, pdb_path, Age); + + var directory = new ImageDebugDirectory () { + MajorVersion = 0, + MinorVersion = 0, + Type = ImageDebugType.CodeView, + TimeDateStamp = (int)timestamp, + SizeOfData = data.Length, + }; + + 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 IMetadataSymbolWriter.WriteModule () + { + } + + 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 ().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; + + int offsetCount = async_debug_info.Resumes.Count; + + int[] yieldOffsets = new int[offsetCount]; + int[] resumeOffsets = new int[offsetCount]; + for (int i = 0; i < offsetCount; i++) { + yieldOffsets[i] = async_debug_info.Yields[i].Offset; + resumeOffsets[i] = async_debug_info.Resumes[i].Offset; + } + + writer.SetAsyncInfo ( + moveNextMethodToken: async_debug_info.MoveNextMethod.MetadataToken.ToInt32 (), + kickoffMethodToken: info.StateMachineKickOffMethod.MetadataToken.ToInt32 (), + catchHandlerOffset: async_debug_info.CatchHandler.Offset, + yieldOffsets: yieldOffsets, + resumeOffsets: resumeOffsets); + } + } + + 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); + } + } + + 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 sequence_points) + { + int current_doc_index = -1; + Document current_doc = null; + + for (int i = 0; i < sequence_points.Count; i++) { + var sequence_point = sequence_points[i]; + + if (!ReferenceEquals(current_doc, sequence_point.Document)) { + current_doc_index = GetDocumentIndex (sequence_point.Document); + current_doc = sequence_point.Document; + } + + sequence_point_writer.Add ( + current_doc_index, + sequence_point.Offset, + sequence_point.StartLine, + sequence_point.StartColumn, + sequence_point.EndLine, + sequence_point.EndColumn); + } + + sequence_point_writer.Flush (); + } + + void DefineLocalVariable (VariableDebugInformation variable, int local_var_token) + { + writer.DefineLocalVariable ( + variable.Index, + variable.Name, + (int)variable.Attributes, + local_var_token); + } + + void DefineConstant (ConstantDebugInformation constant) + { + var row = metadata.AddStandAloneSignature (metadata.GetConstantTypeBlobIndex (constant.ConstantType)); + var token = new MetadataToken (TokenType.Signature, row); + + writer.DefineLocalConstant (constant.Name, constant.Value, token.ToInt32 ()); + } + + int GetDocumentIndex (Document document) + { + if (document == null) + return -1; + + int doc_index; + if (documents.TryGetValue (document.Url, out doc_index)) + return doc_index; + + doc_index = writer.DefineDocument ( + document.Url, + document.Language.ToGuid (), + document.LanguageVendor.ToGuid (), + document.Type.ToGuid (), + document.HashAlgorithm.ToGuid (), + document.Hash, + source: null); // TODO: implement support for embedded source + + documents [document.Url] = doc_index; + return doc_index; + } + + public void Dispose () + { + var entry_point = module.EntryPoint; + if (entry_point != null) + writer.SetEntryPoint (entry_point.MetadataToken.ToInt32 ()); + + writer.UpdateSignature (id, timestamp, Age); + + using (var stream = new FileStream (pdb_path, FileMode.Create, FileAccess.Write, FileShare.None)) { + writer.WriteTo (stream); + } + + writer.Dispose (); + } + } + + enum CustomMetadataType : byte { + UsingInfo = 0, + ForwardInfo = 1, + IteratorScopes = 3, + ForwardIterator = 4, + } + + class CustomMetadataWriter : IDisposable { + + readonly SymUnmanagedWriter sym_writer; + readonly MemoryStream stream; + readonly BinaryStreamWriter writer; + + int count; + + const byte version = 4; + + public CustomMetadataWriter (SymUnmanagedWriter 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 (stream.ToArray ()); + } + + public void Dispose () + { + stream.Dispose (); + } + } +} + +#endif diff --git a/symbols/pdb.windows/Mono.Cecil.Pdb/PdbHelper.cs b/symbols/pdb.windows/Mono.Cecil.Pdb/PdbHelper.cs new file mode 100644 index 000000000..112457785 --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.Pdb/PdbHelper.cs @@ -0,0 +1,114 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.IO; + +using Mono.Cecil.Cil; + +#if !READ_ONLY +using Microsoft.DiaSymReader; +#endif + +namespace Mono.Cecil.WindowsPdb { + + public sealed class NativePdbReaderProvider : ISymbolReaderProvider { + + public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName) + { + Mixin.CheckModule (module); + Mixin.CheckFileName (fileName); + + return new Pdb.NativePdbReader (Disposable.Owned (File.OpenRead (Mixin.GetPdbFileName (fileName)) as Stream)); + } + + public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream) + { + Mixin.CheckModule (module); + Mixin.CheckStream (symbolStream); + + return new Pdb.NativePdbReader (Disposable.NotOwned (symbolStream)); + } + } + + public sealed class PdbReaderProvider : ISymbolReaderProvider { + + public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName) + { + Mixin.CheckModule (module); + Mixin.CheckFileName (fileName); + + if (module.HasDebugHeader) { + var header = module.GetDebugHeader (); + var entry = header.GetEmbeddedPortablePdbEntry (); + if (entry != null) + return new EmbeddedPortablePdbReaderProvider ().GetSymbolReader (module, fileName); + } + + return Mixin.IsPortablePdb (Mixin.GetPdbFileName (fileName)) + ? new PortablePdbReaderProvider ().GetSymbolReader (module, fileName) + : new NativePdbReaderProvider ().GetSymbolReader (module, fileName); + } + + public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream) + { + Mixin.CheckModule (module); + Mixin.CheckStream (symbolStream); + Mixin.CheckReadSeek (symbolStream); + + return Mixin.IsPortablePdb (symbolStream) + ? new PortablePdbReaderProvider ().GetSymbolReader (module, symbolStream) + : new NativePdbReaderProvider ().GetSymbolReader (module, symbolStream); + } + } + +#if !READ_ONLY + + public sealed class NativePdbWriterProvider : ISymbolWriterProvider { + + public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName) + { + Mixin.CheckModule (module); + Mixin.CheckFileName (fileName); + + return new NativePdbWriter (module, SymUnmanagedWriterFactory.CreateWriter (new ModuleMetadata (module)), Mixin.GetPdbFileName (fileName)); + } + + public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream) + { + throw new NotImplementedException (); + } + } + + public sealed class PdbWriterProvider : ISymbolWriterProvider { + + public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName) + { + Mixin.CheckModule (module); + Mixin.CheckFileName (fileName); + + if (HasPortablePdbSymbols (module)) + return new PortablePdbWriterProvider ().GetSymbolWriter (module, fileName); + + return new NativePdbWriterProvider ().GetSymbolWriter (module, fileName); + } + + static bool HasPortablePdbSymbols (ModuleDefinition module) + { + return module.symbol_reader != null && module.symbol_reader is PortablePdbReader; + } + + public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream) + { + Mixin.CheckModule (module); + Mixin.CheckStream (symbolStream); + Mixin.CheckReadSeek (symbolStream); + + if (HasPortablePdbSymbols (module)) + return new PortablePdbWriterProvider ().GetSymbolWriter (module, symbolStream); + + return new NativePdbWriterProvider ().GetSymbolWriter (module, symbolStream); + } + } + +#endif +} diff --git a/symbols/pdb.windows/Mono.Cecil.Pdb/ProjectInfo.cs b/symbols/pdb.windows/Mono.Cecil.Pdb/ProjectInfo.cs new file mode 100644 index 000000000..d51e57e25 --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.Pdb/ProjectInfo.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyProduct (Consts.AssemblyName)] +[assembly: AssemblyCopyright ("Copyright © Microsoft")] + +[assembly: ComVisible (false)] + +[assembly: AssemblyVersion ("0.10.0.0")] +[assembly: AssemblyFileVersion ("0.10.0.0")] +[assembly: AssemblyInformationalVersion ("0.10.0.0-beta6")] diff --git a/symbols/pdb.windows/Mono.Cecil.WindowsPdb.csproj b/symbols/pdb.windows/Mono.Cecil.WindowsPdb.csproj new file mode 100644 index 000000000..237272590 --- /dev/null +++ b/symbols/pdb.windows/Mono.Cecil.WindowsPdb.csproj @@ -0,0 +1,34 @@ + + + + + {1A7F5B01-F15F-4943-8AF5-CB736C60B1BE} + Mono.Cecil.WindowsPdb + Mono.Cecil.WindowsPdb + true + + + + {D68133BD-1E63-496E-9EDE-4FBDBF77B486} + Mono.Cecil + + + {63e6915c-7ea4-4d76-ab28-0d7191eea626} + Mono.Cecil.Pdb + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/symbols/pdb.windows/Resources/assemblies/test.exe b/symbols/pdb.windows/Resources/assemblies/test.exe new file mode 100644 index 0000000000000000000000000000000000000000..1f45491b739e7580fe39e0a14636247bab29bcb9 GIT binary patch literal 4096 zcmeHJ-EUMy6hC*nElZ(I2~r>`3|lm{*xRMlK*%m^zraFEn{Fw@tkAo6r`xOdW4Uv; z?ixcHBZ|=&eDKBaz=O|36BCIa(SLx%e?UV*LZUwKq6sk({LS3E-E9PcM;?F68#vDoXui^Xd~>4Jw(qm z`yZyWRp=@*0sG~qF?ztO0qmlj6Md@I2sbQ6jA%jkg>S-A*s@TX)&!QKEYRydw><<( zth9h8b9JIMQI=?=$y90<^-Gf2V$@2P7||V!)nKE^*&d5Fr(%@E2#noC-R*liVr`%H zB3~P|Z9U!I7W>G$8{e4d|D}7w9$MG;JjHsk0PWPbBi7prrEes6Y(!JDhqWvZ>M8xD z)c(Q!5=JZ8;0(!o&J%qIc?Wh+F7Pe4BxJ-pm`fg+o|8HH5IT0BdXAo)7=yeFJ1^}K z+bcjyf=fHPB}VI|@u#+ry2ILK;pkJ}hLixObWEwxNhyJcvW@o8Zq)cH9it6&4n1vj zg;v0SQ2Zu(C56#peOurYnqji{V;WQ$&qvmNppVf-WxcyCLt7#Qqlne8W1A>L z+i4g0PI>`+3+<)fFlN2dbs*^@9kc8Mf11+35MRO2HS{wqSznzrM6ObL$}3iEeux4t z0-aYm&4k}JIl}aO+bU45CIarzbm28_1~g?@E@CVL>ptZh zZ(iv^-o zctBO%C#24l`VW?EiVHi>j(Yxhm8-2+$AWXcXv^;uFUoVovPyfx{tGJ*Q}-pqE4mGE z4}`C26Y%innt6bK={|lrc%>;rsD|hL5{xTZqO?5l5#1Oe`ZerUo^)&oavpE=S@3b1 zg*HLcbOQDS_z~!mzKh?!TfbkGBVvam8Ha32tGr{%H%|un$YbGc;mGOIB6+GG_a)>U zdJT95`V9&Y=fMi;^Y~>X)qp8Llm&n3KAEa2CPnqXAu2#8dJ#9Twi-W%*#*9PnWwyF z9){Qy?vY09JYs!BH?X8|$2S_$5MBXIRTHRK7uapAmq89}LVh_Lu4%}s@(}eZJd?0W zDtZ)^mZ_!?m1qgkL=sC{<(`iGvTB*TzJk(v@Ek*`jv0*gs7Mvm8(?48R@10M)+EoN ztbG`G1tJ}+o()v&q2n-=Zh!NA`f$~;*)sP9?%PaqubxUW?wVc^4^1X{a_&g~fg}@w z;T8?sb9p9N<05(ZP)B<@x+!Z630#p$R($uMFqgPvh6%kCh zi{2yR8BD5im|JkOf)}n9+3@)MTm?9J5wG^56+DEAmB~rns!jyu)0i~BiN?ttqn_ZB{y#C zTb!ak$sSZ3C@6wH$V5yJ#YO1<-Zs%_0fmcGE+7F|z z4r*vP+uGD}sr|*l53-MsY@dDdcjsI3h%Qv02bNp^xgVCV|17iTf2GyujrG@~>tm00 z&uqNrKO2|n!|!Eop-#f=+1L4OHUq5(cZm#c_H#WR{@~xA9Sheo+PVqp8ZKy-<6uVtJ|D6XG=NIR> zx4%X)sfQD$@k~CYn~9X3N@o)0RCdhBn2DH?GeS{Tg@(t+5=V8jkT{|{ZIh;{XU8&W zd{zJ_lrk%b%2Je)9(o$0_(39HNfdXYLEsQA1khUd)T&&u0*|)uBU%x1j!!O}FMW1J zyWMjh+apD&qT+nZNbLnu_Jyu9$Bx;2CyF}CF02g?aCU`cpI=#H2XI%JX{f4YQL$pl zbPn&WQsd`$Ujd!Acxk& zeG^c_pY@H^|8Xh-_$;EHu(6hXRIK5AI)^0q-_oI#N|p|(rHZ47_yN!cP!HC|I$Z3VrVrTEi8qS3hMwh{1eUK>wYMd|f*hB%x*p)#b{8Fqzn%KI;d7Brc_h`VvW { + var type = module.GetType ("Program"); + var main = type.GetMethod ("Main"); + + AssertCode (@" + .locals init (System.Int32 i, System.Int32 CS$1$0000, System.Boolean CS$4$0001) + .line 6,6:2,3 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0000: nop + .line 7,7:8,18 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0001: ldc.i4.0 + IL_0002: stloc.0 + .line hidden 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0003: br.s IL_0012 + .line 8,8:4,21 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0005: ldarg.0 + IL_0006: ldloc.0 + IL_0007: ldelem.ref + IL_0008: call System.Void Program::Print(System.String) + IL_000d: nop + .line 7,7:36,39 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: stloc.0 + .line 7,7:19,34 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0012: ldloc.0 + IL_0013: ldarg.0 + IL_0014: ldlen + IL_0015: conv.i4 + IL_0016: clt + IL_0018: stloc.2 + .line hidden 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0019: ldloc.2 + IL_001a: brtrue.s IL_0005 + .line 10,10:3,12 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_001c: ldc.i4.0 + IL_001d: stloc.1 + IL_001e: br.s IL_0020 + .line 11,11:2,3 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs' + IL_0020: ldloc.1 + IL_0021: ret +", main); + }, readOnly: Platform.OnMono, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider)); + } + } +} +#endif \ No newline at end of file diff --git a/symbols/pdb.windows/Test/Mono.Cecil.WindowsPdb.Tests.csproj b/symbols/pdb.windows/Test/Mono.Cecil.WindowsPdb.Tests.csproj new file mode 100644 index 000000000..46eb8a2d9 --- /dev/null +++ b/symbols/pdb.windows/Test/Mono.Cecil.WindowsPdb.Tests.csproj @@ -0,0 +1,38 @@ + + + + + {77E8A7D2-4DC4-43E1-94FF-002B33FF2397} + Mono.Cecil.WindowsPdb.Tests + Mono.Cecil.WindowsPdb.Tests + + + + {D68133BD-1E63-496E-9EDE-4FBDBF77B486} + Mono.Cecil + + + {A47B1F49-A81A-43E8-BE6B-DD28AF2C4055} + Mono.Cecil.Tests + + + {1a7f5b01-f15f-4943-8af5-cb736c60b1be} + Mono.Cecil.WindowsPdb + + + + + + + + PreserveNewest + false + Microsoft.DiaSymReader.Native.x86.dll + + + PreserveNewest + false + Microsoft.DiaSymReader.Native.amd64.dll + + + \ No newline at end of file diff --git a/symbols/pdb/Mono.Cecil.Pdb/AssemblyInfo.cs b/symbols/pdb/Mono.Cecil.Pdb/AssemblyInfo.cs index c4b4e2e9e..1b62d2341 100644 --- a/symbols/pdb/Mono.Cecil.Pdb/AssemblyInfo.cs +++ b/symbols/pdb/Mono.Cecil.Pdb/AssemblyInfo.cs @@ -10,7 +10,10 @@ using System; using System.Reflection; +using System.Runtime.CompilerServices; [assembly: AssemblyTitle ("Mono.Cecil.Pdb")] [assembly: CLSCompliant (false)] + +[assembly: InternalsVisibleTo ("Mono.Cecil.WindowsPdb, PublicKey=" + Consts.PublicKey)] \ No newline at end of file