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.*;
|
|
28
|
|
29 /** Provides iteration-style access to the symbols in the sstGlobalSym
|
|
30 (and possibly other) subsections of the VC++ 5.0 debug
|
|
31 information. Clients should walk down these platform-dependent
|
|
32 symbols and transform them into the platform-independent
|
|
33 interfaces described in the package sun.jvm.hotspot.debugger.csym. */
|
|
34
|
|
35 public interface DebugVC50SymbolIterator
|
|
36 extends DebugVC50SymbolTypes, DebugVC50SymbolEnums {
|
|
37
|
|
38 /** Indicates whether this iterator has processed all of the
|
|
39 available symbols. */
|
|
40 public boolean done();
|
|
41
|
|
42 /** Go to the next symbol. NOTE that the iterator is pointing at the
|
|
43 first symbol initially, so one should use a while (!iter.done())
|
|
44 { ... iter.next(); } construct.
|
|
45
|
|
46 @throw NoSuchElementException if the iterator is already done
|
|
47 and next() is called. */
|
|
48 public void next() throws NoSuchElementException;
|
|
49
|
|
50 /** Length of record, in bytes, excluding the length field. */
|
|
51 public short getLength();
|
|
52
|
|
53 /** The type enumeration is defined in {@link
|
|
54 sun.jvm.hotspot.debugger.win32.coff.DebugVC50SymbolTypes} */
|
|
55 public int getType();
|
|
56
|
|
57 /** For debugging: returns the file offset of the current symbol. */
|
|
58 public int getOffset();
|
|
59
|
|
60 /////////////////////////
|
|
61 // S_COMPILE accessors //
|
|
62 /////////////////////////
|
|
63
|
|
64 /** Machine enumeration specifying target processor; see
|
|
65 DebugVC50SymbolEnums. */
|
|
66 public byte getCompilerTargetProcessor();
|
|
67
|
|
68 /** Compile flags; see DebugVC50SymbolEnums. */
|
|
69 public int getCompilerFlags();
|
|
70
|
|
71 /** Length-prefixed string specifying language processor version.
|
|
72 Language processors can place additional data in version string
|
|
73 if desired. */
|
|
74 public String getComplierVersion();
|
|
75
|
|
76 //////////////////////////
|
|
77 // S_REGISTER accessors //
|
|
78 //////////////////////////
|
|
79
|
|
80 /** Type of the symbol which is in the register */
|
|
81 public int getRegisterSymbolType();
|
|
82
|
|
83 /** Enumerate of the registers in which the symbol is stored. The
|
|
84 high and low bytes are treated independently for values split
|
|
85 across two registers (i.e., 64-bit values on a 32-bit machine.) */
|
|
86 public short getRegisterEnum();
|
|
87
|
|
88 /** Length-prefixed name of the symbol stored in the register. */
|
|
89 public String getRegisterSymbolName();
|
|
90
|
|
91 // Note: register tracking elided as it is not implemented in the
|
|
92 // Microsoft compilers.
|
|
93
|
|
94 //////////////////////////
|
|
95 // S_CONSTANT accessors //
|
|
96 //////////////////////////
|
|
97
|
|
98 /** Type of symbol or containing enum. This record is used to output
|
|
99 constants and C enumerations. If used to output an enumeration,
|
|
100 then the type index refers to the containing enum. */
|
|
101 public int getConstantType();
|
|
102
|
|
103 /** Numeric leaf containing the value of the symbol as an int */
|
|
104 public int getConstantValueAsInt() throws DebugVC50WrongNumericTypeException;
|
|
105
|
|
106 /** Numeric leaf containing the value of the symbol as a long */
|
|
107 public long getConstantValueAsLong() throws DebugVC50WrongNumericTypeException;
|
|
108
|
|
109 /** Numeric leaf containing the value of the symbol as a float */
|
|
110 public float getConstantValueAsFloat() throws DebugVC50WrongNumericTypeException;
|
|
111
|
|
112 /** Numeric leaf containing the value of the symbol as a double */
|
|
113 public double getConstantValueAsDouble() throws DebugVC50WrongNumericTypeException;
|
|
114
|
|
115 /** Length-prefixed name of the symbol */
|
|
116 public String getConstantName();
|
|
117
|
|
118 /////////////////////
|
|
119 // S_UDT accessors //
|
|
120 /////////////////////
|
|
121
|
|
122 /** Type of symbol. This specifies a C typedef or user-defined type,
|
|
123 such as classes, structures, unions, or enums. */
|
|
124 public int getUDTType();
|
|
125
|
|
126 /** Length-prefixed name of the user defined type. */
|
|
127 public String getUDTName();
|
|
128
|
|
129 /////////////////////////
|
|
130 // S_SSEARCH accessors //
|
|
131 /////////////////////////
|
|
132
|
|
133 // FIXME: Add more documentation and understand what this does
|
|
134
|
|
135 /** $$SYMBOL offset of the procedure or thunk record for this module
|
|
136 that has the lowest offset for the specified segment. */
|
|
137 public int getSearchSymbolOffset();
|
|
138
|
|
139 /** Segment (PE section) that this Start Search refers to. */
|
|
140 public short getSearchSegment();
|
|
141
|
|
142 /////////////////////
|
|
143 // S_END accessors //
|
|
144 /////////////////////
|
|
145
|
|
146 // (No accessors)
|
|
147 // Closes the scope of the nearest preceding Block Start, Global
|
|
148 // Procedure Start, Local Procedure Start, With Start, or Thunk
|
|
149 // Start definition.
|
|
150
|
|
151 //////////////////////
|
|
152 // S_SKIP accessors //
|
|
153 //////////////////////
|
|
154
|
|
155 // (No accessors)
|
|
156 // Use the length field, available in every symbol, to skip over
|
|
157 // these records.
|
|
158
|
|
159 ///////////////////////////
|
|
160 // S_CVRESERVE accessors //
|
|
161 ///////////////////////////
|
|
162
|
|
163 // (No accessors)
|
|
164
|
|
165 /////////////////////////
|
|
166 // S_OBJNAME accessors //
|
|
167 /////////////////////////
|
|
168
|
|
169 /** Signature used to determine whether changes in precompiled types
|
|
170 defined in this module require a recompilation of users of those
|
|
171 types. This does not have much meaning given that the algorithm
|
|
172 for computing the signature is unspecified. */
|
|
173 public int getObjectCodeViewSignature();
|
|
174
|
|
175 /** Length prefixed name of the object file without any path
|
|
176 information prepended to the name. */
|
|
177 public String getObjectName();
|
|
178
|
|
179 ////////////////////////
|
|
180 // S_ENDARG accessors //
|
|
181 ////////////////////////
|
|
182
|
|
183 // (No accessors)
|
|
184
|
|
185 //////////////////////////
|
|
186 // S_COBOLUDT accessors //
|
|
187 //////////////////////////
|
|
188
|
|
189 // (Elided as they are irrelevant)
|
|
190
|
|
191 /////////////////////////
|
|
192 // S_MANYREG accessors //
|
|
193 /////////////////////////
|
|
194
|
|
195 /** Type index of the symbol. This record is used to specify that a
|
|
196 symbol is stored in a set of registers. */
|
|
197 public int getManyRegType();
|
|
198
|
|
199 /** Count of the register enumerates that follow. */
|
|
200 public byte getManyRegCount();
|
|
201
|
|
202 /** Get the <i>i</i>th register (0..getManyRegCount() - 1). The
|
|
203 registers are listed high order register first. */
|
|
204 public byte getManyRegRegister(int i);
|
|
205
|
|
206 /** Name of the symbol. */
|
|
207 public String getManyRegName();
|
|
208
|
|
209 ////////////////////////
|
|
210 // S_RETURN accessors //
|
|
211 ////////////////////////
|
|
212
|
|
213 /** Logical or of FUNCRET_VARARGS_LEFT_TO_RIGHT_MASK (push varargs
|
|
214 left to right if set) and FUNCRET_RETURNEE_STACK_CLEANUP_MASK
|
|
215 (returnee cleans up stack if true). */
|
|
216 public short getReturnFlags();
|
|
217
|
|
218 /** Function return style; see constants in {@link
|
|
219 sun.jvm.hotspot.debugger.win32.coff.DebugVC50SymbolEnums}. */
|
|
220 public byte getReturnStyle();
|
|
221
|
|
222 /** Get count of registers containing return value; only valid for
|
|
223 FUNCRET_IN_REGISTERS return style. */
|
|
224 public byte getReturnRegisterCount();
|
|
225
|
|
226 /** Get <i>i</i>th register (0..getReturnRegisterCount() - 1)
|
|
227 containing return value, high order first; only valid for
|
|
228 FUNCRET_IN_REGISTERS return style. */
|
|
229 public byte getReturnRegister(int i);
|
|
230
|
|
231 ///////////////////////////
|
|
232 // S_ENTRYTHIS accessors //
|
|
233 ///////////////////////////
|
|
234
|
|
235 /** Advance this iterator to the symbol (which actually describes
|
|
236 the <b>this</b> pointer) contained within the S_ENTRYTHIS
|
|
237 symbol. */
|
|
238 public void advanceToEntryThisSymbol();
|
|
239
|
|
240 ///////////////////////////////////////////////////////////////////////
|
|
241 // //
|
|
242 // //
|
|
243 // Symbols for (Intel) 16:32 Segmented and 32-bit Flat Architectures //
|
|
244 // //
|
|
245 // //
|
|
246 ///////////////////////////////////////////////////////////////////////
|
|
247
|
|
248 /////////////////////////
|
|
249 // S_BPREL32 accessors //
|
|
250 /////////////////////////
|
|
251
|
|
252 // This symbol specifies symbols that are allocated on the stack for
|
|
253 // a procedure. For C/C++, these include the actual parameters to a
|
|
254 // function and the local nonstatic variables of functions.
|
|
255
|
|
256 /** Signed offset relative to BP. If 0, then the symbol was assigned
|
|
257 to a register or never instantiated by the optimizer and cannot
|
|
258 be evaluated because its location is unknown. */
|
|
259 public int getBPRelOffset();
|
|
260
|
|
261 /** Type of the symbol. */
|
|
262 public int getBPRelType();
|
|
263
|
|
264 /** Length-prefixed name of the symbol. */
|
|
265 public String getBPRelName();
|
|
266
|
|
267 ///////////////////////////////////////
|
|
268 // S_LDATA32 and S_GDATA32 accessors //
|
|
269 ///////////////////////////////////////
|
|
270
|
|
271 // FIXME: consider documenting this as covering S_PUB32 symbols as
|
|
272 // well
|
|
273
|
|
274 // The formats of S_LDATA32 and S_GDATA32 symbols match; the only
|
|
275 // difference is the type tag.
|
|
276 //
|
|
277 // LDATA32 symbols are used for data that is not exported from a
|
|
278 // module. In C/C++, symbols that are declared static are emitted as
|
|
279 // Local Data symbols. Symbols that are emitted as Local Data cannot
|
|
280 // be moved by CVPACK into the global symbol table for the
|
|
281 // executable file.
|
|
282 //
|
|
283 // GDATA32 records have the same format as the Local Data 16:32
|
|
284 // except that the record type is S_GDATA32. For C/C++, symbols that
|
|
285 // are not specifically declared static are emitted as Global Data
|
|
286 // Symbols and can be compacted by CVPACK into the global symbol
|
|
287 // table.
|
|
288
|
|
289 /** Type index of the symbol. */
|
|
290 public int getLGDataType();
|
|
291
|
|
292 /** Offset portion of the symbol address. */
|
|
293 public int getLGDataOffset();
|
|
294
|
|
295 /** Segment portion of the symbol address. */
|
|
296 public short getLGDataSegment();
|
|
297
|
|
298 /** Length-prefixed name of symbol. */
|
|
299 public String getLGDataName();
|
|
300
|
|
301 ///////////////////////
|
|
302 // S_PUB32 accessors //
|
|
303 ///////////////////////
|
|
304
|
|
305 // FIXME: has the same format as the above; consider updating
|
|
306 // documentation. No separate accessors provided.
|
|
307
|
|
308 ///////////////////////////////////////
|
|
309 // S_LPROC32 and S_GPROC32 accessors //
|
|
310 ///////////////////////////////////////
|
|
311
|
|
312 // LPROC32 and GPROC32 symbols have the same format, differing only
|
|
313 // in the type tag.
|
|
314 //
|
|
315 // The LPROC32 symbol record defines a local (file static) procedure
|
|
316 // definition. For C/C++, functions that are declared static to a
|
|
317 // module are emitted as Local Procedure symbols. Functions not
|
|
318 // specifically declared static are emitted as Global Procedures.
|
|
319 //
|
|
320 // GPROC32 records are used for procedures that are not specifically
|
|
321 // declared static to a module. The format is the same as the Local
|
|
322 // Procedure Start 16:32 symbol.
|
|
323
|
|
324 /** Creates a new symbol iterator pointing to the symbol opening the
|
|
325 enclosing lexical scope of this function (if any); returns null
|
|
326 if there is no enclosing scope. */
|
|
327 public DebugVC50SymbolIterator getLGProcParent();
|
|
328
|
|
329 /** Gets the absolute file offset of the parent symbol, or 0 if
|
|
330 none. This is useful for constructing and resolving types in a
|
|
331 lazy fashion. */
|
|
332 public int getLGProcParentOffset();
|
|
333
|
|
334 /** Creates a new symbol iterator pointing to the block end symbol
|
|
335 terminating the lexical scope, or NULL if there is no containing
|
|
336 lexical scope. */
|
|
337 public DebugVC50SymbolIterator getLGProcEnd();
|
|
338
|
|
339 /** Gets the absolute file offset of the end symbol. This is useful
|
|
340 for constructing and resolving types in a lazy fashion. */
|
|
341 public int getLGProcEndOffset();
|
|
342
|
|
343 /** Creates a new symbol iterator pointing to the next outermost
|
|
344 scope symbol in the segment (if any); returns null if this is
|
|
345 the last outermost scope for the current segment. (See the
|
|
346 documentation for more information.) */
|
|
347 public DebugVC50SymbolIterator getLGProcNext();
|
|
348
|
|
349 /** Gets the absolute file offset of the next symbol, or 0 if none.
|
|
350 This is useful for constructing and resolving types in a lazy
|
|
351 fashion. */
|
|
352 public int getLGProcNextOffset();
|
|
353
|
|
354 /** Length in bytes of this procedure. */
|
|
355 public int getLGProcLength();
|
|
356
|
|
357 /** Offset in bytes from the start of the procedure to the point
|
|
358 where the stack frame has been set up. Parameter and frame
|
|
359 variables can be viewed at this point. */
|
|
360 public int getLGProcDebugStart();
|
|
361
|
|
362 /** Offset in bytes from the start of the procedure to the point
|
|
363 where the procedure is ready to return and has calculated its
|
|
364 return value, if any. Frame and register variables can still be
|
|
365 viewed. */
|
|
366 public int getLGProcDebugEnd();
|
|
367
|
|
368 /** Type of the procedure type record. */
|
|
369 public int getLGProcType();
|
|
370
|
|
371 /** Offset portion of the procedure address. */
|
|
372 public int getLGProcOffset();
|
|
373
|
|
374 /** Segment portion of the procedure address. */
|
|
375 public short getLGProcSegment();
|
|
376
|
|
377 /** Value defined by bitwise or of the the PROCFLAGS enumeration in
|
|
378 {@link
|
|
379 sun.jvm.hotspot.debugger.win32.coff.DebugVC50SymbolEnums}. */
|
|
380 public byte getLGProcFlags();
|
|
381
|
|
382 /** Length-prefixed name of procedure. */
|
|
383 public String getLGProcName();
|
|
384
|
|
385 /////////////////////////
|
|
386 // S_THUNK32 accessors //
|
|
387 /////////////////////////
|
|
388
|
|
389 // This record is used to specify any piece of code that exists
|
|
390 // outside a procedure. It is followed by an End record. The thunk
|
|
391 // record is intended for small code fragments. and a two byte
|
|
392 // length field is sufficient for its intended purpose.
|
|
393
|
|
394 /** Creates a new symbol iterator pointing to the symbol opening the
|
|
395 enclosing lexical scope of this thunk (if any); returns null if
|
|
396 there is no enclosing scope. */
|
|
397 public DebugVC50SymbolIterator getThunkParent();
|
|
398
|
|
399 /** Gets the absolute file offset of the parent symbol, or 0 if
|
|
400 none. This is useful for constructing and resolving types in a
|
|
401 lazy fashion. */
|
|
402 public int getThunkParentOffset();
|
|
403
|
|
404 /** Creates a new symbol iterator pointing to the block end symbol
|
|
405 terminating the lexical scope, or NULL if there is no containing
|
|
406 lexical scope. */
|
|
407 public DebugVC50SymbolIterator getThunkEnd();
|
|
408
|
|
409 /** Gets the absolute file offset of the end symbol. This is useful
|
|
410 for constructing and resolving types in a lazy fashion. */
|
|
411 public int getThunkEndOffset();
|
|
412
|
|
413 /** Creates a new symbol iterator pointing to the next outermost
|
|
414 scope symbol in the segment (if any); returns null if this is
|
|
415 the last outermost scope for the current segment. (See the
|
|
416 documentation for more information.) */
|
|
417 public DebugVC50SymbolIterator getThunkNext();
|
|
418
|
|
419 /** Gets the absolute file offset of the next symbol, or 0 if none.
|
|
420 This is useful for constructing and resolving types in a lazy
|
|
421 fashion. */
|
|
422 public int getThunkNextOffset();
|
|
423
|
|
424 /** Offset portion of the thunk address. */
|
|
425 public int getThunkOffset();
|
|
426
|
|
427 /** Segment portion of the procedure address. */
|
|
428 public short getThunkSegment();
|
|
429
|
|
430 /** Length in bytes of this thunk. */
|
|
431 public short getThunkLength();
|
|
432
|
|
433 /** Ordinal specifying the type of thunk; see THUNK enumeration in
|
|
434 {@link
|
|
435 sun.jvm.hotspot.debugger.win32.coff.DebugVC50SymbolEnums}. */
|
|
436 public byte getThunkType();
|
|
437
|
|
438 /** Length-prefixed name of thunk. */
|
|
439 public String getThunkName();
|
|
440
|
|
441 /** Delta to be added to "this" pointer; only valid if thunk type is
|
|
442 "adjustor". */
|
|
443 public short getThunkAdjustorThisDelta();
|
|
444
|
|
445 /** Length-prefixed name of target function; only valid if thunk type is
|
|
446 "adjustor". */
|
|
447 public String getThunkAdjustorTargetName();
|
|
448
|
|
449 /** Displacement into the virtual table; only valid if thunk type is
|
|
450 "vcall". */
|
|
451 public short getThunkVCallDisplacement();
|
|
452
|
|
453 /** Offset of p-code entry point; only valid if thunk type is
|
|
454 "pcode". */
|
|
455 public int getThunkPCodeOffset();
|
|
456
|
|
457 /** Segment of p-code entry point; only valid if thunk type is
|
|
458 "pcode". */
|
|
459 public short getThunkPCodeSegment();
|
|
460
|
|
461 /////////////////////////
|
|
462 // S_BLOCK32 accessors //
|
|
463 /////////////////////////
|
|
464
|
|
465 // This symbol specifies the start of an inner block of lexically
|
|
466 // scoped symbols. The lexical scope is terminated by a matching
|
|
467 // S_END symbol.
|
|
468
|
|
469 /** Creates a new symbol iterator pointing to the symbol opening the
|
|
470 enclosing lexical scope of this scope (if any); returns null if
|
|
471 there is no enclosing scope. */
|
|
472 public DebugVC50SymbolIterator getBlockParent();
|
|
473
|
|
474 /** Gets the absolute file offset of the parent symbol, or 0 if
|
|
475 none. This is useful for constructing and resolving types in a
|
|
476 lazy fashion. */
|
|
477 public int getBlockParentOffset();
|
|
478
|
|
479 /** Creates a new symbol iterator pointing to the block end symbol
|
|
480 terminating this scope. */
|
|
481 public DebugVC50SymbolIterator getBlockEnd();
|
|
482
|
|
483 /** Gets the absolute file offset of the end symbol. This is useful
|
|
484 for constructing and resolving types in a lazy fashion. */
|
|
485 public int getBlockEndOffset();
|
|
486
|
|
487 /** Length in bytes of the scope of this block. */
|
|
488 public int getBlockLength();
|
|
489
|
|
490 /** Offset portion of the segmented procedure address. */
|
|
491 public int getBlockOffset();
|
|
492
|
|
493 /** Segment portion of the segmented procedure address. */
|
|
494 public short getBlockSegment();
|
|
495
|
|
496 /** Length-prefixed name of the block. */
|
|
497 public String getBlockName();
|
|
498
|
|
499 ////////////////////////
|
|
500 // S_WITH32 accessors //
|
|
501 ////////////////////////
|
|
502
|
|
503 // FIXME: this is a Pascal construct; ignored for now
|
|
504
|
|
505 /////////////////////////
|
|
506 // S_LABEL32 accessors //
|
|
507 /////////////////////////
|
|
508
|
|
509 /** Offset portion of the segmented address of the start of the
|
|
510 block. */
|
|
511 public int getLabelOffset();
|
|
512
|
|
513 /** Segment portion of the segmented address of the start of the
|
|
514 block. */
|
|
515 public short getLabelSegment();
|
|
516
|
|
517 /** Label flags. These are the same as the PROCFLAGS enumeration. */
|
|
518 public byte getLabelFlags();
|
|
519
|
|
520 /** Length prefixed name of label. */
|
|
521 public String getLabelName();
|
|
522
|
|
523 ////////////////////////////
|
|
524 // S_CEXMODEL32 accessors //
|
|
525 ////////////////////////////
|
|
526
|
|
527 // This record is used to notify the debugger that, starting at the
|
|
528 // given code offset and until the address specified by the next
|
|
529 // Change Execution Model record, the execution model is of the
|
|
530 // specified type. The native execution model is assumed in the
|
|
531 // absence of Change Execution Model records.
|
|
532
|
|
533 /** Offset portion of start of the block where the change occurs. */
|
|
534 public int getChangeOffset();
|
|
535
|
|
536 /** Segment portion of start of the block where the change occurs. */
|
|
537 public short getChangeSegment();
|
|
538
|
|
539 /** The execution model, enumerated in EXMODEL constants in {@link
|
|
540 sun.jvm.hotspot.debugger.win32.coff.DebugVC50SymbolEnums}. */
|
|
541 public short getChangeModel();
|
|
542
|
|
543 // FIXME: figure out how to deal with variant (or whether it is
|
|
544 // necessary)
|
|
545
|
|
546 ////////////////////////////
|
|
547 // S_VFTTABLE32 accessors //
|
|
548 ////////////////////////////
|
|
549
|
|
550 // This record is used to describe the base class path for the
|
|
551 // virtual function table descriptor.
|
|
552
|
|
553 /** The type index of the class at the root of the path. */
|
|
554 public int getVTableRoot();
|
|
555
|
|
556 /** Type index of the record describing the base class path from the
|
|
557 root to the leaf class for the virtual function table. */
|
|
558 public int getVTablePath();
|
|
559
|
|
560 /** Offset portion of start of the virtual function table. */
|
|
561 public int getVTableOffset();
|
|
562
|
|
563 /** Segment portion of the virtual function table. */
|
|
564 public short getVTableSegment();
|
|
565
|
|
566 //////////////////////////
|
|
567 // S_REGREL32 accessors //
|
|
568 //////////////////////////
|
|
569
|
|
570 // This symbol specifies symbols that are allocated relative to a
|
|
571 // register.
|
|
572
|
|
573 /** Signed offset relative to register. */
|
|
574 public int getRegRelOffset();
|
|
575
|
|
576 /** Type of the symbol. */
|
|
577 public int getRegRelType();
|
|
578
|
|
579 /** Register enumerates on which the symbol is based. Note that the
|
|
580 register field can specify a pair of register such as ES:EBX. */
|
|
581 public short getRegRelRegister();
|
|
582
|
|
583 /** Length-prefixed name of the symbol. */
|
|
584 public String getRegRelName();
|
|
585
|
|
586 ///////////////////////////////////////////
|
|
587 // S_LTHREAD32 and S_GTHREAD32 accessors //
|
|
588 ///////////////////////////////////////////
|
|
589
|
|
590 // These symbols are used for data declared with the __thread
|
|
591 // storage attribute that is not exported from a module. In C/C++,
|
|
592 // __thread symbols that are declared static are emitted as Local
|
|
593 // Thread Storage 16:32 symbols. Symbols that are emitted as Local
|
|
594 // Thread Storage 16:32 cannot be moved by CVPACK into the global
|
|
595 // symbol table for the executable file. __thread symbols that are
|
|
596 // not specifically declared static are emitted as Global Thread
|
|
597 // Storage 16:32 symbols and can be compacted by CVPACK into the
|
|
598 // global symbol table.
|
|
599
|
|
600 /** Type index. */
|
|
601 public int getLThreadType();
|
|
602
|
|
603 /** Offset into thread local storage. */
|
|
604 public int getLThreadOffset();
|
|
605
|
|
606 /** Segment of thread local storage. */
|
|
607 public short getLThreadSegment();
|
|
608
|
|
609 /** Length prefixed name. */
|
|
610 public String getLThreadName();
|
|
611
|
|
612 // NOTE: accessors for all other kinds of symbols (i.e., MIPS)
|
|
613 // elided for now (FIXME)
|
|
614 }
|