Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/DebugVC50TypeIterator.java @ 3944:35c656d0b685
7090654: nightly failures after 7086585
Reviewed-by: kvn
author | never |
---|---|
date | Wed, 14 Sep 2011 13:57:32 -0700 |
parents | c18cbe5936b8 |
children |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 package sun.jvm.hotspot.debugger.win32.coff; | |
26 | |
27 import java.util.NoSuchElementException; | |
28 | |
29 /** <p> Provides iteration-style access to the types in the | |
30 sstGlobalTypes subsection of the VC++ 5.0 debug | |
31 information. Clients should walk down these platform-dependent | |
32 types and transform them into the platform-independent interfaces | |
33 described in the package sun.jvm.hotspot.debugger.csym. </p> | |
34 | |
35 <p> This iterator is a "two-dimensional" iterator; it iterates not | |
36 only over all of the types in the type table, but also iterates | |
37 over the leaf types in the current type string. This structure was | |
38 chosen to avoid constructing a new type iterator for each type in | |
39 the type table because of the expected large number of types. </p> | |
40 */ | |
41 | |
42 public interface DebugVC50TypeIterator { | |
43 // | |
44 // Iteration through type table | |
45 // | |
46 | |
47 /** Indicates whether the iteration through the type table is | |
48 complete. */ | |
49 public boolean done(); | |
50 | |
51 /** Go to the next type in the type table. NOTE that the iterator is | |
52 pointing at the first type initially, so one should use a while | |
53 (!iter.done()) { ... iter.next(); } construct. | |
54 | |
55 @throw NoSuchElementException if the iterator is already done | |
56 and next() is called. */ | |
57 public void next() throws NoSuchElementException; | |
58 | |
59 /** Gets the length, in bytes, of the current type record. */ | |
60 public short getLength(); | |
61 | |
62 /** Gets the type index of the current type. This number is | |
63 compatible with type references in symbols and type records. */ | |
64 public int getTypeIndex(); | |
65 | |
66 /** Debugging support only */ | |
67 public int getNumTypes(); | |
68 | |
69 // | |
70 // Iteration through type strings | |
71 // | |
72 | |
73 /** Indicates whether iteration through the current type string is | |
74 complete. */ | |
75 public boolean typeStringDone(); | |
76 | |
77 /** Goes to the next element in the current type string. NOTE that | |
78 the iterator is pointing at the first type initially, so one | |
79 should use a while (!iter.typeStringDone()) { ... | |
80 iter.typeStringNext(); } construct. | |
81 | |
82 @throw NoSuchElementException if the iterator is already done | |
83 and typeStringNext() is called. */ | |
84 public void typeStringNext() throws NoSuchElementException; | |
85 | |
86 /** Return the leaf index (see {@link | |
87 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeLeafIndices}) | |
88 for the current element of the current type string. */ | |
89 public int typeStringLeaf(); | |
90 | |
91 /** For debugging: returns the file offset of the current type | |
92 string leaf. */ | |
93 public int typeStringOffset(); | |
94 | |
95 // | |
96 // Leaf Indices Referenced from Symbols | |
97 // | |
98 | |
99 /////////////////////////// | |
100 // LF_MODIFIER accessors // | |
101 /////////////////////////// | |
102 | |
103 // This record is used to indicate the const,r volatile and | |
104 // unaligned properties for any particular type. | |
105 | |
106 /** Type index of the modified type. */ | |
107 public int getModifierIndex(); | |
108 | |
109 /** Attributes specified in MODIFIER_ enums in {@link | |
110 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
111 public short getModifierAttribute(); | |
112 | |
113 ////////////////////////// | |
114 // LF_POINTER accessors // | |
115 ////////////////////////// | |
116 | |
117 /** Type index of object pointed to. */ | |
118 public int getPointerType(); | |
119 | |
120 /** Pointer attributes. Consists of seven bit fields whose | |
121 enumerants are in {@link | |
122 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}: | |
123 PTRTYPE, PTRMODE, ISFLAT32, VOLATILE, CONST, UNALIGNED, and | |
124 RESTRICT. */ | |
125 public int getPointerAttributes(); | |
126 | |
127 /** Only valid if the pointer type is BASED_ON_TYPE; retrieves index | |
128 of type. */ | |
129 public int getPointerBasedOnTypeIndex(); | |
130 | |
131 /** Only valid if the pointer type is BASED_ON_TYPE; retrieves name | |
132 of type. */ | |
133 public String getPointerBasedOnTypeName(); | |
134 | |
135 /** Only valid if the pointer mode is either PTR_TO_DATA_MEMBER or | |
136 PTR_TO_METHOD; retrieves the type index of the containing | |
137 class. */ | |
138 public int getPointerToMemberClass(); | |
139 | |
140 /** Only valid if the pointer mode is either PTR_TO_DATA_MEMBER or | |
141 PTR_TO_METHOD; retrieves the data format of the pointer in | |
142 memory. See the PTR_FORMAT enum in {@link | |
143 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
144 public short getPointerToMemberFormat(); | |
145 | |
146 //////////////////////// | |
147 // LF_ARRAY accessors // | |
148 //////////////////////// | |
149 | |
150 /** Type index of each array element. */ | |
151 public int getArrayElementType(); | |
152 | |
153 /** Type index of indexing variable. */ | |
154 public int getArrayIndexType(); | |
155 | |
156 /** Length of the array in bytes. */ | |
157 public int getArrayLength() throws DebugVC50WrongNumericTypeException; | |
158 | |
159 /** Length-prefixed name of array. */ | |
160 public String getArrayName(); | |
161 | |
162 ///////////////////////////////////////// | |
163 // LF_CLASS and LF_STRUCTURE accessors // | |
164 ///////////////////////////////////////// | |
165 | |
166 /** Number of elements in the class or structure. This count | |
167 includes direct, virtual, and indirect virtual bases, and | |
168 methods including overloads, data members, static data members, | |
169 friends, and so on. */ | |
170 public short getClassCount(); | |
171 | |
172 /** Property bit field; see PROPERTY_ enumeration in {@link | |
173 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
174 public short getClassProperty(); | |
175 | |
176 /** Type index of the field list for this class. */ | |
177 public int getClassFieldList(); | |
178 | |
179 /** Get new iterator pointing at the field list of this class. */ | |
180 public DebugVC50TypeIterator getClassFieldListIterator(); | |
181 | |
182 /** Type index of the derivation list. This is output by the | |
183 compiler as 0x0000 and is filled in by the CVPACK utility to a | |
184 LF_DERIVED record containing the type indices of those classes | |
185 which immediately inherit the current class. A zero index | |
186 indicates that no derivation information is available. A LF_NULL | |
187 index indicates that the class is not inherited by other | |
188 classes. */ | |
189 public int getClassDerivationList(); | |
190 | |
191 /** Type index of the virtual function table shape descriptor. */ | |
192 public int getClassVShape(); | |
193 | |
194 /** Numeric leaf specifying size in bytes of the structure. */ | |
195 public int getClassSize() throws DebugVC50WrongNumericTypeException; | |
196 | |
197 /** Length-prefixed name of this type. */ | |
198 public String getClassName(); | |
199 | |
200 //////////////////////// | |
201 // LF_UNION accessors // | |
202 //////////////////////// | |
203 | |
204 /** Number of fields in the union. */ | |
205 public short getUnionCount(); | |
206 | |
207 /** Property bit field. */ | |
208 public short getUnionProperty(); | |
209 | |
210 /** Type index of field list. */ | |
211 public int getUnionFieldList(); | |
212 | |
213 /** Get new iterator pointing at the field list of this union. */ | |
214 public DebugVC50TypeIterator getUnionFieldListIterator(); | |
215 | |
216 /** Numeric leaf specifying size in bytes of the union. */ | |
217 public int getUnionSize() throws DebugVC50WrongNumericTypeException; | |
218 | |
219 /** Length-prefixed name of union. */ | |
220 public String getUnionName(); | |
221 | |
222 /////////////////////// | |
223 // LF_ENUM accessors // | |
224 /////////////////////// | |
225 | |
226 /** Number of enumerates. */ | |
227 public short getEnumCount(); | |
228 | |
229 /** Property bit field. */ | |
230 public short getEnumProperty(); | |
231 | |
232 /** Index of underlying type of enum. */ | |
233 public int getEnumType(); | |
234 | |
235 /** Type index of field list. */ | |
236 public int getEnumFieldList(); | |
237 | |
238 /** Get new iterator pointing at the field list of this enum. */ | |
239 public DebugVC50TypeIterator getEnumFieldListIterator(); | |
240 | |
241 /** Length-prefixed name of enum. */ | |
242 public String getEnumName(); | |
243 | |
244 //////////////////////////// | |
245 // LF_PROCEDURE accessors // | |
246 //////////////////////////// | |
247 | |
248 /** Type index of the value returned by the procedure. */ | |
249 public int getProcedureReturnType(); | |
250 | |
251 /** Calling convention of the procedure; see CALLCONV_ enumeration | |
252 in {@link | |
253 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
254 public byte getProcedureCallingConvention(); | |
255 | |
256 /** Number of parameters. */ | |
257 public short getProcedureNumberOfParameters(); | |
258 | |
259 /** Type index of argument list type record. */ | |
260 public int getProcedureArgumentList(); | |
261 | |
262 /** Get new iterator pointing at the argument list of this procedure. */ | |
263 public DebugVC50TypeIterator getProcedureArgumentListIterator(); | |
264 | |
265 //////////////////////////// | |
266 // LF_MFUNCTION accessors // | |
267 //////////////////////////// | |
268 | |
269 /** Type index of the value returned by the procedure. */ | |
270 public int getMFunctionReturnType(); | |
271 | |
272 /** Type index of the containing class of the function. */ | |
273 public int getMFunctionContainingClass(); | |
274 | |
275 /** Type index of the <b>this</b> parameter of the member function. | |
276 A type of void indicates that the member function is static and | |
277 has no <b>this</b> parameter. */ | |
278 public int getMFunctionThis(); | |
279 | |
280 /** Calling convention of the procedure; see CALLCONV_ enumeration | |
281 in {@link | |
282 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
283 public byte getMFunctionCallingConvention(); | |
284 | |
285 /** Number of parameters. This count does not include the | |
286 <b>this</b> parameter. */ | |
287 public short getMFunctionNumberOfParameters(); | |
288 | |
289 /** List of parameter specifiers. This list does not include the | |
290 <b>this</b> parameter. */ | |
291 public int getMFunctionArgumentList(); | |
292 | |
293 /** Get new iterator pointing at the argument list of this member function. */ | |
294 public DebugVC50TypeIterator getMFunctionArgumentListIterator(); | |
295 | |
296 /** Logical <b>this</b> adjustor for the method. Whenever a class | |
297 element is referenced via the <b>this</b> pointer, thisadjust | |
298 will be added to the resultant offset before referencing the | |
299 element. */ | |
300 public int getMFunctionThisAdjust(); | |
301 | |
302 ////////////////////////// | |
303 // LF_VTSHAPE accessors // | |
304 ////////////////////////// | |
305 | |
306 // This record describes the format of a virtual function table. | |
307 // This record is accessed via the vfunctabptr in the member list of | |
308 // the class which introduces the virtual function. The vfunctabptr | |
309 // is defined either by the LF_VFUNCTAB or LF_VFUNCOFF member | |
310 // record. If LF_VFUNCTAB record is used, then vfunctabptr is at the | |
311 // address point of the class. If LF_VFUNCOFF record is used, then | |
312 // vfunctabptr is at the specified offset from the class address | |
313 // point. The underlying type of the pointer is a VTShape type | |
314 // record. This record describes how to interpret the memory at the | |
315 // location pointed to by the virtual function table pointer. | |
316 | |
317 /** Number of descriptors. */ | |
318 public short getVTShapeCount(); | |
319 | |
320 /** Fetch the <i>i</i>th descriptor (0..getVTShapeCount() - 1). Each | |
321 descriptor is a 4-bit (half-byte) value described by the | |
322 VTENTRY_ enumeration in {@link | |
323 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
324 public int getVTShapeDescriptor(int i); | |
325 | |
326 // | |
327 // NOTE: LF_COBOL0, LF_COBOL1 accessors elided (FIXME) | |
328 // | |
329 | |
330 ///////////////////////// | |
331 // LF_BARRAY accessors // | |
332 ///////////////////////// | |
333 | |
334 /** Type of each element of the array. */ | |
335 public int getBasicArrayType(); | |
336 | |
337 //////////////////////// | |
338 // LF_LABEL accessors // | |
339 //////////////////////// | |
340 | |
341 /** Addressing mode of the label, described by LABEL_ADDR_MODE_ enum | |
342 in {@link | |
343 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ | |
344 public short getLabelAddressMode(); | |
345 | |
346 // | |
347 // LF_NULL, LF_NOTTRANS have no data | |
348 // | |
349 | |
350 /////////////////////////// | |
351 // LF_DIMARRAY accessors // | |
352 /////////////////////////// | |
353 | |
354 /** Underlying type of the array. */ | |
355 public int getDimArrayType(); | |
356 | |
357 /** Index of the type record containing the dimension information. */ | |
358 public int getDimArrayDimInfo(); | |
359 | |
360 /** Length-prefixed name of the array. */ | |
361 public String getDimArrayName(); | |
362 | |
363 ////////////////////////// | |
364 // LF_VFTPATH accessors // | |
365 ////////////////////////// | |
366 | |
367 /** Count of number of bases in the path to the virtual function | |
368 table. */ | |
369 public int getVFTPathCount(); | |
370 | |
371 /** Type indices of the base classes in the path | |
372 (0..getVFTPathCount() - 1). */ | |
373 public int getVFTPathBase(int i); | |
374 | |
375 // | |
376 // NOTE: LF_PRECOMP and LF_ENDPRECOMP accessors elided because the | |
377 // signature contained within is extremely compiler-specific and is | |
378 // left undefined in the specification, so is not useful. (FIXME) | |
379 // | |
380 | |
381 // | |
382 // NOTE: LF_OEM accessors elided because we will not need to parse | |
383 // vendor-specific debug information (yet). (FIXME) | |
384 // | |
385 | |
386 // | |
387 // NOTE: LF_TYPESERVER accessors elided because we will not be using | |
388 // this library in conjunction with a program database. (FIXME) | |
389 // | |
390 | |
391 // | |
392 // Type Records Referenced from Type Records | |
393 // | |
394 | |
395 /////////////////////// | |
396 // LF_SKIP accessors // | |
397 /////////////////////// | |
398 | |
399 /** In processing $$TYPES, the index counter is advanced to index | |
400 count, skipping all intermediate indices. This is the next valid | |
401 index. */ | |
402 public int getSkipIndex(); | |
403 | |
404 ////////////////////////// | |
405 // LF_ARGLIST accessors // | |
406 ////////////////////////// | |
407 | |
408 /** Count of number of indices in list. */ | |
409 public int getArgListCount(); | |
410 | |
411 /** List of type indices (0..getArgListCount() - 1) for describing | |
412 the formal parameters to a function or method. */ | |
413 public int getArgListType(int i); | |
414 | |
415 ///////////////////////// | |
416 // LF_DEFARG accessors // | |
417 ///////////////////////// | |
418 | |
419 /** Type index of resulting expression. */ | |
420 public int getDefaultArgType(); | |
421 | |
422 /** Length-prefixed string of supplied default expression. */ | |
423 public String getDefaultArgExpression(); | |
424 | |
425 // | |
426 // Field list accessors (LF_FIELDLIST) | |
427 // | |
428 // No explicit accessors for the field list. The field list is | |
429 // structured similarly to most type strings; it is a series of | |
430 // leaves. LF_INDEX leaves are used to split the field list if it | |
431 // gets long enough that it will cross a 48K boundary; LF_PAD leaves | |
432 // are used to enforce proper alignment. Both of these leaves, and | |
433 // their lengths, are understood by this iterator, and LF_INDEX | |
434 // leaves have an accessor for reaching the target type record. | |
435 // | |
436 | |
437 ////////////////////////// | |
438 // LF_DERIVED accessors // | |
439 ////////////////////////// | |
440 | |
441 // This type record specifies all of the classes that are directly | |
442 // derived from the class that references this type record. | |
443 | |
444 /** Number of types in the list. */ | |
445 public int getDerivedCount(); | |
446 | |
447 /** Fetch <i>i</i>th derived type (0..getDerivedCount() - 1). */ | |
448 public int getDerivedType(int i); | |
449 | |
450 /////////////////////////// | |
451 // LF_BITFIELD accessors // | |
452 /////////////////////////// | |
453 | |
454 // Bit fields are represented by an entry in the field list that | |
455 // indexes a bit field type definition. | |
456 | |
457 /** Type index of the field. */ | |
458 public int getBitfieldFieldType(); | |
459 | |
460 /** The length in bits of the object. */ | |
461 public byte getBitfieldLength(); | |
462 | |
463 /** Starting position (from bit 0) of the object in the word. */ | |
464 public byte getBitfieldPosition(); | |
465 | |
466 //////////////////////// | |
467 // LF_MLIST accessors // | |
468 //////////////////////// | |
469 | |
470 // This record is typically used to describe overloaded methods, | |
471 // though it can also be used (inefficiently) to describe a single | |
472 // method. It is referenced from the LF_METHOD record. The "count" | |
473 // is not really contained in this record; it is contained within | |
474 // the LF_METHOD record which points to this one. However, it seems | |
475 // it can be inferred from the length of this type string as the | |
476 // only repeated portion of the record is the type of each | |
477 // overloaded variant. | |
478 // | |
479 // Once a method has been found in this list, its symbol is found by | |
480 // qualifying the method name with its class (T::name) and then | |
481 // searching the symbol table for a symbol by that name with the | |
482 // correct type index. Note that the number of repeats is determined | |
483 // by the subleaf of the field list that references this LF_MLIST | |
484 // record. | |
485 | |
486 /** Attribute of the member function; see {@link | |
487 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums} and {@link | |
488 sun.jvm.hotspot.debugger.win32.coff.DebugVC50MemberAttributes}. */ | |
489 public short getMListAttribute(); | |
490 | |
491 /** Number of types corresponding to this overloaded method. FIXME: | |
492 must verify this can be inferred solely from this record's | |
493 length. */ | |
494 public int getMListLength(); | |
495 | |
496 /** Type index of the procedure record for the <i>i</i>th occurrence | |
497 of the function (0..getMListLength() - 1). */ | |
498 public int getMListType(int i); | |
499 | |
500 /** Convenience routine indicating whether this member function is | |
501 introducing virtual. */ | |
502 public boolean isMListIntroducingVirtual(); | |
503 | |
504 /** Present only when property attribute is introducing virtual | |
505 (optional). Offset in vtable of the class which contains the | |
506 pointer to the function. (FIXME: is this on a per-method or | |
507 per-method list basis? If the latter, will have to provide an | |
508 iterator for this record.) */ | |
509 public int getMListVtabOffset(); | |
510 | |
511 // | |
512 // NOTE: LF_DIMCONU, LF_DIMCONLU, LF_DIMVARU, and LF_DIMVARLU | |
513 // accessors elided as these are very likely Fortran-specific | |
514 // (FIXME?) | |
515 // | |
516 | |
517 ///////////////////////// | |
518 // LF_REFSYM accessors // | |
519 ///////////////////////// | |
520 | |
521 // This record is used to describe a symbol that is referenced by a | |
522 // type record. The record is defined because type records cannot | |
523 // reference symbols or locations in the $$SYMBOLS table because | |
524 // global symbol compaction will move symbols. | |
525 | |
526 /** Create a new SymbolIterator pointing at the copy of the symbol | |
527 this record contains. */ | |
528 public DebugVC50SymbolIterator getRefSym(); | |
529 | |
530 // | |
531 // Subfields of complex lists | |
532 // | |
533 | |
534 ///////////////////////// | |
535 // LF_BCLASS accessors // | |
536 ///////////////////////// | |
537 | |
538 // This leaf specifies a real base class. If a class inherits real | |
539 // base classes, the corresponding REAL Base Class records will | |
540 // precede all other member records in the field list of that | |
541 // class. Base class records are emitted in left to right | |
542 // declaration order for real bases. | |
543 | |
544 /** Member attribute bit field. */ | |
545 public short getBClassAttribute(); | |
546 | |
547 /** Index to type record of the class. The class name can be | |
548 obtained from this record. */ | |
549 public int getBClassType(); | |
550 | |
551 /** Offset of subobject that represents the base class within the | |
552 structure. */ | |
553 public int getBClassOffset() throws DebugVC50WrongNumericTypeException; | |
554 | |
555 ////////////////////////// | |
556 // LF_VBCLASS accessors // | |
557 ////////////////////////// | |
558 | |
559 // This leaf specifies a directly inherited virtual base class. If a | |
560 // class directly inherits virtual base classes, the corresponding | |
561 // Direct Virtual BaseClass records will follow all Real Base Class | |
562 // member records and precede all other member records in the field | |
563 // list of that class. Direct Virtual Base class records are emitted | |
564 // in bottommost left-to-right inheritance order for directly | |
565 // inherited virtual bases. | |
566 | |
567 /** Member attribute bit field. */ | |
568 public short getVBClassAttribute(); | |
569 | |
570 /** Index to type record of the direct or indirect virtual base | |
571 class. The class name can be obtained from this record. */ | |
572 public int getVBClassBaseClassType(); | |
573 | |
574 /** Type index of the virtual base pointer for this base. */ | |
575 public int getVBClassVirtualBaseClassType(); | |
576 | |
577 /** Numeric leaf specifying the offset of the virtual base pointer | |
578 from the address point of the class for this virtual base. */ | |
579 public int getVBClassVBPOff() throws DebugVC50WrongNumericTypeException; | |
580 | |
581 /** Numeric leaf specifying the index into the virtual base | |
582 displacement table of the entry that contains the displacement | |
583 of the virtual base. The displacement is relative to the address | |
584 point of the class plus vbpoff. */ | |
585 public int getVBClassVBOff() throws DebugVC50WrongNumericTypeException; | |
586 | |
587 /////////////////////////// | |
588 // LF_IVBCLASS accessors // | |
589 /////////////////////////// | |
590 | |
591 // This leaf specifies indirectly inherited virtual base class. If a | |
592 // class indirectly inherits virtual base classes, the corresponding | |
593 // Indirect Virtual Base Class records will follow all Real Base | |
594 // Class and Direct Virtual Base Class member records and precede | |
595 // all other member records in the field list of that class. Direct | |
596 // Virtual Base class records are emitted in bottommost | |
597 // left-to-right inheritance order for virtual bases. | |
598 | |
599 /** Member attribute bit field. */ | |
600 public short getIVBClassAttribute(); | |
601 | |
602 /** Index to type record of the direct or indirect virtual base | |
603 class. The class name can be obtained from this record. */ | |
604 public int getIVBClassBType(); | |
605 | |
606 /** Type index of the virtual base pointer for this base. */ | |
607 public int getIVBClassVBPType(); | |
608 | |
609 /** Numeric leaf specifying the offset of the virtual base pointer | |
610 from the address point of the class for this virtual base. */ | |
611 public int getIVBClassVBPOff() throws DebugVC50WrongNumericTypeException; | |
612 | |
613 /** Numeric leaf specifying the index into the virtual base | |
614 displacement table of the entry that contains the displacement | |
615 of the virtual base. The displacement is relative to the address | |
616 point of the class plus vbpoff. */ | |
617 public int getIVBClassVBOff() throws DebugVC50WrongNumericTypeException; | |
618 | |
619 //////////////////////////// | |
620 // LF_ENUMERATE accessors // | |
621 //////////////////////////// | |
622 | |
623 /** Member attribute bit field. */ | |
624 public short getEnumerateAttribute(); | |
625 | |
626 /** Numeric leaf specifying the value of enumerate. */ | |
627 public long getEnumerateValue() throws DebugVC50WrongNumericTypeException; | |
628 | |
629 /** Length-prefixed name of the member field. */ | |
630 public String getEnumerateName(); | |
631 | |
632 //////////////////////////// | |
633 // LF_FRIENDFCN accessors // | |
634 //////////////////////////// | |
635 | |
636 /** Index to type record of the friend function. */ | |
637 public int getFriendFcnType(); | |
638 | |
639 /** Length prefixed name of friend function. */ | |
640 public String getFriendFcnName(); | |
641 | |
642 //////////////////////// | |
643 // LF_INDEX accessors // | |
644 //////////////////////// | |
645 | |
646 /** Type index. This field is emitted by the compiler when a complex | |
647 list needs to be split during writing. */ | |
648 public int getIndexValue(); | |
649 | |
650 /** Create a new type iterator starting at the above index. */ | |
651 public DebugVC50TypeIterator getIndexIterator(); | |
652 | |
653 ///////////////////////// | |
654 // LF_MEMBER accessors // | |
655 ///////////////////////// | |
656 | |
657 /** Member attribute bit field. */ | |
658 public short getMemberAttribute(); | |
659 | |
660 /** Index to type record for field. */ | |
661 public int getMemberType(); | |
662 | |
663 /** Numeric leaf specifying the offset of field in the structure. */ | |
664 public int getMemberOffset() throws DebugVC50WrongNumericTypeException; | |
665 | |
666 /** Length-prefixed name of the member field. */ | |
667 public String getMemberName(); | |
668 | |
669 /////////////////////////// | |
670 // LF_STMEMBER accessors // | |
671 /////////////////////////// | |
672 | |
673 // This leaf specifies a static data member of a class. Once a | |
674 // static data member has been found in this list, its symbol is | |
675 // found by qualifying the name with its class (T::name) and then | |
676 // searching the symbol table for a symbol by that name with the | |
677 // correct type index. | |
678 | |
679 /** Member attribute bit field. */ | |
680 public short getStaticAttribute(); | |
681 | |
682 /** Index to type record for field. */ | |
683 public int getStaticType(); | |
684 | |
685 /** Length-prefixed name of the member field. */ | |
686 public String getStaticName(); | |
687 | |
688 ///////////////////////// | |
689 // LF_METHOD accessors // | |
690 ///////////////////////// | |
691 | |
692 // This leaf specifies the overloaded member functions of a class. | |
693 // This type record can also be used to specify a non-overloaded | |
694 // method but is inefficient. The LF_ONEMETHOD record should be used | |
695 // for non-overloaded methods. | |
696 | |
697 /** Number of occurrences of function within the class. If the | |
698 function is overloaded then there will be multiple entries in | |
699 the method list. */ | |
700 public short getMethodCount(); | |
701 | |
702 /** Type index of method list. */ | |
703 public int getMethodList(); | |
704 | |
705 /** Length-prefixed name of method. */ | |
706 public String getMethodName(); | |
707 | |
708 ///////////////////////////// | |
709 // LF_NESTEDTYPE accessors // | |
710 ///////////////////////////// | |
711 | |
712 /** Type index of nested type. */ | |
713 public int getNestedType(); | |
714 | |
715 /** Length-prefixed name of type. */ | |
716 public String getNestedName(); | |
717 | |
718 /////////////////////////// | |
719 // LF_VFUNCTAB accessors // | |
720 /////////////////////////// | |
721 | |
722 // This leaf specifies virtual table pointers within the class. It | |
723 // is a requirement that this record be emitted in the field list | |
724 // before any virtual functions are emitted to the field list. | |
725 | |
726 /** Index to the pointer record describing the pointer. The pointer | |
727 will in turn have a LF_VTSHAPE type record as the underlying | |
728 type. Note that the offset of the virtual function table pointer | |
729 from the address point of the class is always zero. */ | |
730 public int getVFuncTabType(); | |
731 | |
732 //////////////////////////// | |
733 // LF_FRIENDCLS accessors // | |
734 //////////////////////////// | |
735 | |
736 /** Index to type record of the friend class. The name of the class | |
737 can be obtained from the referenced record. */ | |
738 public int getFriendClsType(); | |
739 | |
740 //////////////////////////// | |
741 // LF_ONEMETHOD accessors // | |
742 //////////////////////////// | |
743 | |
744 /** Method attribute; see {@link | |
745 sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums} and | |
746 {@link | |
747 sun.jvm.hotspot.debugger.win32.coff.DebugVC50MemberAttributes}. */ | |
748 public short getOneMethodAttribute(); | |
749 | |
750 /** Type index of method. */ | |
751 public int getOneMethodType(); | |
752 | |
753 /** Convenience routine indicating whether this method is | |
754 introducing virtual. */ | |
755 public boolean isOneMethodIntroducingVirtual(); | |
756 | |
757 /** Offset in virtual function table if introducing virtual method. | |
758 If the method is not an introducing virtual, then this field is | |
759 not present. */ | |
760 public int getOneMethodVBaseOff(); | |
761 | |
762 /** Length prefixed name of method. */ | |
763 public String getOneMethodName(); | |
764 | |
765 /////////////////////////// | |
766 // LF_VFUNCOFF accessors // | |
767 /////////////////////////// | |
768 | |
769 // This record is used to specify a virtual function table pointer | |
770 // at a non-zero offset relative to the address point of a class. | |
771 | |
772 /** Type index of virtual function table pointer. */ | |
773 public int getVFuncOffType(); | |
774 | |
775 /** Offset of virtual function table pointer relative to address | |
776 point of class. */ | |
777 public int getVFuncOffOffset(); | |
778 | |
779 /////////////////////////////// | |
780 // LF_NESTEDTYPEEX accessors // | |
781 /////////////////////////////// | |
782 | |
783 // This leaf specifies nested type definition with classes, | |
784 // structures, unions, or enums and includes the protection | |
785 // attributes that are missing in LF_NESTEDTYPE. | |
786 | |
787 /** Nested type attribute (protection fields are valid). */ | |
788 public short getNestedExAttribute(); | |
789 | |
790 /** Type index of nested type. */ | |
791 public int getNestedExType(); | |
792 | |
793 /** Length-prefixed name of type. */ | |
794 public String getNestedExName(); | |
795 | |
796 /////////////////////////////// | |
797 // LF_MEMBERMODIFY accessors // | |
798 /////////////////////////////// | |
799 | |
800 /** New protection attributes. */ | |
801 public short getMemberModifyAttribute(); | |
802 | |
803 /** Type index of base class that introduced the member. */ | |
804 public int getMemberModifyType(); | |
805 | |
806 /** Length-prefixed name of member. */ | |
807 public String getMemberModifyName(); | |
808 | |
809 //////////////////////////// | |
810 // Numeric Leaf accessors // | |
811 //////////////////////////// | |
812 | |
813 /** Fetch the two-byte type (or data, for short integer numeric | |
814 leaves) of the numeric leaf at the given offset, in bytes, from | |
815 the start of the current leaf. */ | |
816 public short getNumericTypeAt(int byteOffset); | |
817 | |
818 /** The size in bytes of the numeric leaf at the given offset, in | |
819 bytes, from the start of the current leaf. | |
820 | |
821 @throw DebugVC50WrongNumericTypeException if there is no numeric | |
822 leaf at the specified byte offset. */ | |
823 public int getNumericLengthAt(int byteOffset) | |
824 throws DebugVC50WrongNumericTypeException; | |
825 | |
826 /** Fetch the value of the integer numeric leaf at the given offset, | |
827 in bytes, from the start of the current leaf. | |
828 | |
829 @throw DebugVC50WrongNumericTypeException if the specified | |
830 numeric leaf is not of integer type. */ | |
831 public int getNumericIntAt(int byteOffset) | |
832 throws DebugVC50WrongNumericTypeException; | |
833 | |
834 /** Fetch the value of the long or integer numeric leaf at the given | |
835 offset, in bytes, from the start of the current leaf. | |
836 | |
837 @throw DebugVC50WrongNumericTypeException if the specified | |
838 numeric leaf is not of long or integer type. */ | |
839 public long getNumericLongAt(int byteOffset) | |
840 throws DebugVC50WrongNumericTypeException; | |
841 | |
842 /** Fetch the value of the single-precision floating-point numeric | |
843 leaf at the given offset, in bytes, from the start of the | |
844 current leaf. | |
845 | |
846 @throw DebugVC50WrongNumericTypeException if the specified | |
847 numeric leaf is not of 32-bit float type. */ | |
848 public float getNumericFloatAt(int byteOffset) | |
849 throws DebugVC50WrongNumericTypeException; | |
850 | |
851 /** Fetch the value of the double-precision floating-point numeric | |
852 leaf at the given offset, in bytes, from the start of the | |
853 current leaf. | |
854 | |
855 @throw DebugVC50WrongNumericTypeException if the specified | |
856 numeric leaf is not of 64-bit float type. */ | |
857 public double getNumericDoubleAt(int byteOffset) | |
858 throws DebugVC50WrongNumericTypeException; | |
859 | |
860 /** Fetch the raw bytes, including LF_ prefix (if any), of the | |
861 numeric leaf at the given offset, in bytes, from the start of | |
862 the current leaf. | |
863 | |
864 @throw DebugVC50WrongNumericTypeException if there is no numeric | |
865 leaf at the specified byte offset. */ | |
866 public byte[] getNumericDataAt(int byteOffset) | |
867 throws DebugVC50WrongNumericTypeException; | |
868 } |