Debian Codegraph @

mcs/tools/mono-symbolicate/LocationProvider.cs

raw
1 using System;
2 using System.IO;
3 using System.Linq;
4 using System.Text;
5 using System.Collections.Generic;
6 using Mono.Cecil;
7 using Mono.Cecil.Cil;
8 using Mono.Collections.Generic;
9
10 namespace Mono
11 {
12 class AssemblyLocationProvider
13 {
14 string assemblyFullPath;
15 Logger logger;
16
17 public AssemblyLocationProvider (string assemblyPath, Logger logger)
18 {
19 assemblyPath = Path.GetFullPath (assemblyPath);
20 this.logger = logger;
21
22 if (!File.Exists (assemblyPath))
23 throw new ArgumentException ("assemblyPath does not exist: "+ assemblyPath);
24
25 assemblyFullPath = assemblyPath;
26 }
27
28 public bool TryResolveLocation (StackFrameData sfData, SeqPointInfo seqPointInfo, out Location location)
29 {
30 var readerParameters = new ReaderParameters { ReadSymbols = true };
31 using (var assembly = AssemblyDefinition.ReadAssembly (assemblyFullPath, readerParameters)) {
32
33 if (!assembly.MainModule.HasSymbols) {
34 location = default;
35 return false;
36 }
37
38 TypeDefinition type = null;
39 string[] nested;
40 if (sfData.TypeFullName.IndexOf ('/') >= 0)
41 nested = sfData.TypeFullName.Split ('/');
42 else
43 nested = sfData.TypeFullName.Split ('+');
44
45 var types = assembly.MainModule.Types;
46 foreach (var ntype in nested) {
47 if (type == null) {
48 // Use namespace first time.
49 type = types.FirstOrDefault (t => t.FullName == ntype);
50 } else {
51 type = types.FirstOrDefault (t => t.Name == ntype);
52 }
53
54 if (type == null) {
55 logger.LogWarning ("Could not find type: {0}", ntype);
56 location = default;
57 return false;
58 }
59
60 types = type.NestedTypes;
61 }
62
63 var parensStart = sfData.MethodSignature.IndexOf ('(');
64 var methodName = sfData.MethodSignature.Substring (0, parensStart).TrimEnd ();
65 var methodParameters = sfData.MethodSignature.Substring (parensStart);
66 var methods = type.Methods.Where (m => CompareName (m, methodName) && CompareParameters (m.Parameters, methodParameters)).ToArray ();
67 if (methods.Length == 0) {
68 logger.LogWarning ("Could not find method: {0}", methodName);
69 location = default;
70 return false;
71 }
72 if (methods.Length > 1) {
73 logger.LogWarning ("Ambiguous match for method: {0}", sfData.MethodSignature);
74 location = default;
75 return false;
76 }
77 var method = methods [0];
78
79 int ilOffset;
80 if (sfData.IsILOffset) {
81 ilOffset = sfData.Offset;
82 } else {
83 if (seqPointInfo == null) {
84 location = default;
85 return false;
86 }
87
88 ilOffset = seqPointInfo.GetILOffset (method.MetadataToken.ToInt32 (), sfData.MethodIndex, sfData.Offset);
89 }
90
91 if (ilOffset < 0) {
92 location = default;
93 return false;
94 }
95
96 if (!method.DebugInformation.HasSequencePoints) {
97 var async_method = GetAsyncStateMachine (method);
98 if (async_method?.ConstructorArguments?.Count == 1) {
99 string state_machine = ((TypeReference)async_method.ConstructorArguments [0].Value).FullName;
100 return TryResolveLocation (sfData.Relocate (state_machine, "MoveNext ()"), seqPointInfo, out location);
101 }
102
103 location = default;
104 return false;
105 }
106
107 SequencePoint prev = null;
108 foreach (var sp in method.DebugInformation.SequencePoints.OrderBy (l => l.Offset)) {
109 if (sp.Offset >= ilOffset) {
110 location = new Location (sp.Document.Url, sp.StartLine);
111 return true;
112 }
113
114 prev = sp;
115 }
116
117 if (prev != null) {
118 location = new Location (prev.Document.Url, prev.StartLine);
119 return true;
120 }
121
122 location = default;
123 return false;
124 }
125 }
126
127 static CustomAttribute GetAsyncStateMachine (MethodDefinition method)
128 {
129 if (!method.HasCustomAttributes)
130 return null;
131
132 return method.CustomAttributes.FirstOrDefault (l =>
133 l.AttributeType.Name == "AsyncStateMachineAttribute" && l.AttributeType.Namespace == "System.Runtime.CompilerServices");
134 }
135
136 static bool CompareName (MethodDefinition candidate, string expected)
137 {
138 if (candidate.Name == expected)
139 return true;
140
141 if (!candidate.HasGenericParameters)
142 return false;
143
144 var genStart = expected.IndexOf ('[');
145 if (genStart < 0)
146 genStart = expected.IndexOf ('<');
147
148 if (genStart < 0)
149 return false;
150
151 if (candidate.Name != expected.Substring (0, genStart))
152 return false;
153
154 int arity = 1;
155 for (int pos = genStart; pos < expected.Length; ++pos) {
156 if (expected [pos] == ',')
157 ++arity;
158 }
159
160 return candidate.GenericParameters.Count == arity;
161 }
162
163 static string RemoveGenerics (string expected, char open, char close)
164 {
165 if (expected.IndexOf (open) < 0)
166 return expected;
167
168 var sb = new StringBuilder ();
169 for (int i = 0; i < expected.Length;) {
170 int start = expected.IndexOf (open, i);
171 int end = expected.IndexOf (close, i);
172 if (start < 0 || end < 0) {
173 sb.Append (expected, i, expected.Length - i);
174 break;
175 }
176
177 bool is_ginst = false;
178 for (int j = start + 1; j < end; ++j) {
179 if (expected [j] != ',')
180 is_ginst = true;
181 }
182
183 if (is_ginst) //discard the the generic args
184 sb.Append (expected, i, start - i);
185 else //include array arity
186 sb.Append (expected, i, end + 1 - i);
187 i = end + 1;
188
189 }
190 return sb.ToString ();
191 }
192
193 static bool CompareParameters (Collection<ParameterDefinition> candidate, string expected)
194 {
195 var builder = new StringBuilder ();
196 builder.Append ("(");
197
198 for (int i = 0; i < candidate.Count; i++) {
199 var parameter = candidate [i];
200 if (i > 0)
201 builder.Append (", ");
202
203 if (parameter.ParameterType.IsSentinel)
204 builder.Append ("...,");
205
206 var pt = parameter.ParameterType;
207 FormatElementType (pt, builder);
208
209 builder.Append (" ");
210 builder.Append (parameter.Name);
211 }
212
213 builder.Append (")");
214
215 if (builder.ToString () == RemoveGenerics (expected, '[', ']'))
216 return true;
217
218 //now try the compact runtime format.
219
220 builder.Clear ();
221
222 builder.Append ("(");
223
224 for (int i = 0; i < candidate.Count; i++) {
225 var parameter = candidate [i];
226 if (i > 0)
227 builder.Append (",");
228
229 if (parameter.ParameterType.IsSentinel)
230 builder.Append ("...,");
231
232 var pt = parameter.ParameterType;
233
234 RuntimeFormatElementType (pt, builder);
235 }
236
237 builder.Append (")");
238
239 if (builder.ToString () == RemoveGenerics (expected, '<', '>'))
240 return true;
241 return false;
242
243 }
244
245 static void RuntimeFormatElementType (TypeReference tr, StringBuilder builder)
246 {
247 var ts = tr as TypeSpecification;
248 if (ts != null) {
249 if (ts.IsByReference) {
250 RuntimeFormatElementType (ts.ElementType, builder);
251 builder.Append ("&");
252 return;
253 }
254 }
255
256 switch (tr.MetadataType) {
257 case MetadataType.Void:
258 builder.Append ("void");
259 break;
260 case MetadataType.Boolean:
261 builder.Append ("bool");
262 break;
263 case MetadataType.Char:
264 builder.Append ("char");
265 break;
266 case MetadataType.SByte:
267 builder.Append ("sbyte");
268 break;
269 case MetadataType.Byte:
270 builder.Append ("byte");
271 break;
272 case MetadataType.Int16:
273 builder.Append ("int16");
274 break;
275 case MetadataType.UInt16:
276 builder.Append ("uint16");
277 break;
278 case MetadataType.Int32:
279 builder.Append ("int");
280 break;
281 case MetadataType.UInt32:
282 builder.Append ("uint");
283 break;
284 case MetadataType.Int64:
285 builder.Append ("long");
286 break;
287 case MetadataType.UInt64:
288 builder.Append ("ulong");
289 break;
290 case MetadataType.Single:
291 builder.Append ("single");
292 break;
293 case MetadataType.Double:
294 builder.Append ("double");
295 break;
296 case MetadataType.String:
297 builder.Append ("string");
298 break;
299 case MetadataType.Pointer:
300 builder.Append (((TypeSpecification)tr).ElementType);
301 builder.Append ("*");
302 break;
303 case MetadataType.ValueType:
304 case MetadataType.Class:
305 case MetadataType.GenericInstance: {
306 FormatName (tr, builder, '/');
307 break;
308 }
309 case MetadataType.Var:
310 case MetadataType.MVar:
311 builder.Append (tr.Name);
312 builder.Append ("_REF");
313 break;
314 case MetadataType.Array: {
315 var array = (ArrayType)tr;
316 RuntimeFormatElementType (array.ElementType, builder);
317 builder.Append ("[");
318
319 for (int i = 0; i < array.Rank - 1; ++i)
320 builder.Append (",");
321
322 builder.Append ("]");
323 break;
324 }
325
326 case MetadataType.TypedByReference:
327 builder.Append ("typedbyref");
328 break;
329 case MetadataType.IntPtr:
330 builder.Append ("intptr");
331 break;
332 case MetadataType.UIntPtr:
333 builder.Append ("uintptr");
334 break;
335 case MetadataType.FunctionPointer:
336 builder.Append ("*()");
337 break;
338 case MetadataType.Object:
339 builder.Append ("object");
340 break;
341 default:
342 builder.Append ("-unknown-");
343 break;
344 }
345 }
346
347 static void FormatName (TypeReference tr, StringBuilder builder, char sep)
348 {
349 if (tr.IsNested && !(tr.MetadataType == MetadataType.Var || tr.MetadataType == MetadataType.MVar)) {
350 FormatName (tr.DeclaringType, builder, sep);
351 builder.Append (sep);
352 }
353 if (!string.IsNullOrEmpty (tr.Namespace)) {
354 builder.Append (tr.Namespace);
355 builder.Append (".");
356 }
357
358 builder.Append (tr.Name);
359 }
360
361 static void FormatElementType (TypeReference tr, StringBuilder builder)
362 {
363 var ts = tr as TypeSpecification;
364 if (ts != null) {
365 if (ts.IsByReference) {
366 FormatElementType (ts.ElementType, builder);
367 builder.Append ("&");
368 return;
369 }
370
371 var array = ts as ArrayType;
372 if (array != null) {
373 FormatElementType (ts.ElementType, builder);
374 builder.Append ("[");
375
376 for (int ii = 0; ii < array.Rank - 1; ++ii) {
377 builder.Append (",");
378 }
379
380 builder.Append ("]");
381 return;
382 }
383 }
384 FormatName (tr, builder, '+');
385 }
386 }
387 }
388