Context Navigation

source: stable/HeuristicLab.ExtLibs/HeuristicLab.Cecil/0.9.5/Mono.Cecil-0.9.5/Symbols/Mono.Cecil.Pdb/Microsoft.Cci.Pdb/PdbFunction.cs @ 13825

Visit:

Last change on this file since 13825 was 11700, checked in by jkarder, 10 years ago
#2077: created branch and added first version
File size: 11.7 KB

Line
1	//-----------------------------------------------------------------------------
2	//
3	// Copyright (C) Microsoft Corporation. All Rights Reserved.
4	//
5	//-----------------------------------------------------------------------------
6	using System;
7	using System.Collections;
8	using System.Collections.Generic;
9
10	namespace Microsoft.Cci.Pdb {
11	internal class PdbFunction {
12	static internal readonly Guid msilMetaData = new Guid(0xc6ea3fc9, 0x59b3, 0x49d6, 0xbc, 0x25,
13	0x09, 0x02, 0xbb, 0xab, 0xb4, 0x60);
14	static internal readonly IComparer byAddress = new PdbFunctionsByAddress();
15	static internal readonly IComparer byToken = new PdbFunctionsByToken();
16
17	internal uint token;
18	internal uint slotToken;
19	internal string name;
20	internal string module;
21	internal ushort flags;
22
23	internal uint segment;
24	internal uint address;
25	internal uint length;
26
27	//internal byte[] metadata;
28	internal PdbScope[] scopes;
29	internal PdbLines[] lines;
30	internal ushort[]/?/ usingCounts;
31	internal IEnumerable<INamespaceScope>/?/ namespaceScopes;
32	internal string/?/ iteratorClass;
33	internal List<ILocalScope>/?/ iteratorScopes;
34
35	private static string StripNamespace(string module) {
36	int li = module.LastIndexOf('.');
37	if (li > 0) {
38	return module.Substring(li + 1);
39	}
40	return module;
41	}
42
43
44	internal static PdbFunction[] LoadManagedFunctions(string module,
45	BitAccess bits, uint limit,
46	bool readStrings) {
47	string mod = StripNamespace(module);
48	int begin = bits.Position;
49	int count = 0;
50
51	while (bits.Position < limit) {
52	ushort siz;
53	ushort rec;
54
55	bits.ReadUInt16(out siz);
56	int star = bits.Position;
57	int stop = bits.Position + siz;
58	bits.Position = star;
59	bits.ReadUInt16(out rec);
60
61	switch ((SYM)rec) {
62	case SYM.S_GMANPROC:
63	case SYM.S_LMANPROC:
64	ManProcSym proc;
65	bits.ReadUInt32(out proc.parent);
66	bits.ReadUInt32(out proc.end);
67	bits.Position = (int)proc.end;
68	count++;
69	break;
70
71	case SYM.S_END:
72	bits.Position = stop;
73	break;
74
75	default:
76	//Console.WriteLine("{0,6}: {1:x2} {2}",
77	// bits.Position, rec, (SYM)rec);
78	bits.Position = stop;
79	break;
80	}
81	}
82	if (count == 0) {
83	return null;
84	}
85
86	bits.Position = begin;
87	PdbFunction[] funcs = new PdbFunction[count];
88	int func = 0;
89
90	while (bits.Position < limit) {
91	ushort siz;
92	ushort rec;
93
94	bits.ReadUInt16(out siz);
95	int star = bits.Position;
96	int stop = bits.Position + siz;
97	bits.ReadUInt16(out rec);
98
99	switch ((SYM)rec) {
100
101	case SYM.S_GMANPROC:
102	case SYM.S_LMANPROC:
103	ManProcSym proc;
104	int offset = bits.Position;
105
106	bits.ReadUInt32(out proc.parent);
107	bits.ReadUInt32(out proc.end);
108	bits.ReadUInt32(out proc.next);
109	bits.ReadUInt32(out proc.len);
110	bits.ReadUInt32(out proc.dbgStart);
111	bits.ReadUInt32(out proc.dbgEnd);
112	bits.ReadUInt32(out proc.token);
113	bits.ReadUInt32(out proc.off);
114	bits.ReadUInt16(out proc.seg);
115	bits.ReadUInt8(out proc.flags);
116	bits.ReadUInt16(out proc.retReg);
117	if (readStrings) {
118	bits.ReadCString(out proc.name);
119	} else {
120	bits.SkipCString(out proc.name);
121	}
122	//Console.WriteLine("token={0:X8} [{1}::{2}]", proc.token, module, proc.name);
123
124	bits.Position = stop;
125	funcs[func++] = new PdbFunction(module, proc, bits);
126	break;
127
128	default: {
129	//throw new PdbDebugException("Unknown SYMREC {0}", (SYM)rec);
130	bits.Position = stop;
131	break;
132	}
133	}
134	}
135	return funcs;
136	}
137
138	internal static void CountScopesAndSlots(BitAccess bits, uint limit,
139	out int constants, out int scopes, out int slots, out int usedNamespaces) {
140	int pos = bits.Position;
141	BlockSym32 block;
142	constants = 0;
143	slots = 0;
144	scopes = 0;
145	usedNamespaces = 0;
146
147	while (bits.Position < limit) {
148	ushort siz;
149	ushort rec;
150
151	bits.ReadUInt16(out siz);
152	int star = bits.Position;
153	int stop = bits.Position + siz;
154	bits.Position = star;
155	bits.ReadUInt16(out rec);
156
157	switch ((SYM)rec) {
158	case SYM.S_BLOCK32: {
159	bits.ReadUInt32(out block.parent);
160	bits.ReadUInt32(out block.end);
161
162	scopes++;
163	bits.Position = (int)block.end;
164	break;
165	}
166
167	case SYM.S_MANSLOT:
168	slots++;
169	bits.Position = stop;
170	break;
171
172	case SYM.S_UNAMESPACE:
173	usedNamespaces++;
174	bits.Position = stop;
175	break;
176
177	case SYM.S_MANCONSTANT:
178	constants++;
179	bits.Position = stop;
180	break;
181
182	default:
183	bits.Position = stop;
184	break;
185	}
186	}
187	bits.Position = pos;
188	}
189
190	internal PdbFunction() {
191	}
192
193	internal PdbFunction(string module, ManProcSym proc, BitAccess bits) {
194	this.token = proc.token;
195	this.module = module;
196	this.name = proc.name;
197	this.flags = proc.flags;
198	this.segment = proc.seg;
199	this.address = proc.off;
200	this.length = proc.len;
201	this.slotToken = 0;
202
203	if (proc.seg != 1) {
204	throw new PdbDebugException("Segment is {0}, not 1.", proc.seg);
205	}
206	if (proc.parent != 0 \|\| proc.next != 0) {
207	throw new PdbDebugException("Warning parent={0}, next={1}",
208	proc.parent, proc.next);
209	}
210	if (proc.dbgStart != 0 \|\| proc.dbgEnd != 0) {
211	throw new PdbDebugException("Warning DBG start={0}, end={1}",
212	proc.dbgStart, proc.dbgEnd);
213	}
214
215	int constantCount;
216	int scopeCount;
217	int slotCount;
218	int usedNamespacesCount;
219	CountScopesAndSlots(bits, proc.end, out constantCount, out scopeCount, out slotCount, out usedNamespacesCount);
220	scopes = new PdbScope[scopeCount];
221	int scope = 0;
222
223	while (bits.Position < proc.end) {
224	ushort siz;
225	ushort rec;
226
227	bits.ReadUInt16(out siz);
228	int star = bits.Position;
229	int stop = bits.Position + siz;
230	bits.Position = star;
231	bits.ReadUInt16(out rec);
232
233	switch ((SYM)rec) {
234	case SYM.S_OEM: { // 0x0404
235	OemSymbol oem;
236
237	bits.ReadGuid(out oem.idOem);
238	bits.ReadUInt32(out oem.typind);
239	// internal byte[] rgl; // user data, force 4-byte alignment
240
241	if (oem.idOem == msilMetaData) {
242	string name = bits.ReadString();
243	if (name == "MD2") {
244	byte version;
245	bits.ReadUInt8(out version);
246	if (version == 4) {
247	byte count;
248	bits.ReadUInt8(out count);
249	bits.Align(4);
250	while (count-- > 0)
251	this.ReadCustomMetadata(bits);
252	}
253	}
254	bits.Position = stop;
255	break;
256	} else {
257	throw new PdbDebugException("OEM section: guid={0} ti={1}",
258	oem.idOem, oem.typind);
259	// bits.Position = stop;
260	}
261	}
262
263	case SYM.S_BLOCK32: {
264	BlockSym32 block = new BlockSym32();
265
266	bits.ReadUInt32(out block.parent);
267	bits.ReadUInt32(out block.end);
268	bits.ReadUInt32(out block.len);
269	bits.ReadUInt32(out this.address);
270	bits.ReadUInt16(out block.seg);
271	bits.SkipCString(out block.name);
272	bits.Position = stop;
273
274	scopes[scope] = new PdbScope(block, bits, out slotToken);
275	bits.Position = (int)block.end;
276	break;
277	}
278
279	case SYM.S_UNAMESPACE:
280	bits.Position = stop;
281	break;
282
283	case SYM.S_END:
284	bits.Position = stop;
285	break;
286
287	default: {
288	//throw new PdbDebugException("Unknown SYM: {0}", (SYM)rec);
289	bits.Position = stop;
290	break;
291	}
292	}
293	}
294
295	if (bits.Position != proc.end) {
296	throw new PdbDebugException("Not at S_END");
297	}
298
299	ushort esiz;
300	ushort erec;
301	bits.ReadUInt16(out esiz);
302	bits.ReadUInt16(out erec);
303
304	if (erec != (ushort)SYM.S_END) {
305	throw new PdbDebugException("Missing S_END");
306	}
307	}
308
309	private void ReadCustomMetadata(BitAccess bits) {
310	int savedPosition = bits.Position;
311	byte version;
312	bits.ReadUInt8(out version);
313	if (version != 4) {
314	throw new PdbDebugException("Unknown custom metadata item version: {0}", version);
315	}
316	byte kind;
317	bits.ReadUInt8(out kind);
318	bits.Align(4);
319	uint numberOfBytesInItem;
320	bits.ReadUInt32(out numberOfBytesInItem);
321	switch (kind) {
322	case 0: this.ReadUsingInfo(bits); break;
323	case 1: this.ReadForwardInfo(bits); break;
324	case 2: this.ReadForwardedToModuleInfo(bits); break;
325	case 3: this.ReadIteratorLocals(bits); break;
326	case 4: this.ReadForwardIterator(bits); break;
327	default: throw new PdbDebugException("Unknown custom metadata item kind: {0}", kind);
328	}
329	bits.Position = savedPosition+(int)numberOfBytesInItem;
330	}
331
332	private void ReadForwardIterator(BitAccess bits) {
333	this.iteratorClass = bits.ReadString();
334	}
335
336	private void ReadIteratorLocals(BitAccess bits) {
337	uint numberOfLocals;
338	bits.ReadUInt32(out numberOfLocals);
339	this.iteratorScopes = new List<ILocalScope>((int)numberOfLocals);
340	while (numberOfLocals-- > 0) {
341	uint ilStartOffset;
342	uint ilEndOffset;
343	bits.ReadUInt32(out ilStartOffset);
344	bits.ReadUInt32(out ilEndOffset);
345	this.iteratorScopes.Add(new PdbIteratorScope(ilStartOffset, ilEndOffset-ilStartOffset));
346	}
347	}
348
349	private void ReadForwardedToModuleInfo(BitAccess bits) {
350	}
351
352	private void ReadForwardInfo(BitAccess bits) {
353	}
354
355	private void ReadUsingInfo(BitAccess bits) {
356	ushort numberOfNamespaces;
357	bits.ReadUInt16(out numberOfNamespaces);
358	this.usingCounts = new ushort[numberOfNamespaces];
359	for (ushort i = 0; i < numberOfNamespaces; i++) {
360	bits.ReadUInt16(out this.usingCounts[i]);
361	}
362	}
363
364	internal class PdbFunctionsByAddress : IComparer {
365	public int Compare(Object x, Object y) {
366	PdbFunction fx = (PdbFunction)x;
367	PdbFunction fy = (PdbFunction)y;
368
369	if (fx.segment < fy.segment) {
370	return -1;
371	} else if (fx.segment > fy.segment) {
372	return 1;
373	} else if (fx.address < fy.address) {
374	return -1;
375	} else if (fx.address > fy.address) {
376	return 1;
377	} else {
378	return 0;
379	}
380	}
381	}
382
383	internal class PdbFunctionsByToken : IComparer {
384	public int Compare(Object x, Object y) {
385	PdbFunction fx = (PdbFunction)x;
386	PdbFunction fy = (PdbFunction)y;
387
388	if (fx.token < fy.token) {
389	return -1;
390	} else if (fx.token > fy.token) {
391	return 1;
392	} else {
393	return 0;
394	}
395	}
396
397	}
398	}
399	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences