Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/DebugVC50SymbolIterator.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.*; | |
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 } |