mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.2.0.175

Browse Source 
Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2017-06-07 13:16:24 +00:00
parent 4bdbaf4a88
commit 966bba02bb
8776 changed files with 346420 additions and 149650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
external/cecil/symbols/pdb/Microsoft.Cci.Pdb/.editorconfig vendored Normal file
View File

@@ -0,0 +1,3 @@
[*.cs]
indent_style = space
indent_size = 2

16
external/cecil/symbols/pdb/Microsoft.Cci.Pdb/PdbFile.cs vendored
View File

@@ -9,10 +9,10 @@
//
//-----------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Diagnostics.SymbolStore;
using Mono.Cecil.Cil;
namespace Microsoft.Cci.Pdb {
internal class PdbFile {
@@ -254,7 +254,7 @@ namespace Microsoft.Cci.Pdb {
static void LoadFuncsFromDbiModule(BitAccess bits,
DbiModuleInfo info,
IntHashTable names,
ArrayList funcList,
List<PdbFunction> funcList,
bool readStrings,
MsfDirectory dir,
Dictionary<string, int> nameIndex,
@@ -297,7 +297,7 @@ namespace Microsoft.Cci.Pdb {
//}
// Read gpmod section.
ArrayList modList = new ArrayList();
List<DbiModuleInfo> modList = new List<DbiModuleInfo>();
int end = bits.Position + dh.gpmodiSize;
while (bits.Position < end) {
DbiModuleInfo mod = new DbiModuleInfo(bits, readStrings);
@@ -309,7 +309,7 @@ namespace Microsoft.Cci.Pdb {
}
if (modList.Count > 0) {
modules = (DbiModuleInfo[])modList.ToArray(typeof(DbiModuleInfo));
modules = modList.ToArray();
} else {
modules = null;
}
@@ -368,7 +368,7 @@ namespace Microsoft.Cci.Pdb {
dir.streams[3].Read(reader, bits);
LoadDbiStream(bits, out modules, out header, true);
ArrayList funcList = new ArrayList();
List<PdbFunction> funcList = new List<PdbFunction>();
if (modules != null) {
for (int m = 0; m < modules.Length; m++) {
@@ -384,7 +384,7 @@ namespace Microsoft.Cci.Pdb {
}
}
PdbFunction[] funcs = (PdbFunction[])funcList.ToArray(typeof(PdbFunction));
PdbFunction[] funcs = funcList.ToArray();
// After reading the functions, apply the token remapping table if it exists.
if (header.snTokenRidMap != 0 && header.snTokenRidMap != 0xffff) {
@@ -509,7 +509,7 @@ namespace Microsoft.Cci.Pdb {
string name = (string)names[(int)chk.name];
int guidStream;
Guid doctypeGuid = SymDocumentType.Text;
Guid doctypeGuid = DocumentType.Text.ToGuid();
Guid languageGuid = Guid.Empty;
Guid vendorGuid = Guid.Empty;
if (nameIndex.TryGetValue("/SRC/FILES/"+name.ToUpperInvariant(), out guidStream)) {

4
external/cecil/symbols/pdb/Microsoft.Cci.Pdb/PdbFunction.cs vendored
View File

@@ -29,7 +29,7 @@ namespace Microsoft.Cci.Pdb {
internal uint segment;
internal uint address;
//internal uint length;
internal uint length;
//internal byte[] metadata;
internal PdbScope[] scopes;
@@ -208,7 +208,7 @@ namespace Microsoft.Cci.Pdb {
//this.flags = proc.flags;
this.segment = proc.seg;
this.address = proc.off;
//this.length = proc.len;
this.length = proc.len;
if (proc.seg != 1) {
throw new PdbDebugException("Segment is {0}, not 1.", proc.seg);

1
external/cecil/symbols/pdb/Microsoft.Cci.Pdb/SourceLocationProvider.cs vendored
View File

@@ -9,7 +9,6 @@ using System.IO;
using Microsoft.Cci;
using Microsoft.Cci.Pdb;
using System.Text;
using System.Diagnostics.SymbolStore;
namespace Microsoft.Cci {

4
external/cecil/symbols/pdb/Mono.Cecil.Pdb.csproj vendored
View File

@@ -18,5 +18,5 @@
<Compile Include="Mono.Cecil.Pdb\*.cs" />
</ItemGroup>
<Import Project="..\..\Mono.Cecil.props" />
<Import Project="$(MSBuildCSharpTargets)" />
</Project>
<Import Project="$(MSBuildCSharpTargets)" Condition=" ! $(NetStandard) " />
</Project>

16
external/cecil/symbols/pdb/Mono.Cecil.Pdb/ISymUnmanagedWriter2.cs vendored
View File

@@ -8,7 +8,6 @@
//
using System;
using System.Diagnostics.SymbolStore;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
@@ -29,8 +28,8 @@ namespace Mono.Cecil.Pdb {
[In] ref Guid languageVendor,
[In] ref Guid documentType,
[Out, MarshalAs (UnmanagedType.Interface)] out ISymUnmanagedDocumentWriter pRetVal);
void SetUserEntryPoint ([In] SymbolToken method);
void OpenMethod ([In] SymbolToken method);
void SetUserEntryPoint ([In] int methodToken);
void OpenMethod ([In] int methodToken);
void CloseMethod ();
void OpenScope ([In] int startOffset, [Out] out int pRetVal);
void CloseScope ([In] int endOffset);
@@ -40,7 +39,7 @@ namespace Mono.Cecil.Pdb {
void DefineField_Placeholder ();
void DefineGlobalVariable_Placeholder ();
void Close ();
void SetSymAttribute_Placeholder ();
void SetSymAttribute (uint parent, string name, uint data, IntPtr signature);
void OpenNamespace ([In, MarshalAs (UnmanagedType.LPWStr)] string name);
void CloseNamespace ();
void UsingNamespace ([In, MarshalAs (UnmanagedType.LPWStr)] string fullName);
@@ -71,13 +70,20 @@ namespace Mono.Cecil.Pdb {
void DefineLocalVariable2 (
[In, MarshalAs (UnmanagedType.LPWStr)] string name,
[In] int attributes,
[In] SymbolToken sigToken,
[In] int sigToken,
[In] int addrKind,
[In] int addr1,
[In] int addr2,
[In] int addr3,
[In] int startOffset,
[In] int endOffset);
void DefineGlobalVariable2_Placeholder ();
void DefineConstant2 (
[In, MarshalAs (UnmanagedType.LPWStr)] string name,
[In, MarshalAs (UnmanagedType.Struct)] object variant,
[In] int sigToken);
}
}

149
external/cecil/symbols/pdb/Mono.Cecil.Pdb/NativePdbReader.cs vendored
View File

@@ -28,12 +28,19 @@ namespace Mono.Cecil.Pdb {
readonly Disposable<Stream> pdb_file;
readonly Dictionary<string, Document> documents = new Dictionary<string, Document> ();
readonly Dictionary<uint, PdbFunction> functions = new Dictionary<uint, PdbFunction> ();
readonly Dictionary<PdbScope, ImportDebugInformation> imports = new Dictionary<PdbScope, ImportDebugInformation> ();
internal NativePdbReader (Disposable<Stream> file)
{
this.pdb_file = file;
}
#if !READ_ONLY
public ISymbolWriterProvider GetWriterProvider ()
{
return new NativePdbWriterProvider ();
}
#endif
/*
uint Magic = 0x53445352;
Guid Signature;
@@ -41,25 +48,36 @@ namespace Mono.Cecil.Pdb {
string FileName;
*/
public bool ProcessDebugHeader (ImageDebugDirectory directory, byte [] header)
public bool ProcessDebugHeader (ImageDebugHeader header)
{
if (directory.Type != 2) //IMAGE_DEBUG_TYPE_CODEVIEW
if (!header.HasEntries)
return false;
var entry = header.GetCodeViewEntry ();
if (entry == null)
return false;
var directory = entry.Directory;
if (directory.Type != ImageDebugType.CodeView)
return false;
if (directory.MajorVersion != 0 || directory.MinorVersion != 0)
return false;
if (header.Length < 24)
var data = entry.Data;
if (data.Length < 24)
return false;
var magic = ReadInt32 (header, 0);
var magic = ReadInt32 (data, 0);
if (magic != 0x53445352)
return false;
var guid_bytes = new byte [16];
Buffer.BlockCopy (header, 4, guid_bytes, 0, 16);
Buffer.BlockCopy (data, 4, guid_bytes, 0, 16);
this.guid = new Guid (guid_bytes);
this.age = ReadInt32 (header, 20);
this.age = ReadInt32 (data, 20);
return PopulateFunctions ();
}
@@ -104,8 +122,12 @@ namespace Mono.Cecil.Pdb {
ReadSequencePoints (function, symbol);
if (!function.scopes.IsNullOrEmpty())
symbol.scope = ReadScopeAndLocals (function.scopes [0], symbol);
symbol.scope = !function.scopes.IsNullOrEmpty ()
? ReadScopeAndLocals (function.scopes [0], symbol)
: new ScopeDebugInformation { Start = new InstructionOffset (0), End = new InstructionOffset ((int) function.length) };
if (function.tokenOfMethodWhoseUsingInfoAppliesToThisMethod != method.MetadataToken.ToUInt32 () && function.tokenOfMethodWhoseUsingInfoAppliesToThisMethod != 0)
symbol.scope.import = GetImport (function.tokenOfMethodWhoseUsingInfoAppliesToThisMethod, method.Module);
if (function.scopes.Length > 1) {
for (int i = 1; i < function.scopes.Length; i++) {
@@ -115,10 +137,28 @@ namespace Mono.Cecil.Pdb {
}
}
if (function.iteratorScopes != null)
foreach (var iterator_scope in function.iteratorScopes)
symbol.CustomDebugInformations.Add (new StateMachineScopeDebugInformation ((int) iterator_scope.Offset, (int) (iterator_scope.Offset + iterator_scope.Length + 1)));
if (function.synchronizationInformation != null) {
var async_debug_info = new AsyncMethodBodyDebugInformation ((int) function.synchronizationInformation.GeneratedCatchHandlerOffset);
foreach (var synchronization_point in function.synchronizationInformation.synchronizationPoints) {
async_debug_info.Yields.Add (new InstructionOffset ((int) synchronization_point.SynchronizeOffset));
async_debug_info.Resumes.Add (new InstructionOffset ((int) synchronization_point.ContinuationOffset));
}
symbol.CustomDebugInformations.Add (async_debug_info);
async_debug_info.MoveNextMethod = method;
symbol.StateMachineKickOffMethod = (MethodDefinition) method.Module.LookupToken ((int) function.synchronizationInformation.kickoffMethodToken);
}
return symbol;
}
static Collection<ScopeDebugInformation> ReadScopeAndLocals (PdbScope [] scopes, MethodDebugInformation info)
Collection<ScopeDebugInformation> ReadScopeAndLocals (PdbScope [] scopes, MethodDebugInformation info)
{
var symbols = new Collection<ScopeDebugInformation> (scopes.Length);
@@ -129,13 +169,13 @@ namespace Mono.Cecil.Pdb {
return symbols;
}
static ScopeDebugInformation ReadScopeAndLocals (PdbScope scope, MethodDebugInformation info)
ScopeDebugInformation ReadScopeAndLocals (PdbScope scope, MethodDebugInformation info)
{
var parent = new ScopeDebugInformation ();
parent.Start = new InstructionOffset ((int) scope.offset);
parent.End = new InstructionOffset ((int) (scope.offset + scope.length));
if (!scope.slots.IsNullOrEmpty()) {
if (!scope.slots.IsNullOrEmpty ()) {
parent.variables = new Collection<VariableDebugInformation> (scope.slots.Length);
foreach (PdbSlot slot in scope.slots) {
@@ -154,10 +194,25 @@ namespace Mono.Cecil.Pdb {
parent.constants = new Collection<ConstantDebugInformation> (scope.constants.Length);
foreach (var constant in scope.constants) {
parent.constants.Add (new ConstantDebugInformation (
constant.name,
(TypeReference) info.method.Module.LookupToken ((int) constant.token),
constant.value));
var type = info.Method.Module.Read (constant, (c, r) => r.ReadConstantSignature (new MetadataToken (c.token)));
var value = constant.value;
// Object "null" is encoded as integer
if (type != null && !type.IsValueType && value is int && (int) value == 0)
value = null;
parent.constants.Add (new ConstantDebugInformation (constant.name, type, value));
}
}
if (!scope.usedNamespaces.IsNullOrEmpty ()) {
ImportDebugInformation import;
if (imports.TryGetValue (scope, out import)) {
parent.import = import;
} else {
import = GetImport (scope, info.Method.Module);
imports.Add (scope, import);
parent.import = import;
}
}
@@ -181,6 +236,70 @@ namespace Mono.Cecil.Pdb {
return false;
}
ImportDebugInformation GetImport (uint token, ModuleDefinition module)
{
PdbFunction function;
if (!functions.TryGetValue (token, out function))
return null;
if (function.scopes.Length != 1)
return null;
var scope = function.scopes [0];
ImportDebugInformation import;
if (imports.TryGetValue (scope, out import))
return import;
import = GetImport (scope, module);
imports.Add (scope, import);
return import;
}
static ImportDebugInformation GetImport (PdbScope scope, ModuleDefinition module)
{
if (scope.usedNamespaces.IsNullOrEmpty ())
return null;
var import = new ImportDebugInformation ();
foreach (var used_namespace in scope.usedNamespaces) {
ImportTarget target = null;
var value = used_namespace.Substring (1);
switch (used_namespace [0]) {
case 'U':
target = new ImportTarget (ImportTargetKind.ImportNamespace) { @namespace = value };
break;
case 'T': {
var type = module.GetType (value, runtimeName: true);
if (type != null)
target = new ImportTarget (ImportTargetKind.ImportType) { type = type };
break;
}
case 'A':
var index = used_namespace.IndexOf(' ');
var alias_value = used_namespace.Substring (1, index - 1);
var alias_target_value = used_namespace.Substring (index + 2);
switch (used_namespace [index + 1]) {
case 'U':
target = new ImportTarget (ImportTargetKind.DefineNamespaceAlias) { alias = alias_value, @namespace = alias_target_value };
break;
case 'T':
var type = module.GetType (alias_target_value, runtimeName: true);
if (type != null)
target = new ImportTarget (ImportTargetKind.DefineTypeAlias) { alias = alias_value, type = type };
break;
}
break;
}
if (target != null)
import.Targets.Add (target);
}
return import;
}
void ReadSequencePoints (PdbFunction function, MethodDebugInformation info)
{
if (function.lines == null)

258
external/cecil/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs vendored
View File

@@ -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

7
external/cecil/symbols/pdb/Mono.Cecil.Pdb/PdbHelper.cs vendored
View File

@@ -41,6 +41,13 @@ namespace Mono.Cecil.Pdb {
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);

37
external/cecil/symbols/pdb/Mono.Cecil.Pdb/SymWriter.cs vendored
View File

@@ -8,8 +8,6 @@
//
using System;
using System.Collections.Generic;
using System.Diagnostics.SymbolStore;
using System.Runtime.InteropServices;
using Mono.Cecil.Cil;
@@ -60,15 +58,24 @@ namespace Mono.Cecil.Pdb
public void DefineLocalVariable2 (
string name,
VariableAttributes attributes,
SymbolToken sigToken,
SymAddressKind addrKind,
int sigToken,
int addr1,
int addr2,
int addr3,
int startOffset,
int endOffset)
{
m_writer.DefineLocalVariable2 (name, (int)attributes, sigToken, (int)addrKind, addr1, addr2, addr3, startOffset, endOffset);
m_writer.DefineLocalVariable2 (name, (int)attributes, sigToken, 1 /* ILOffset*/, addr1, addr2, addr3, startOffset, endOffset);
}
public void DefineConstant2 (string name, object value, int sigToken)
{
if (value == null) {
m_writer.DefineConstant2 (name, 0, sigToken);
return;
}
m_writer.DefineConstant2 (name, value, sigToken);
}
public void Close ()
@@ -104,11 +111,6 @@ namespace Mono.Cecil.Pdb
return new SymDocumentWriter (unmanagedDocumentWriter);
}
public void DefineParameter (string name, ParameterAttributes attributes, int sequence, SymAddressKind addrKind, int addr1, int addr2, int addr3)
{
throw new Exception ("The method or operation is not implemented.");
}
public void DefineSequencePoints (SymDocumentWriter document, int[] offsets, int[] lines, int[] columns, int[] endLines, int[] endColumns)
{
m_writer.DefineSequencePoints (document.GetUnmanaged(), offsets.Length, offsets, lines, columns, endLines, endColumns);
@@ -119,14 +121,14 @@ namespace Mono.Cecil.Pdb
m_writer.Initialize (emitter, filename, null, fFullBuild);
}
public void SetUserEntryPoint (SymbolToken method)
public void SetUserEntryPoint (int methodToken)
{
m_writer.SetUserEntryPoint (method);
m_writer.SetUserEntryPoint (methodToken);
}
public void OpenMethod (SymbolToken method)
public void OpenMethod (int methodToken)
{
m_writer.OpenMethod (method);
m_writer.OpenMethod (methodToken);
}
public void OpenNamespace (string name)
@@ -145,6 +147,13 @@ namespace Mono.Cecil.Pdb
{
m_writer.UsingNamespace (fullName);
}
public void DefineCustomMetadata (string name, byte [] metadata)
{
var handle = GCHandle.Alloc (metadata, GCHandleType.Pinned);
m_writer.SetSymAttribute (0, name, (uint) metadata.Length, handle.AddrOfPinnedObject ());
handle.Free ();
}
}
}

249
external/cecil/symbols/pdb/Test/Mono.Cecil.Tests/PdbTests.cs vendored
View File

@@ -1,4 +1,4 @@
#if !READ_ONLY
using System.IO;
using System.Linq;
@@ -26,7 +26,7 @@ namespace Mono.Cecil.Tests {
.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 16707566,16707566:0,0 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
.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
@@ -46,7 +46,7 @@ namespace Mono.Cecil.Tests {
IL_0015: conv.i4
IL_0016: clt
IL_0018: stloc.2
.line 16707566,16707566:0,0 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
.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'
@@ -86,7 +86,6 @@ namespace Mono.Cecil.Tests {
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider));
}
[Test]
public void Document ()
{
@@ -154,6 +153,247 @@ namespace Mono.Cecil.Tests {
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void LocalVariables ()
{
TestModule ("ComplexPdb.dll", module => {
var type = module.GetType ("ComplexPdb.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasScopes);
Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
var scope = debug_info.Scope.Scopes [0];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
var variable = scope.Variables [0];
Assert.AreEqual ("s", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (2, variable.Index);
scope = debug_info.Scope.Scopes [1];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
variable = scope.Variables [0];
Assert.AreEqual ("s", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (3, variable.Index);
Assert.IsTrue (scope.HasScopes);
Assert.AreEqual (1, scope.Scopes.Count);
scope = scope.Scopes [0];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
variable = scope.Variables [0];
Assert.AreEqual ("u", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (5, variable.Index);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void LocalConstants ()
{
TestModule ("ComplexPdb.dll", module => {
var type = module.GetType ("ComplexPdb.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasScopes);
Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
var scope = debug_info.Scope.Scopes [1];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasConstants);
Assert.AreEqual (2, scope.Constants.Count);
var constant = scope.Constants [0];
Assert.AreEqual ("b", constant.Name);
Assert.AreEqual (12, constant.Value);
Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
constant = scope.Constants [1];
Assert.AreEqual ("c", constant.Name);
Assert.AreEqual ((decimal) 74, constant.Value);
Assert.AreEqual (MetadataType.ValueType, constant.ConstantType.MetadataType);
method = type.GetMethod ("Foo");
debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasConstants);
Assert.AreEqual (4, debug_info.Scope.Constants.Count);
constant = debug_info.Scope.Constants [0];
Assert.AreEqual ("s", constant.Name);
Assert.AreEqual ("const string", constant.Value);
Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [1];
Assert.AreEqual ("f", constant.Name);
Assert.AreEqual (1, constant.Value);
Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [2];
Assert.AreEqual ("o", constant.Name);
Assert.AreEqual (null, constant.Value);
Assert.AreEqual (MetadataType.Object, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [3];
Assert.AreEqual ("u", constant.Name);
Assert.AreEqual (null, constant.Value);
Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void ImportScope ()
{
TestModule ("ComplexPdb.dll", module => {
var type = module.GetType ("ComplexPdb.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
var import = debug_info.Scope.Import;
Assert.IsNotNull (import);
Assert.IsTrue (import.HasTargets);
Assert.AreEqual (6, import.Targets.Count);
var target = import.Targets [0];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System", target.Namespace);
target = import.Targets [1];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System.Collections.Generic", target.Namespace);
target = import.Targets [2];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System.Threading.Tasks", target.Namespace);
target = import.Targets [3];
Assert.AreEqual (ImportTargetKind.ImportType, target.Kind);
Assert.AreEqual ("System.Console", target.Type.FullName);
target = import.Targets [4];
Assert.AreEqual (ImportTargetKind.DefineTypeAlias, target.Kind);
Assert.AreEqual ("Foo1", target.Alias);
Assert.AreEqual ("System.Console", target.Type.FullName);
target = import.Targets [5];
Assert.AreEqual (ImportTargetKind.DefineNamespaceAlias, target.Kind);
Assert.AreEqual ("Foo2", target.Alias);
Assert.AreEqual ("System.Reflection", target.Namespace);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void StateMachineKickOff ()
{
TestModule ("ComplexPdb.dll", module => {
var state_machine = module.GetType ("ComplexPdb.Program/<TestAsync>d__2");
var move_next = state_machine.GetMethod ("MoveNext");
var symbol = move_next.DebugInformation;
Assert.IsNotNull (symbol);
Assert.IsNotNull (symbol.StateMachineKickOffMethod);
Assert.AreEqual ("System.Threading.Tasks.Task ComplexPdb.Program::TestAsync()", symbol.StateMachineKickOffMethod.FullName);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void Iterators ()
{
TestModule ("ComplexPdb.dll", module => {
var state_machine = module.GetType ("ComplexPdb.Program/<TestAsync>d__2");
var move_next = state_machine.GetMethod ("MoveNext");
Assert.IsTrue (move_next.DebugInformation.HasCustomDebugInformations);
Assert.AreEqual (2, move_next.DebugInformation.CustomDebugInformations.Count);
var state_machine_scope = move_next.DebugInformation.CustomDebugInformations [0] as StateMachineScopeDebugInformation;
Assert.IsNotNull (state_machine_scope);
Assert.AreEqual (142, state_machine_scope.Start.Offset);
Assert.AreEqual (319, state_machine_scope.End.Offset);
var async_body = move_next.DebugInformation.CustomDebugInformations [1] as AsyncMethodBodyDebugInformation;
Assert.IsNotNull (async_body);
Assert.AreEqual (-1, async_body.CatchHandler.Offset);
Assert.AreEqual (2, async_body.Yields.Count);
Assert.AreEqual (68, async_body.Yields [0].Offset);
Assert.AreEqual (197, async_body.Yields [1].Offset);
Assert.AreEqual (2, async_body.Resumes.Count);
Assert.AreEqual (98, async_body.Resumes [0].Offset);
Assert.AreEqual (227, async_body.Resumes [1].Offset);
Assert.AreEqual (move_next, async_body.MoveNextMethod);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void ImportsForFirstMethod ()
{
TestModule ("CecilTest.exe", module => {
var type = module.GetType ("CecilTest.Program");
var method = type.GetMethod ("Main");
var debug = method.DebugInformation;
var scope = debug.Scope;
Assert.IsTrue (scope.End.IsEndOfMethod);
var import = scope.Import;
Assert.IsNotNull (import);
Assert.AreEqual (5, import.Targets.Count);
var ns = new [] {
"System",
"System.Collections.Generic",
"System.Linq",
"System.Text",
"System.Threading.Tasks",
};
for (int i = 0; i < import.Targets.Count; i++) {
var target = import.Targets [i];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual (ns [i], target.Namespace);
}
Assert.AreEqual ("System", import.Targets [0].Namespace);
}, readOnly: Platform.OnMono, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
}
[Test]
public void CreateMethodFromScratch ()
{
@@ -208,3 +448,4 @@ namespace Mono.Cecil.Tests {
}
}
}
#endif

BIN
external/cecil/symbols/pdb/Test/Resources/assemblies/CecilTest.pdb vendored Normal file
View File

Binary file not shown.

71
external/cecil/symbols/pdb/Test/Resources/assemblies/ComplexPdb.cs vendored Normal file
View File

@@ -0,0 +1,71 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using static System.Console;
using Foo1 = System.Console;
using Foo2 = System.Reflection;
namespace ComplexPdb
{
public class Program
{
private static void Foo()
{
const string s = "const string";
const int f = 1;
const object o = null;
const string u = null;
WriteLine(s);
WriteLine(2);
}
private static void Bar(int i)
{
int result;
if (i < 0)
{
int s = 1;
result = s;
}
else
{
const int b = 12;
const decimal c = 74;
int s = -1;
result = s + b + (int)c;
if (result > b)
{
int u = result * b;
Console.WriteLine(u);
}
}
WriteLine(result);
}
public async Task TestAsync()
{
WriteLine("Hello1");
await Task.Delay(100);
for (int i = 0; i < 4; ++i)
{
WriteLine("Hello2");
await Task.Delay(100);
WriteLine("Hello3");
}
}
public IEnumerable<string> TestIterator()
{
WriteLine("Hello1");
yield return "Hello1";
for (int i = 0; i < 4; ++i)
{
WriteLine("Hello1");
yield return "Hello2";
WriteLine("Hello3");
}
}
}
}

BIN
external/cecil/symbols/pdb/Test/Resources/assemblies/ComplexPdb.pdb vendored Normal file
View File

Binary file not shown.