0
|
1 /*
|
|
2 * Copyright 2001 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 * have any questions.
|
|
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 }
|