1 /* |
|
2 * Copyright (c) 2001, 2003, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. |
|
8 * |
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
|
13 * accompanied this code). |
|
14 * |
|
15 * You should have received a copy of the GNU General Public License version |
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 * |
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
20 * or visit www.oracle.com if you need additional information or have any |
|
21 * questions. |
|
22 * |
|
23 */ |
|
24 |
|
25 package sun.jvm.hotspot.debugger.win32; |
|
26 |
|
27 import java.util.*; |
|
28 |
|
29 import sun.jvm.hotspot.debugger.*; |
|
30 import sun.jvm.hotspot.debugger.win32.coff.*; |
|
31 import sun.jvm.hotspot.debugger.cdbg.*; |
|
32 import sun.jvm.hotspot.debugger.cdbg.basic.*; |
|
33 import sun.jvm.hotspot.utilities.Assert; |
|
34 |
|
35 class Win32CDebugInfoBuilder |
|
36 implements DebugVC50SubsectionTypes, DebugVC50TypeLeafIndices, DebugVC50TypeEnums, DebugVC50SymbolTypes, DebugVC50MemberAttributes, CVAttributes, AccessControl { |
|
37 private Win32Debugger dbg; |
|
38 private Address base; |
|
39 |
|
40 private DebugVC50 vc50; |
|
41 private BasicCDebugInfoDataBase db; |
|
42 private DebugVC50TypeIterator iter; |
|
43 |
|
44 private DebugVC50SymbolIterator symIter; |
|
45 |
|
46 // Logical->physical segment mapping |
|
47 private COFFFile file; |
|
48 private DebugVC50SSSegMap segMap; |
|
49 |
|
50 // Canonicalization of primitive types |
|
51 private Map primIndexToTypeMap; |
|
52 |
|
53 // Global unnamed enumeration |
|
54 // (FIXME: must figure out how to handle nested type descriptions) |
|
55 private BasicEnumType unnamedEnum; |
|
56 |
|
57 private Stack blockStack; |
|
58 private int endsToSkip; |
|
59 |
|
60 private static final int POINTER_SIZE = 4; |
|
61 |
|
62 Win32CDebugInfoBuilder(Win32Debugger dbg) { |
|
63 this.dbg = dbg; |
|
64 } |
|
65 |
|
66 CDebugInfoDataBase buildDataBase(String dllName, Address base) { |
|
67 this.base = base; |
|
68 file = COFFFileParser.getParser().parse(dllName); |
|
69 vc50 = getDebugVC50(file); |
|
70 |
|
71 if (vc50 == null) return null; |
|
72 |
|
73 segMap = getSegMap(); |
|
74 |
|
75 primIndexToTypeMap = new HashMap(); |
|
76 blockStack = new Stack(); |
|
77 endsToSkip = 0; |
|
78 |
|
79 db = new BasicCDebugInfoDataBase(); |
|
80 db.beginConstruction(); |
|
81 |
|
82 // Get global types and add them to the database |
|
83 DebugVC50SSGlobalTypes types = getGlobalTypes(); |
|
84 for (iter = types.getTypeIterator(); !iter.done(); iter.next()) { |
|
85 while (!iter.typeStringDone()) { |
|
86 switch (iter.typeStringLeaf()) { |
|
87 case LF_MODIFIER: { |
|
88 int idx = iter.getModifierIndex(); |
|
89 BasicType target = getTypeByIndex(idx); |
|
90 short windowsMods = iter.getModifierAttribute(); |
|
91 short mods = 0; |
|
92 if ((windowsMods & MODIFIER_CONST_MASK) != 0) mods |= CONST; |
|
93 if ((windowsMods & MODIFIER_VOLATILE_MASK) != 0) mods |= VOLATILE; |
|
94 putType(target.getCVVariant(mods)); |
|
95 break; |
|
96 } |
|
97 case LF_POINTER: { |
|
98 int idx = iter.getPointerType(); |
|
99 BasicType target = getTypeByIndex(idx); |
|
100 short windowsMods = iter.getModifierAttribute(); |
|
101 short mods = 0; |
|
102 if ((windowsMods & POINTER_CONST_MASK) != 0) mods |= CONST; |
|
103 if ((windowsMods & POINTER_VOLATILE_MASK) != 0) mods |= VOLATILE; |
|
104 BasicPointerType ptrType = new BasicPointerType(POINTER_SIZE, target); |
|
105 if (mods != 0) { |
|
106 ptrType = (BasicPointerType) ptrType.getCVVariant(mods); |
|
107 } |
|
108 |
|
109 putType(ptrType); |
|
110 break; |
|
111 } |
|
112 case LF_ARRAY: { |
|
113 BasicType elemType = getTypeByIndex(iter.getArrayElementType()); |
|
114 putType(new BasicArrayType(iter.getArrayName(), elemType, iter.getArrayLength())); |
|
115 break; |
|
116 } |
|
117 case LF_CLASS: |
|
118 case LF_STRUCTURE: { |
|
119 CompoundTypeKind kind = ((iter.typeStringLeaf() == LF_CLASS) ? CompoundTypeKind.CLASS |
|
120 : CompoundTypeKind.STRUCT); |
|
121 BasicCompoundType type = new BasicCompoundType(iter.getClassName(), |
|
122 iter.getClassSize(), |
|
123 kind); |
|
124 // Skip parsing of forward references to types |
|
125 // FIXME: do we have to resolve these later? |
|
126 if ((iter.getClassProperty() & PROPERTY_FWDREF) == 0) { |
|
127 DebugVC50TypeIterator fieldIter = iter.getClassFieldListIterator(); |
|
128 if (Assert.ASSERTS_ENABLED) { |
|
129 Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list"); |
|
130 } |
|
131 boolean advance = false; |
|
132 while (!fieldIter.typeStringDone()) { |
|
133 advance = true; |
|
134 switch (fieldIter.typeStringLeaf()) { |
|
135 case LF_FIELDLIST: break; |
|
136 case LF_BCLASS: { |
|
137 int accessControl = memberAttributeToAccessControl(fieldIter.getBClassAttribute()); |
|
138 Type baseType = getTypeByIndex(fieldIter.getBClassType()); |
|
139 // FIXME: take offset into account |
|
140 type.addBaseClass(new BasicBaseClass(accessControl, false, baseType)); |
|
141 break; |
|
142 } |
|
143 case LF_VBCLASS: { |
|
144 int accessControl = memberAttributeToAccessControl(fieldIter.getVBClassAttribute()); |
|
145 Type baseType = getTypeByIndex(fieldIter.getVBClassBaseClassType()); |
|
146 // FIXME: take offset and virtual base offset into account |
|
147 type.addBaseClass(new BasicBaseClass(accessControl, true, baseType)); |
|
148 break; |
|
149 } |
|
150 // I don't think we need to handle indirect virtual base |
|
151 // classes since they should be handled indirectly through |
|
152 // the modeling of the type hierarchy |
|
153 case LF_IVBCLASS: break; |
|
154 case LF_INDEX: { |
|
155 fieldIter = fieldIter.getIndexIterator(); |
|
156 advance = false; |
|
157 break; |
|
158 } |
|
159 case LF_MEMBER: { |
|
160 BasicField field = new BasicField(fieldIter.getMemberName(), |
|
161 getTypeByIndex(fieldIter.getMemberType()), |
|
162 memberAttributeToAccessControl(fieldIter.getMemberAttribute()), |
|
163 false); |
|
164 field.setOffset(fieldIter.getMemberOffset()); |
|
165 type.addField(field); |
|
166 break; |
|
167 } |
|
168 case LF_STMEMBER: { |
|
169 BasicField field = new BasicField(fieldIter.getStaticName(), |
|
170 getTypeByIndex(fieldIter.getStaticType()), |
|
171 memberAttributeToAccessControl(fieldIter.getStaticAttribute()), |
|
172 true); |
|
173 // The field's address will be found during resolution |
|
174 // of the debug info database |
|
175 type.addField(field); |
|
176 break; |
|
177 } |
|
178 // FIXME: handle methods |
|
179 case LF_METHOD: break; |
|
180 case LF_ONEMETHOD: break; |
|
181 // FIXME: handle nested types |
|
182 case LF_NESTTYPE: break; |
|
183 case LF_NESTTYPEEX: break; |
|
184 // NOTE: virtual functions not needed/handled yet for |
|
185 // this debugging system (because we are not planning to |
|
186 // handle calling methods in the target process at |
|
187 // runtime) |
|
188 case LF_VFUNCTAB: break; |
|
189 case LF_FRIENDCLS: break; |
|
190 case LF_VFUNCOFF: break; |
|
191 case LF_MEMBERMODIFY: break; |
|
192 case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3: |
|
193 case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7: |
|
194 case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11: |
|
195 case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break; |
|
196 default: System.err.println("WARNING: unexpected leaf index " + |
|
197 fieldIter.typeStringLeaf() + |
|
198 " in field list for type " + iter.getTypeIndex()); |
|
199 } |
|
200 if (advance) { |
|
201 fieldIter.typeStringNext(); |
|
202 } |
|
203 } |
|
204 } |
|
205 putType(type); |
|
206 break; |
|
207 } |
|
208 case LF_UNION: { |
|
209 BasicCompoundType type = new BasicCompoundType(iter.getUnionName(), |
|
210 iter.getUnionSize(), |
|
211 CompoundTypeKind.UNION); |
|
212 // Skip parsing of forward references to types |
|
213 // FIXME: do we have to resolve these later? |
|
214 if ((iter.getClassProperty() & PROPERTY_FWDREF) == 0) { |
|
215 DebugVC50TypeIterator fieldIter = iter.getUnionFieldListIterator(); |
|
216 if (Assert.ASSERTS_ENABLED) { |
|
217 Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list"); |
|
218 } |
|
219 boolean advance = false; |
|
220 while (!fieldIter.typeStringDone()) { |
|
221 advance = true; |
|
222 switch (fieldIter.typeStringLeaf()) { |
|
223 case LF_FIELDLIST: break; |
|
224 case LF_BCLASS: break; |
|
225 case LF_VBCLASS: break; |
|
226 case LF_IVBCLASS: break; |
|
227 case LF_INDEX: { |
|
228 fieldIter = fieldIter.getIndexIterator(); |
|
229 advance = false; |
|
230 break; |
|
231 } |
|
232 case LF_MEMBER: { |
|
233 BasicField field = new BasicField(fieldIter.getMemberName(), |
|
234 getTypeByIndex(fieldIter.getMemberType()), |
|
235 memberAttributeToAccessControl(fieldIter.getMemberAttribute()), |
|
236 false); |
|
237 field.setOffset(fieldIter.getMemberOffset()); |
|
238 type.addField(field); |
|
239 break; |
|
240 } |
|
241 case LF_STMEMBER: { |
|
242 System.err.println("WARNING: I didn't think unions could contain static fields..."); |
|
243 BasicField field = new BasicField(fieldIter.getStaticName(), |
|
244 getTypeByIndex(fieldIter.getStaticType()), |
|
245 memberAttributeToAccessControl(fieldIter.getStaticAttribute()), |
|
246 true); |
|
247 // The field's address will be found during resolution |
|
248 // of the debug info database |
|
249 type.addField(field); |
|
250 break; |
|
251 } |
|
252 case LF_METHOD: break; |
|
253 case LF_ONEMETHOD: break; |
|
254 // FIXME: handle nested types |
|
255 case LF_NESTTYPE: break; |
|
256 case LF_NESTTYPEEX: break; |
|
257 case LF_VFUNCTAB: break; |
|
258 case LF_FRIENDCLS: break; |
|
259 case LF_VFUNCOFF: break; |
|
260 case LF_MEMBERMODIFY: break; |
|
261 case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3: |
|
262 case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7: |
|
263 case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11: |
|
264 case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break; |
|
265 |
|
266 default: System.err.println("WARNING: unexpected leaf index " + |
|
267 fieldIter.typeStringLeaf() + |
|
268 " in field list for union of type " + iter.getTypeIndex()); |
|
269 } |
|
270 if (advance) { |
|
271 fieldIter.typeStringNext(); |
|
272 } |
|
273 } |
|
274 } |
|
275 putType(type); |
|
276 break; |
|
277 } |
|
278 case LF_ENUM: { |
|
279 String name = iter.getEnumName(); |
|
280 BasicEnumType enumType = null; |
|
281 if ((name == null) || (name.equals(""))) { |
|
282 if (unnamedEnum == null) { |
|
283 unnamedEnum = new BasicEnumType(null, getTypeByIndex(iter.getEnumType())); |
|
284 } |
|
285 enumType = unnamedEnum; |
|
286 } else { |
|
287 enumType = new BasicEnumType(name, getTypeByIndex(iter.getEnumType())); |
|
288 } |
|
289 DebugVC50TypeIterator fieldIter = iter.getEnumFieldListIterator(); |
|
290 if (Assert.ASSERTS_ENABLED) { |
|
291 Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list"); |
|
292 } |
|
293 boolean advance = false; |
|
294 while (!fieldIter.typeStringDone()) { |
|
295 advance = true; |
|
296 switch (fieldIter.typeStringLeaf()) { |
|
297 case LF_FIELDLIST: break; |
|
298 case LF_ENUMERATE: { |
|
299 String enumName = fieldIter.getEnumerateName(); |
|
300 long enumVal = fieldIter.getEnumerateValue(); |
|
301 enumType.addEnum(enumName, enumVal); |
|
302 break; |
|
303 } |
|
304 case LF_INDEX: { |
|
305 fieldIter = fieldIter.getIndexIterator(); |
|
306 advance = false; |
|
307 break; |
|
308 } |
|
309 |
|
310 case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3: |
|
311 case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7: |
|
312 case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11: |
|
313 case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break; |
|
314 |
|
315 default: System.err.println("WARNING: unexpected leaf index " + |
|
316 fieldIter.typeStringLeaf() + |
|
317 " in field list for enum of type " + iter.getTypeIndex()); |
|
318 } |
|
319 |
|
320 if (advance) { |
|
321 fieldIter.typeStringNext(); |
|
322 } |
|
323 } |
|
324 |
|
325 putType(enumType); |
|
326 break; |
|
327 } |
|
328 case LF_PROCEDURE: { |
|
329 Type retType = getTypeByIndex(iter.getProcedureReturnType()); |
|
330 BasicFunctionType func = new BasicFunctionType(null, POINTER_SIZE, retType); |
|
331 DebugVC50TypeIterator argIter = iter.getProcedureArgumentListIterator(); |
|
332 if (Assert.ASSERTS_ENABLED) { |
|
333 Assert.that(argIter.typeStringLeaf() == LF_ARGLIST, "Expected argument list"); |
|
334 } |
|
335 for (int i = 0; i < argIter.getArgListCount(); i++) { |
|
336 func.addArgumentType(getTypeByIndex(argIter.getArgListType(i))); |
|
337 } |
|
338 putType(func); |
|
339 break; |
|
340 } |
|
341 case LF_MFUNCTION: { |
|
342 Type retType = getTypeByIndex(iter.getMFunctionReturnType()); |
|
343 Type container = getTypeByIndex(iter.getMFunctionContainingClass()); |
|
344 Type thisType = getTypeByIndex(iter.getMFunctionThis()); |
|
345 long thisAdjust = iter.getMFunctionThisAdjust(); |
|
346 BasicMemberFunctionType func = new BasicMemberFunctionType(null, |
|
347 POINTER_SIZE, |
|
348 retType, |
|
349 container, |
|
350 thisType, |
|
351 thisAdjust); |
|
352 DebugVC50TypeIterator argIter = iter.getMFunctionArgumentListIterator(); |
|
353 for (int i = 0; i < argIter.getArgListCount(); i++) { |
|
354 func.addArgumentType(getTypeByIndex(argIter.getArgListType(i))); |
|
355 } |
|
356 putType(func); |
|
357 break; |
|
358 } |
|
359 // FIXME: handle virtual function table shape description |
|
360 case LF_VTSHAPE: break; |
|
361 case LF_BARRAY: System.err.println("FIXME: don't know what to do with LF_BARRAY leaves (convert to pointers?"); break; |
|
362 case LF_LABEL: break; |
|
363 case LF_NULL: break; // FIXME: do we need to handle this? With what? |
|
364 case LF_DIMARRAY: System.err.println("FIXME: don't know what to do with LF_DIMARRAY leaves yet"); break; |
|
365 case LF_VFTPATH: break; |
|
366 case LF_PRECOMP: break; |
|
367 case LF_ENDPRECOMP: break; |
|
368 case LF_OEM: break; |
|
369 case LF_TYPESERVER: break; |
|
370 |
|
371 // Type records referenced from other type records |
|
372 |
|
373 case LF_SKIP: break; |
|
374 case LF_ARGLIST: skipTypeRecord(); break; |
|
375 case LF_DEFARG: System.err.println("FIXME: handle default arguments (dereference the type)"); break; |
|
376 case LF_FIELDLIST: skipTypeRecord(); break; |
|
377 case LF_DERIVED: break; |
|
378 case LF_BITFIELD: { |
|
379 Type underlyingType = getTypeByIndex(iter.getBitfieldFieldType()); |
|
380 BasicBitType bit = new BasicBitType(underlyingType, |
|
381 (iter.getBitfieldLength() & 0xFF), |
|
382 (iter.getBitfieldPosition() & 0xFF)); |
|
383 putType(bit); |
|
384 break; |
|
385 } |
|
386 case LF_METHODLIST: break; |
|
387 case LF_DIMCONU: |
|
388 case LF_DIMCONLU: |
|
389 case LF_DIMVARU: |
|
390 case LF_DIMVARLU: break; |
|
391 case LF_REFSYM: break; |
|
392 |
|
393 case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3: |
|
394 case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7: |
|
395 case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11: |
|
396 case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break; |
|
397 |
|
398 default: { |
|
399 System.err.println("Unexpected leaf index " + |
|
400 iter.typeStringLeaf() + " at offset 0x" + |
|
401 Integer.toHexString(iter.typeStringOffset())); |
|
402 break; |
|
403 } |
|
404 } |
|
405 |
|
406 |
|
407 if (!iter.typeStringDone()) { |
|
408 iter.typeStringNext(); |
|
409 } |
|
410 } |
|
411 } |
|
412 |
|
413 // Add all symbol directories to debug info |
|
414 // (FIXME: must figure out how to handle module-by-module |
|
415 // arrangement of at least the static symbols to have proper |
|
416 // lookup -- should probably also take advantage of the PROCREF |
|
417 // and UDT references to understand how to build the global |
|
418 // database vs. the module-by-module one) |
|
419 DebugVC50SubsectionDirectory dir = vc50.getSubsectionDirectory(); |
|
420 int moduleNumber = 0; // Debugging |
|
421 for (int i = 0; i < dir.getNumEntries(); i++) { |
|
422 DebugVC50Subsection ss = dir.getSubsection(i); |
|
423 int ssType = ss.getSubsectionType(); |
|
424 boolean process = false; |
|
425 |
|
426 if ((ssType == SST_GLOBAL_SYM) || |
|
427 (ssType == SST_GLOBAL_PUB) || |
|
428 (ssType == SST_STATIC_SYM)) { |
|
429 DebugVC50SSSymbolBase syms = (DebugVC50SSSymbolBase) ss; |
|
430 symIter = syms.getSymbolIterator(); |
|
431 process = true; |
|
432 } |
|
433 |
|
434 if (ssType == SST_ALIGN_SYM) { |
|
435 DebugVC50SSAlignSym syms = (DebugVC50SSAlignSym) ss; |
|
436 symIter = syms.getSymbolIterator(); |
|
437 process = true; |
|
438 } |
|
439 |
|
440 if (process) { |
|
441 for (; !symIter.done(); symIter.next()) { |
|
442 switch (symIter.getType()) { |
|
443 case S_COMPILE: break; |
|
444 case S_SSEARCH: break; // FIXME: may need this later |
|
445 case S_END: { |
|
446 try { |
|
447 // FIXME: workaround for warnings until we figure out |
|
448 // what to do with THUNK32 symbols |
|
449 if (endsToSkip == 0) { |
|
450 blockStack.pop(); |
|
451 } else { |
|
452 --endsToSkip; |
|
453 } |
|
454 } catch (EmptyStackException e) { |
|
455 System.err.println("WARNING: mismatched block begins/ends in debug information"); |
|
456 } |
|
457 break; |
|
458 } |
|
459 case S_SKIP: break; |
|
460 case S_CVRESERVE: break; |
|
461 case S_OBJNAME: break; // FIXME: may need this later |
|
462 case S_ENDARG: break; |
|
463 case S_COBOLUDT: break; |
|
464 case S_MANYREG: break; // FIXME: may need to add support for this |
|
465 case S_RETURN: break; // NOTE: would need this if adding support for calling functions |
|
466 case S_ENTRYTHIS: break; // FIXME: may need to add support for this |
|
467 case S_REGISTER: break; // FIXME: may need to add support for this |
|
468 case S_CONSTANT: break; // FIXME: will need to add support for this |
|
469 case S_UDT: break; // FIXME: need to see how these are used; are |
|
470 // they redundant, or are they used to describe |
|
471 // global variables as opposed to types? |
|
472 case S_COBOLUDT2: break; |
|
473 case S_MANYREG2: break; |
|
474 case S_BPREL32: { |
|
475 LocalSym sym = new BasicLocalSym(symIter.getBPRelName(), |
|
476 getTypeByIndex(symIter.getBPRelType()), |
|
477 symIter.getBPRelOffset()); |
|
478 addLocalToCurBlock(sym); |
|
479 break; |
|
480 } |
|
481 case S_LDATA32: |
|
482 case S_GDATA32: { |
|
483 // FIXME: must handle these separately from global data (have |
|
484 // module scoping and only add these at the module level) |
|
485 boolean isModuleLocal = (symIter.getType() == S_LDATA32); |
|
486 |
|
487 GlobalSym sym = new BasicGlobalSym(symIter.getLGDataName(), |
|
488 getTypeByIndex(symIter.getLGDataType()), |
|
489 newAddress(symIter.getLGDataOffset(), symIter.getLGDataSegment()), |
|
490 isModuleLocal); |
|
491 // FIXME: must handle module-local symbols differently |
|
492 addGlobalSym(sym); |
|
493 break; |
|
494 } |
|
495 case S_PUB32: break; // FIXME: figure out how these differ from |
|
496 // above and how they are used |
|
497 case S_LPROC32: |
|
498 case S_GPROC32: { |
|
499 BasicFunctionSym sym = new BasicFunctionSym(newLazyBlockSym(symIter.getLGProcParentOffset()), |
|
500 symIter.getLGProcLength(), |
|
501 newAddress(symIter.getLGProcOffset(), symIter.getLGProcSegment()), |
|
502 symIter.getLGProcName(), |
|
503 getTypeByIndex(symIter.getLGProcType()), |
|
504 (symIter.getType() == S_LPROC32)); |
|
505 |
|
506 // FIXME: have to handle local procedures differently (have |
|
507 // notion of modules and only add those procedures to the |
|
508 // module they are defined in) |
|
509 addBlock(sym); |
|
510 break; |
|
511 } |
|
512 case S_THUNK32: { |
|
513 // FIXME: see whether we need to handle these |
|
514 skipEnd(); |
|
515 break; |
|
516 } |
|
517 case S_BLOCK32: { |
|
518 BasicBlockSym sym = new BasicBlockSym(newLazyBlockSym(symIter.getBlockParentOffset()), |
|
519 symIter.getBlockLength(), |
|
520 newAddress(symIter.getBlockOffset(), symIter.getBlockSegment()), |
|
521 symIter.getBlockName()); |
|
522 addBlock(sym); |
|
523 break; |
|
524 } |
|
525 case S_WITH32: break; |
|
526 case S_LABEL32: break; |
|
527 case S_CEXMODEL32: break; |
|
528 case S_VFTTABLE32: break; // FIXME: may need to handle this |
|
529 // (most likely for run-time type determination) |
|
530 case S_REGREL32: break; // FIXME: may need to add support for this |
|
531 case S_LTHREAD32: break; |
|
532 case S_GTHREAD32: break; // FIXME: may need to add support for these |
|
533 case S_PROCREF: break; |
|
534 case S_DATAREF: break; |
|
535 case S_ALIGN: break; |
|
536 default: |
|
537 // These two unknown symbol types show up very frequently. |
|
538 // Symbol type 0 appears to always be a no-op symbol of |
|
539 // length 2 (i.e., length just covers the symbol type.) |
|
540 // Symbol type 4115 appears to be a copyright notice for |
|
541 // the Microsoft linker. |
|
542 if ((symIter.getType() != 0) && (symIter.getType() != 4115)) { |
|
543 System.err.println(" NOTE: Unexpected symbol of type " + |
|
544 symIter.getType() + " at offset 0x" + |
|
545 Integer.toHexString(symIter.getOffset())); |
|
546 } |
|
547 break; |
|
548 } |
|
549 } |
|
550 } |
|
551 } |
|
552 |
|
553 // Add line number information for all modules |
|
554 for (int i = 0; i < dir.getNumEntries(); i++) { |
|
555 DebugVC50Subsection ss = dir.getSubsection(i); |
|
556 if (ss.getSubsectionType() == SST_SRC_MODULE) { |
|
557 DebugVC50SSSrcModule srcMod = (DebugVC50SSSrcModule) ss; |
|
558 for (int sf = 0; sf < srcMod.getNumSourceFiles(); sf++) { |
|
559 DebugVC50SrcModFileDesc desc = srcMod.getSourceFileDesc(sf); |
|
560 // Uniquify these to save space |
|
561 String name = desc.getSourceFileName().intern(); |
|
562 for (int cs = 0; cs < desc.getNumCodeSegments(); cs++) { |
|
563 DebugVC50SrcModLineNumberMap map = desc.getLineNumberMap(cs); |
|
564 SectionHeader seg = file.getHeader().getSectionHeader(map.getSegment()); |
|
565 for (int lp = 0; lp < map.getNumSourceLinePairs(); lp++) { |
|
566 Address startPC = base.addOffsetTo(seg.getVirtualAddress() + map.getCodeOffset(lp)); |
|
567 // Fake address for endPC -- will be filled in by BasicLineNumberMapping |
|
568 Address endPC = base.addOffsetTo(seg.getSize()); |
|
569 db.addLineNumberInfo(new BasicLineNumberInfo(name, map.getLineNumber(lp), startPC, endPC)); |
|
570 } |
|
571 } |
|
572 } |
|
573 } |
|
574 } |
|
575 |
|
576 // Finish assembly of database |
|
577 db.resolve(new ResolveListener() { |
|
578 public void resolveFailed(Type containingType, LazyType failedResolve, String detail) { |
|
579 System.err.println("WARNING: failed to resolve type of index " + |
|
580 ((Integer) failedResolve.getKey()).intValue() + |
|
581 " in type " + containingType.getName() + " (class " + |
|
582 containingType.getClass().getName() + ") while " + detail); |
|
583 } |
|
584 |
|
585 public void resolveFailed(Type containingType, String staticFieldName) { |
|
586 System.err.println("WARNING: failed to resolve address of static field \"" + |
|
587 staticFieldName + "\" in type " + containingType.getName()); |
|
588 } |
|
589 |
|
590 public void resolveFailed(Sym containingSymbol, LazyType failedResolve, String detail) { |
|
591 System.err.println("WARNING: failed to resolve type of index " + |
|
592 ((Integer) failedResolve.getKey()).intValue() + |
|
593 " in symbol of type " + containingSymbol.getClass().getName() + |
|
594 " while " + detail); |
|
595 } |
|
596 |
|
597 public void resolveFailed(Sym containingSymbol, LazyBlockSym failedResolve, String detail) { |
|
598 System.err.println("WARNING: failed to resolve block at offset 0x" + |
|
599 Integer.toHexString(((Integer) failedResolve.getKey()).intValue()) + |
|
600 " in symbol of type " + containingSymbol.getClass().getName() + |
|
601 " while " + detail); |
|
602 } |
|
603 }); |
|
604 |
|
605 db.endConstruction(); |
|
606 |
|
607 return db; |
|
608 } |
|
609 |
|
610 |
|
611 //---------------------------------------------------------------------- |
|
612 // Internals only below this point |
|
613 // |
|
614 |
|
615 private static DebugVC50 getDebugVC50(COFFFile file) { |
|
616 COFFHeader header = file.getHeader(); |
|
617 OptionalHeader opt = header.getOptionalHeader(); |
|
618 if (opt == null) { |
|
619 // Optional header not found |
|
620 return null; |
|
621 } |
|
622 OptionalHeaderDataDirectories dd = opt.getDataDirectories(); |
|
623 if (dd == null) { |
|
624 // Optional header data directories not found |
|
625 return null; |
|
626 } |
|
627 DebugDirectory debug = dd.getDebugDirectory(); |
|
628 if (debug == null) { |
|
629 // Debug directory not found |
|
630 return null; |
|
631 } |
|
632 for (int i = 0; i < debug.getNumEntries(); i++) { |
|
633 DebugDirectoryEntry entry = debug.getEntry(i); |
|
634 if (entry.getType() == DebugTypes.IMAGE_DEBUG_TYPE_CODEVIEW) { |
|
635 return entry.getDebugVC50(); |
|
636 } |
|
637 } |
|
638 |
|
639 // CodeView information not found in debug directory |
|
640 return null; |
|
641 } |
|
642 |
|
643 private DebugVC50SSSegMap getSegMap() { |
|
644 return (DebugVC50SSSegMap) findSubsection(SST_SEG_MAP); |
|
645 } |
|
646 |
|
647 private DebugVC50SSGlobalTypes getGlobalTypes() { |
|
648 return (DebugVC50SSGlobalTypes) findSubsection(SST_GLOBAL_TYPES); |
|
649 } |
|
650 |
|
651 private DebugVC50SSGlobalSym getGlobalSymbols() { |
|
652 return (DebugVC50SSGlobalSym) findSubsection(SST_GLOBAL_SYM); |
|
653 } |
|
654 |
|
655 private DebugVC50Subsection findSubsection(short ssType) { |
|
656 DebugVC50SubsectionDirectory dir = vc50.getSubsectionDirectory(); |
|
657 for (int i = 0; i < dir.getNumEntries(); i++) { |
|
658 DebugVC50Subsection ss = dir.getSubsection(i); |
|
659 if (ss.getSubsectionType() == ssType) { |
|
660 return ss; |
|
661 } |
|
662 } |
|
663 throw new DebuggerException("Unable to find subsection of type " + ssType); |
|
664 } |
|
665 |
|
666 private void putType(Type t) { |
|
667 db.addType(new Integer(iter.getTypeIndex()), t); |
|
668 } |
|
669 |
|
670 private Address newAddress(int offset, short segment) { |
|
671 int seg = segment & 0xFFFF; |
|
672 // NOTE: it isn't clear how to use the segMap to map from logical |
|
673 // to physical segments. It seems it would make more sense if the |
|
674 // SegDescs contained a physical segment number in addition to the |
|
675 // offset within the physical segment of the logical one. |
|
676 |
|
677 // Get the section header corresponding to this segment |
|
678 SectionHeader section = file.getHeader().getSectionHeader(seg); |
|
679 |
|
680 // Result is relative to image base |
|
681 return base.addOffsetTo(section.getVirtualAddress() + offset); |
|
682 } |
|
683 |
|
684 private BasicType getTypeByIndex(int intIndex) { |
|
685 Integer index = new Integer(intIndex); |
|
686 |
|
687 // Handle primitive types here. |
|
688 if (intIndex <= 0x0FFF) { |
|
689 BasicType type = (BasicType) primIndexToTypeMap.get(index); |
|
690 if (type != null) { |
|
691 return type; |
|
692 } |
|
693 // Construct appropriate new primitive type |
|
694 int primMode = intIndex & RESERVED_MODE_MASK; |
|
695 if (primMode == RESERVED_MODE_DIRECT) { |
|
696 int primType = intIndex & RESERVED_TYPE_MASK; |
|
697 switch (primType) { |
|
698 case RESERVED_TYPE_SIGNED_INT: |
|
699 case RESERVED_TYPE_UNSIGNED_INT: { |
|
700 boolean unsigned = (primType == RESERVED_TYPE_UNSIGNED_INT); |
|
701 int size = 0; |
|
702 String name = null; |
|
703 switch (intIndex & RESERVED_SIZE_MASK) { |
|
704 case RESERVED_SIZE_INT_1_BYTE: size = 1; name = "char"; break; |
|
705 case RESERVED_SIZE_INT_2_BYTE: size = 2; name = "short"; break; |
|
706 case RESERVED_SIZE_INT_4_BYTE: size = 4; name = "int"; break; |
|
707 case RESERVED_SIZE_INT_8_BYTE: size = 8; name = "__int64"; break; |
|
708 default: throw new DebuggerException("Illegal size of integer type " + intIndex); |
|
709 } |
|
710 type = new BasicIntType(name, size, unsigned); |
|
711 break; |
|
712 } |
|
713 case RESERVED_TYPE_BOOLEAN: { |
|
714 int size = 0; |
|
715 switch (intIndex & RESERVED_SIZE_MASK) { |
|
716 case RESERVED_SIZE_INT_1_BYTE: size = 1; break; |
|
717 case RESERVED_SIZE_INT_2_BYTE: size = 2; break; |
|
718 case RESERVED_SIZE_INT_4_BYTE: size = 4; break; |
|
719 case RESERVED_SIZE_INT_8_BYTE: size = 8; break; |
|
720 default: throw new DebuggerException("Illegal size of boolean type " + intIndex); |
|
721 } |
|
722 type = new BasicIntType("bool", size, false); |
|
723 break; |
|
724 } |
|
725 case RESERVED_TYPE_REAL: { |
|
726 switch (intIndex & RESERVED_SIZE_MASK) { |
|
727 case RESERVED_SIZE_REAL_32_BIT: |
|
728 type = new BasicFloatType("float", 4); |
|
729 break; |
|
730 case RESERVED_SIZE_REAL_64_BIT: |
|
731 type = new BasicDoubleType("double", 8); |
|
732 break; |
|
733 default: |
|
734 throw new DebuggerException("Unsupported floating-point size in type " + intIndex); |
|
735 } |
|
736 break; |
|
737 } |
|
738 case RESERVED_TYPE_REALLY_INT: { |
|
739 switch (intIndex & RESERVED_SIZE_MASK) { |
|
740 case RESERVED_SIZE_REALLY_INT_CHAR: type = new BasicIntType("char", 1, false); break; |
|
741 case RESERVED_SIZE_REALLY_INT_WCHAR: type = new BasicIntType("wchar", 2, false); break; |
|
742 case RESERVED_SIZE_REALLY_INT_2_BYTE: type = new BasicIntType("short", 2, false); break; |
|
743 case RESERVED_SIZE_REALLY_INT_2_BYTE_U: type = new BasicIntType("short", 2, true); break; |
|
744 case RESERVED_SIZE_REALLY_INT_4_BYTE: type = new BasicIntType("int", 4, false); break; |
|
745 case RESERVED_SIZE_REALLY_INT_4_BYTE_U: type = new BasicIntType("int", 4, true); break; |
|
746 case RESERVED_SIZE_REALLY_INT_8_BYTE: type = new BasicIntType("__int64", 8, false); break; |
|
747 case RESERVED_SIZE_REALLY_INT_8_BYTE_U: type = new BasicIntType("__int64", 8, true); break; |
|
748 default: throw new DebuggerException("Illegal REALLY_INT size in type " + intIndex); |
|
749 } |
|
750 break; |
|
751 } |
|
752 case RESERVED_TYPE_SPECIAL: { |
|
753 switch (intIndex & RESERVED_SIZE_MASK) { |
|
754 case RESERVED_SIZE_SPECIAL_NO_TYPE: |
|
755 case RESERVED_SIZE_SPECIAL_VOID: type = new BasicVoidType(); break; |
|
756 default: throw new DebuggerException("Don't know how to handle reserved special type " + intIndex); |
|
757 } |
|
758 break; |
|
759 } |
|
760 |
|
761 default: |
|
762 throw new DebuggerException("Don't know how to handle reserved type " + intIndex); |
|
763 } |
|
764 } else { |
|
765 // Fold all pointer types together since we only support |
|
766 // flat-mode addressing anyway |
|
767 Type targetType = getTypeByIndex(intIndex & (~RESERVED_MODE_MASK)); |
|
768 |
|
769 type = new BasicPointerType(POINTER_SIZE, targetType); |
|
770 } |
|
771 if (Assert.ASSERTS_ENABLED) { |
|
772 Assert.that(type != null, "Got null Type for primitive type " + intIndex); |
|
773 } |
|
774 primIndexToTypeMap.put(index, type); |
|
775 return type; |
|
776 } |
|
777 |
|
778 // Not primitive type. Construct lazy reference to target type. |
|
779 // (Is it worth canonicalizing these as well to save space?) |
|
780 return new LazyType(index); |
|
781 } |
|
782 |
|
783 private void addBlock(BlockSym block) { |
|
784 db.addBlock(new Integer(symIter.getOffset()), block); |
|
785 blockStack.push(block); |
|
786 } |
|
787 |
|
788 private void skipEnd() { |
|
789 ++endsToSkip; |
|
790 } |
|
791 |
|
792 private BlockSym newLazyBlockSym(int offset) { |
|
793 if (offset == 0) { |
|
794 return null; |
|
795 } |
|
796 |
|
797 return new LazyBlockSym(new Integer(offset)); |
|
798 } |
|
799 |
|
800 private int memberAttributeToAccessControl(short memberAttribute) { |
|
801 int acc = memberAttribute & MEMATTR_ACCESS_MASK; |
|
802 switch (acc) { |
|
803 case MEMATTR_ACCESS_NO_PROTECTION: return NO_PROTECTION; |
|
804 case MEMATTR_ACCESS_PRIVATE: return PRIVATE; |
|
805 case MEMATTR_ACCESS_PROTECTED: return PROTECTED; |
|
806 case MEMATTR_ACCESS_PUBLIC: return PUBLIC; |
|
807 default: throw new RuntimeException("Should not reach here"); |
|
808 } |
|
809 } |
|
810 |
|
811 private void addLocalToCurBlock(LocalSym local) { |
|
812 ((BasicBlockSym) blockStack.peek()).addLocal(local); |
|
813 } |
|
814 |
|
815 private void addGlobalSym(GlobalSym sym) { |
|
816 db.addGlobalSym(sym); |
|
817 } |
|
818 |
|
819 private void skipTypeRecord() { |
|
820 while (!iter.typeStringDone()) { |
|
821 iter.typeStringNext(); |
|
822 } |
|
823 } |
|
824 } |
|