Debian Codegraph @

external/cecil/symbols/mdb/Mono.Cecil.Mdb/MdbReader.cs

raw
1 //
2 // Author:
3 // Jb Evain ([email protected])
4 //
5 // Copyright (c) 2008 - 2015 Jb Evain
6 // Copyright (c) 2008 - 2011 Novell, Inc.
7 //
8 // Licensed under the MIT/X11 license.
9 //
10
11 using System;
12 using System.Collections.Generic;
13 using System.IO;
14
15 using Mono.Cecil.Cil;
16 using Mono.Collections.Generic;
17 using Mono.CompilerServices.SymbolWriter;
18
19 namespace Mono.Cecil.Mdb {
20
21 public sealed class MdbReaderProvider : ISymbolReaderProvider {
22
23 public ISymbolReader GetSymbolReader (ModuleDefinition module, string fileName)
24 {
25 Mixin.CheckModule (module);
26 Mixin.CheckFileName (fileName);
27
28 return new MdbReader (module, MonoSymbolFile.ReadSymbolFile (Mixin.GetMdbFileName (fileName)));
29 }
30
31 public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStream)
32 {
33 Mixin.CheckModule (module);
34 Mixin.CheckStream (symbolStream);
35
36 return new MdbReader (module, MonoSymbolFile.ReadSymbolFile (symbolStream));
37 }
38 }
39
40 public sealed class MdbReader : ISymbolReader {
41
42 readonly ModuleDefinition module;
43 readonly MonoSymbolFile symbol_file;
44 readonly Dictionary<string, Document> documents;
45
46 public MdbReader (ModuleDefinition module, MonoSymbolFile symFile)
47 {
48 this.module = module;
49 this.symbol_file = symFile;
50 this.documents = new Dictionary<string, Document> ();
51 }
52
53 public ISymbolWriterProvider GetWriterProvider ()
54 {
55 return new MdbWriterProvider ();
56 }
57
58 public bool ProcessDebugHeader (ImageDebugHeader header)
59 {
60 return symbol_file.Guid == module.Mvid;
61 }
62
63 public MethodDebugInformation Read (MethodDefinition method)
64 {
65 var method_token = method.MetadataToken;
66 var entry = symbol_file.GetMethodByToken (method_token.ToInt32 ());
67 if (entry == null)
68 return null;
69
70 var info = new MethodDebugInformation (method);
71 info.code_size = ReadCodeSize (method);
72
73 var scopes = ReadScopes (entry, info);
74 ReadLineNumbers (entry, info);
75 ReadLocalVariables (entry, scopes);
76
77 return info;
78 }
79
80 static int ReadCodeSize (MethodDefinition method)
81 {
82 return method.Module.Read (method, (m, reader) => reader.ReadCodeSize (m));
83 }
84
85 static void ReadLocalVariables (MethodEntry entry, ScopeDebugInformation [] scopes)
86 {
87 var locals = entry.GetLocals ();
88
89 foreach (var local in locals) {
90 var variable = new VariableDebugInformation (local.Index, local.Name);
91
92 var index = local.BlockIndex;
93 if (index < 0 || index >= scopes.Length)
94 continue;
95
96 var scope = scopes [index];
97 if (scope == null)
98 continue;
99
100 scope.Variables.Add (variable);
101 }
102 }
103
104 void ReadLineNumbers (MethodEntry entry, MethodDebugInformation info)
105 {
106 var table = entry.GetLineNumberTable ();
107
108 info.sequence_points = new Collection<SequencePoint> (table.LineNumbers.Length);
109
110 for (var i = 0; i < table.LineNumbers.Length; i++) {
111 var line = table.LineNumbers [i];
112 if (i > 0 && table.LineNumbers [i - 1].Offset == line.Offset)
113 continue;
114
115 info.sequence_points.Add (LineToSequencePoint (line));
116 }
117 }
118
119 Document GetDocument (SourceFileEntry file)
120 {
121 var file_name = file.FileName;
122
123 Document document;
124 if (documents.TryGetValue (file_name, out document))
125 return document;
126
127 document = new Document (file_name) {
128 Hash = file.Checksum,
129 };
130
131 documents.Add (file_name, document);
132
133 return document;
134 }
135
136 static ScopeDebugInformation [] ReadScopes (MethodEntry entry, MethodDebugInformation info)
137 {
138 var blocks = entry.GetCodeBlocks ();
139 var scopes = new ScopeDebugInformation [blocks.Length + 1];
140
141 info.scope = scopes [0] = new ScopeDebugInformation {
142 Start = new InstructionOffset (0),
143 End = new InstructionOffset (info.code_size),
144 };
145
146 foreach (var block in blocks) {
147 if (block.BlockType != CodeBlockEntry.Type.Lexical && block.BlockType != CodeBlockEntry.Type.CompilerGenerated)
148 continue;
149
150 var scope = new ScopeDebugInformation ();
151 scope.Start = new InstructionOffset (block.StartOffset);
152 scope.End = new InstructionOffset (block.EndOffset);
153
154 scopes [block.Index + 1] = scope;
155
156 if (!AddScope (info.scope.Scopes, scope))
157 info.scope.Scopes.Add (scope);
158 }
159
160 return scopes;
161 }
162
163 static bool AddScope (Collection<ScopeDebugInformation> scopes, ScopeDebugInformation scope)
164 {
165 foreach (var sub_scope in scopes) {
166 if (sub_scope.HasScopes && AddScope (sub_scope.Scopes, scope))
167 return true;
168
169 if (scope.Start.Offset >= sub_scope.Start.Offset && scope.End.Offset <= sub_scope.End.Offset) {
170 sub_scope.Scopes.Add (scope);
171 return true;
172 }
173 }
174
175 return false;
176 }
177
178 SequencePoint LineToSequencePoint (LineNumberEntry line)
179 {
180 var source = symbol_file.GetSourceFile (line.File);
181 return new SequencePoint (line.Offset, GetDocument (source)) {
182 StartLine = line.Row,
183 EndLine = line.EndRow,
184 StartColumn = line.Column,
185 EndColumn = line.EndColumn,
186 };
187 }
188
189 public void Dispose ()
190 {
191 symbol_file.Dispose ();
192 }
193 }
194
195 static class MethodEntryExtensions {
196
197 public static bool HasColumnInfo (this MethodEntry entry)
198 {
199 return (entry.MethodFlags & MethodEntry.Flags.ColumnsInfoIncluded) != 0;
200 }
201
202 public static bool HasEndInfo (this MethodEntry entry)
203 {
204 return (entry.MethodFlags & MethodEntry.Flags.EndInfoIncluded) != 0;
205 }
206 }
207 }