Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/COFFFileParser.java @ 6842:b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
Summary: Update copyright year to 2012 for relevant files
Reviewed-by: dholmes, coleenp
author | mikael |
---|---|
date | Tue, 09 Oct 2012 10:09:34 -0700 |
parents | d6cd0d55d0b5 |
children |
rev | line source |
---|---|
0 | 1 /* |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
2 * Copyright (c) 2000, 2010, 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.io.*; | |
28 import java.nio.*; | |
29 import java.nio.channels.*; | |
30 import java.util.*; | |
31 | |
32 import sun.jvm.hotspot.utilities.memo.*; | |
33 import sun.jvm.hotspot.utilities.Assert; | |
34 import sun.jvm.hotspot.debugger.DataSource; | |
35 import sun.jvm.hotspot.debugger.MappedByteBufferDataSource; | |
36 | |
37 /** Top-level factory which parses COFF files, including object files, | |
38 Portable Executables and DLLs. Returns {@link | |
39 sun.jvm.hotspot.debugger.win32.coff.COFFFile} objects. This class is a | |
40 singleton. */ | |
41 | |
42 public class COFFFileParser { | |
43 private static COFFFileParser soleInstance; | |
44 | |
45 // Constants from the file format documentation | |
46 private static final int COFF_HEADER_SIZE = 20; | |
47 private static final int SECTION_HEADER_SIZE = 40; | |
48 private static final int SYMBOL_SIZE = 18; | |
49 private static final int RELOCATION_SIZE = 10; | |
50 private static final int LINE_NUMBER_SIZE = 6; | |
51 | |
52 private static final String US_ASCII = "US-ASCII"; | |
53 | |
54 private COFFFileParser() {} | |
55 | |
56 /** This class is a singleton; returns the sole instance. */ | |
57 public static COFFFileParser getParser() { | |
58 if (soleInstance == null) { | |
59 soleInstance = new COFFFileParser(); | |
60 } | |
61 return soleInstance; | |
62 } | |
63 | |
64 public COFFFile parse(String filename) throws COFFException { | |
65 try { | |
66 File file = new File(filename); | |
67 FileInputStream stream = new FileInputStream(file); | |
68 MappedByteBuffer buf = stream.getChannel().map(FileChannel.MapMode.READ_ONLY, | |
69 0, | |
70 file.length()); | |
71 | |
72 // This is pretty confusing. The file format is little-endian | |
73 // and so is the CPU. In order for the multi-byte accessors to | |
74 // work properly we must NOT change the endianness of the | |
75 // MappedByteBuffer. Need to think about this some more and file | |
76 // a bug if there is one. (FIXME) | |
77 // buf.order(ByteOrder.nativeOrder()); | |
78 return parse(new MappedByteBufferDataSource(buf)); | |
79 } catch (FileNotFoundException e) { | |
80 throw new COFFException(e); | |
81 } catch (IOException e) { | |
82 throw new COFFException(e); | |
83 } | |
84 } | |
85 | |
86 public COFFFile parse(DataSource source) throws COFFException { | |
87 return new COFFFileImpl(source); | |
88 } | |
89 | |
90 class COFFFileImpl implements COFFFile { | |
91 private DataSource file; | |
92 private long filePos; | |
93 private boolean isImage; | |
94 private long imageHeaderOffset; | |
95 private MemoizedObject header = new MemoizedObject() { | |
96 public Object computeValue() { | |
97 return new COFFHeaderImpl(); | |
98 } | |
99 }; | |
100 | |
101 COFFFileImpl(DataSource file) throws COFFException { | |
102 this.file = file; | |
103 initialize(); | |
104 } | |
105 | |
106 public boolean isImage() { | |
107 return isImage; | |
108 } | |
109 | |
110 public COFFHeader getHeader() { | |
111 return (COFFHeaderImpl) header.getValue(); | |
112 } | |
113 | |
114 class COFFHeaderImpl implements COFFHeader { | |
115 private short machine; | |
116 private short numberOfSections; | |
117 private int timeDateStamp; | |
118 private int pointerToSymbolTable; | |
119 private int numberOfSymbols; | |
120 private short sizeOfOptionalHeader; | |
121 private short characteristics; | |
122 private MemoizedObject[] sectionHeaders; | |
123 private MemoizedObject[] symbols; | |
124 | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
125 // Init stringTable at decl time since other fields init'ed in the |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
126 // constructor need the String Table. |
0 | 127 private MemoizedObject stringTable = new MemoizedObject() { |
128 public Object computeValue() { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
129 // the String Table follows the Symbol Table |
0 | 130 int ptr = getPointerToSymbolTable(); |
131 if (ptr == 0) { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
132 // no Symbol Table so no String Table |
0 | 133 return new StringTable(0); |
134 } else { | |
135 return new StringTable(ptr + SYMBOL_SIZE * getNumberOfSymbols()); | |
136 } | |
137 } | |
138 }; | |
139 | |
140 COFFHeaderImpl() { | |
141 seek(imageHeaderOffset); | |
142 machine = readShort(); | |
143 numberOfSections = readShort(); | |
144 timeDateStamp = readInt(); | |
145 pointerToSymbolTable = readInt(); | |
146 numberOfSymbols = readInt(); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
147 // String Table can be accessed at this point because |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
148 // pointerToSymbolTable and numberOfSymbols fields are set. |
0 | 149 sizeOfOptionalHeader = readShort(); |
150 characteristics = readShort(); | |
151 | |
152 // Set up section headers | |
153 sectionHeaders = new MemoizedObject[numberOfSections]; | |
154 for (int i = 0; i < numberOfSections; i++) { | |
155 final int secHdrOffset = (int) | |
156 (imageHeaderOffset + COFF_HEADER_SIZE + sizeOfOptionalHeader + i * SECTION_HEADER_SIZE); | |
157 sectionHeaders[i] = new MemoizedObject() { | |
158 public Object computeValue() { | |
159 return new SectionHeaderImpl(secHdrOffset); | |
160 } | |
161 }; | |
162 } | |
163 | |
164 // Set up symbols | |
165 symbols = new MemoizedObject[numberOfSymbols]; | |
166 for (int i = 0; i < numberOfSymbols; i++) { | |
167 final int symbolOffset = pointerToSymbolTable + i * SYMBOL_SIZE; | |
168 symbols[i] = new MemoizedObject() { | |
169 public Object computeValue() { | |
170 return new COFFSymbolImpl(symbolOffset); | |
171 } | |
172 }; | |
173 } | |
174 } | |
175 | |
176 public short getMachineType() { return machine; } | |
177 public short getNumberOfSections() { return numberOfSections; } | |
178 public int getTimeDateStamp() { return timeDateStamp; } | |
179 public int getPointerToSymbolTable() { return pointerToSymbolTable; } | |
180 public int getNumberOfSymbols() { return numberOfSymbols; } | |
181 public short getSizeOfOptionalHeader() { return sizeOfOptionalHeader; } | |
182 public OptionalHeader getOptionalHeader() throws COFFException { | |
183 if (getSizeOfOptionalHeader() == 0) { | |
184 return null; | |
185 } | |
186 return new OptionalHeaderImpl((int) (imageHeaderOffset + COFF_HEADER_SIZE)); | |
187 } | |
188 public short getCharacteristics() { return characteristics; } | |
189 public boolean hasCharacteristic(short characteristic) { | |
190 return ((characteristics & characteristic) != 0); | |
191 } | |
192 public SectionHeader getSectionHeader(int index) { | |
193 // NOTE zero-basing of index | |
194 return (SectionHeader) sectionHeaders[index - 1].getValue(); | |
195 } | |
196 public COFFSymbol getCOFFSymbol(int index) { | |
197 return (COFFSymbol) symbols[index].getValue(); | |
198 } | |
199 public int getNumberOfStrings() { | |
200 return getStringTable().getNum(); | |
201 } | |
202 public String getString(int i) { | |
203 return getStringTable().get(i); | |
204 } | |
205 | |
206 StringTable getStringTable() { return (StringTable) stringTable.getValue(); } | |
207 | |
208 // NOTE: can destroy current seek() position! | |
209 int rvaToFileOffset(int rva) { | |
210 if (rva == 0) return 0; | |
211 // Search for section containing RVA | |
212 for (int i = 1; i <= getNumberOfSections(); i++) { | |
213 SectionHeader sec = getSectionHeader(i); | |
214 int va = sec.getVirtualAddress(); | |
215 int sz = sec.getSize(); | |
216 if ((va <= rva) && (rva < (va + sz))) { | |
217 return sec.getPointerToRawData() + (rva - va); | |
218 } | |
219 } | |
220 throw new COFFException("Unable to find RVA 0x" + | |
221 Integer.toHexString(rva) + | |
222 " in any section"); | |
223 } | |
224 | |
225 class OptionalHeaderImpl implements OptionalHeader { | |
226 private short magic; | |
227 private MemoizedObject standardFields; | |
228 private MemoizedObject windowsSpecificFields; | |
229 private MemoizedObject dataDirectories; | |
230 | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
231 // We use an offset of 2 because OptionalHeaderStandardFieldsImpl doesn't |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
232 // include the 'magic' field. |
0 | 233 private static final int STANDARD_FIELDS_OFFSET = 2; |
234 private static final int PE32_WINDOWS_SPECIFIC_FIELDS_OFFSET = 28; | |
235 private static final int PE32_DATA_DIRECTORIES_OFFSET = 96; | |
236 private static final int PE32_PLUS_WINDOWS_SPECIFIC_FIELDS_OFFSET = 24; | |
237 private static final int PE32_PLUS_DATA_DIRECTORIES_OFFSET = 112; | |
238 | |
239 OptionalHeaderImpl(final int offset) { | |
240 seek(offset); | |
241 magic = readShort(); | |
242 | |
243 final boolean isPE32Plus = (magic == MAGIC_PE32_PLUS); | |
244 final int standardFieldsOffset = offset + STANDARD_FIELDS_OFFSET; | |
245 final int windowsSpecificFieldsOffset = offset + | |
246 (isPE32Plus | |
247 ? PE32_PLUS_WINDOWS_SPECIFIC_FIELDS_OFFSET | |
248 : PE32_WINDOWS_SPECIFIC_FIELDS_OFFSET); | |
249 final int dataDirectoriesOffset = offset + | |
250 (isPE32Plus | |
251 ? PE32_PLUS_DATA_DIRECTORIES_OFFSET | |
252 : PE32_DATA_DIRECTORIES_OFFSET); | |
253 | |
254 standardFields = new MemoizedObject() { | |
255 public Object computeValue() { | |
256 return new OptionalHeaderStandardFieldsImpl(standardFieldsOffset, | |
257 isPE32Plus); | |
258 } | |
259 }; | |
260 windowsSpecificFields = new MemoizedObject() { | |
261 public Object computeValue() { | |
262 return new OptionalHeaderWindowsSpecificFieldsImpl(windowsSpecificFieldsOffset, | |
263 isPE32Plus); | |
264 } | |
265 }; | |
266 dataDirectories = new MemoizedObject() { | |
267 public Object computeValue() { | |
268 return new OptionalHeaderDataDirectoriesImpl(dataDirectoriesOffset, | |
269 getWindowsSpecificFields().getNumberOfRvaAndSizes()); | |
270 } | |
271 }; | |
272 } | |
273 | |
274 public short getMagicNumber() { | |
275 return magic; | |
276 } | |
277 | |
278 public OptionalHeaderStandardFields getStandardFields() { | |
279 return (OptionalHeaderStandardFields) standardFields.getValue(); | |
280 } | |
281 | |
282 public OptionalHeaderWindowsSpecificFields getWindowsSpecificFields() { | |
283 return (OptionalHeaderWindowsSpecificFields) windowsSpecificFields.getValue(); | |
284 } | |
285 public OptionalHeaderDataDirectories getDataDirectories() { | |
286 return (OptionalHeaderDataDirectories) dataDirectories.getValue(); | |
287 } | |
288 } | |
289 | |
290 class OptionalHeaderStandardFieldsImpl implements OptionalHeaderStandardFields { | |
291 private boolean isPE32Plus; | |
292 private byte majorLinkerVersion; | |
293 private byte minorLinkerVersion; | |
294 private int sizeOfCode; | |
295 private int sizeOfInitializedData; | |
296 private int sizeOfUninitializedData; | |
297 private int addressOfEntryPoint; | |
298 private int baseOfCode; | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
299 private int baseOfData; // only set in PE32 |
0 | 300 |
301 OptionalHeaderStandardFieldsImpl(int offset, | |
302 boolean isPE32Plus) { | |
303 this.isPE32Plus = isPE32Plus; | |
304 seek(offset); | |
305 majorLinkerVersion = readByte(); | |
306 minorLinkerVersion = readByte(); | |
307 sizeOfCode = readInt(); | |
308 sizeOfInitializedData = readInt(); | |
309 sizeOfUninitializedData = readInt(); | |
310 addressOfEntryPoint = readInt(); | |
311 baseOfCode = readInt(); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
312 if (!isPE32Plus) { |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
313 // only available in PE32 |
0 | 314 baseOfData = readInt(); |
315 } | |
316 } | |
317 | |
318 public byte getMajorLinkerVersion() { return majorLinkerVersion; } | |
319 public byte getMinorLinkerVersion() { return minorLinkerVersion; } | |
320 public int getSizeOfCode() { return sizeOfCode; } | |
321 public int getSizeOfInitializedData() { return sizeOfInitializedData; } | |
322 public int getSizeOfUninitializedData() { return sizeOfUninitializedData; } | |
323 public int getAddressOfEntryPoint() { return addressOfEntryPoint; } | |
324 public int getBaseOfCode() { return baseOfCode; } | |
325 public int getBaseOfData() throws COFFException { | |
326 if (isPE32Plus) { | |
327 throw new COFFException("Not present in PE32+ files"); | |
328 } | |
329 return baseOfData; | |
330 } | |
331 } | |
332 | |
333 class OptionalHeaderWindowsSpecificFieldsImpl implements OptionalHeaderWindowsSpecificFields { | |
334 private long imageBase; | |
335 private int sectionAlignment; | |
336 private int fileAlignment; | |
337 private short majorOperatingSystemVersion; | |
338 private short minorOperatingSystemVersion; | |
339 private short majorImageVersion; | |
340 private short minorImageVersion; | |
341 private short majorSubsystemVersion; | |
342 private short minorSubsystemVersion; | |
343 private int sizeOfImage; | |
344 private int sizeOfHeaders; | |
345 private int checkSum; | |
346 private short subsystem; | |
347 private short dllCharacteristics; | |
348 private long sizeOfStackReserve; | |
349 private long sizeOfStackCommit; | |
350 private long sizeOfHeapReserve; | |
351 private long sizeOfHeapCommit; | |
352 private int loaderFlags; | |
353 private int numberOfRvaAndSizes; | |
354 | |
355 OptionalHeaderWindowsSpecificFieldsImpl(int offset, boolean isPE32Plus) { | |
356 seek(offset); | |
357 | |
358 if (!isPE32Plus) { | |
359 imageBase = maskInt(readInt()); | |
360 } else { | |
361 imageBase = readLong(); | |
362 } | |
363 sectionAlignment = readInt(); | |
364 fileAlignment = readInt(); | |
365 majorOperatingSystemVersion = readShort(); | |
366 minorOperatingSystemVersion = readShort(); | |
367 majorImageVersion = readShort(); | |
368 minorImageVersion = readShort(); | |
369 majorSubsystemVersion = readShort(); | |
370 minorSubsystemVersion = readShort(); | |
371 readInt(); // Reserved | |
372 sizeOfImage = readInt(); | |
373 sizeOfHeaders = readInt(); | |
374 checkSum = readInt(); | |
375 subsystem = readShort(); | |
376 dllCharacteristics = readShort(); | |
377 if (!isPE32Plus) { | |
378 sizeOfStackReserve = maskInt(readInt()); | |
379 sizeOfStackCommit = maskInt(readInt()); | |
380 sizeOfHeapReserve = maskInt(readInt()); | |
381 sizeOfHeapCommit = maskInt(readInt()); | |
382 } else { | |
383 sizeOfStackReserve = readLong(); | |
384 sizeOfStackCommit = readLong(); | |
385 sizeOfHeapReserve = readLong(); | |
386 sizeOfHeapCommit = readLong(); | |
387 } | |
388 loaderFlags = readInt(); | |
389 numberOfRvaAndSizes = readInt(); | |
390 } | |
391 | |
392 public long getImageBase() { return imageBase; } | |
393 public int getSectionAlignment() { return sectionAlignment; } | |
394 public int getFileAlignment() { return fileAlignment; } | |
395 public short getMajorOperatingSystemVersion() { return majorOperatingSystemVersion; } | |
396 public short getMinorOperatingSystemVersion() { return minorOperatingSystemVersion; } | |
397 public short getMajorImageVersion() { return majorImageVersion; } | |
398 public short getMinorImageVersion() { return minorImageVersion; } | |
399 public short getMajorSubsystemVersion() { return majorSubsystemVersion; } | |
400 public short getMinorSubsystemVersion() { return minorSubsystemVersion; } | |
401 public int getSizeOfImage() { return sizeOfImage; } | |
402 public int getSizeOfHeaders() { return sizeOfHeaders; } | |
403 public int getCheckSum() { return checkSum; } | |
404 public short getSubsystem() { return subsystem; } | |
405 public short getDLLCharacteristics() { return dllCharacteristics; } | |
406 public long getSizeOfStackReserve() { return sizeOfStackReserve; } | |
407 public long getSizeOfStackCommit() { return sizeOfStackCommit; } | |
408 public long getSizeOfHeapReserve() { return sizeOfHeapReserve; } | |
409 public long getSizeOfHeapCommit() { return sizeOfHeapCommit; } | |
410 public int getLoaderFlags() { return loaderFlags; } | |
411 public int getNumberOfRvaAndSizes() { return numberOfRvaAndSizes; } | |
412 | |
413 private long maskInt(long arg) { | |
414 return (arg & 0x00000000FFFFFFFFL); | |
415 } | |
416 } | |
417 | |
418 class OptionalHeaderDataDirectoriesImpl implements OptionalHeaderDataDirectories { | |
419 private int numberOfRvaAndSizes; | |
420 private MemoizedObject[] dataDirectories; | |
421 private MemoizedObject exportDirectoryTable; | |
422 private MemoizedObject debugDirectory; | |
423 | |
424 private static final int DATA_DIRECTORY_SIZE = 8; | |
425 | |
426 OptionalHeaderDataDirectoriesImpl(int offset, | |
427 int numberOfRvaAndSizes) { | |
428 this.numberOfRvaAndSizes = numberOfRvaAndSizes; | |
429 dataDirectories = new MemoizedObject[numberOfRvaAndSizes]; | |
430 for (int i = 0; i < numberOfRvaAndSizes; i++) { | |
431 final int dirOffset = offset + (i * DATA_DIRECTORY_SIZE); | |
432 dataDirectories[i] = new MemoizedObject() { | |
433 public Object computeValue() { | |
434 return new DataDirectoryImpl(dirOffset); | |
435 } | |
436 }; | |
437 } | |
438 | |
439 exportDirectoryTable = new MemoizedObject() { | |
440 public Object computeValue() { | |
441 DataDirectory dir = getExportTable(); | |
442 if (dir.getRVA() == 0 || dir.getSize() == 0) { | |
443 return null; | |
444 } | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
445 // ExportDirectoryTableImpl needs both the RVA and the |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
446 // RVA converted to a file offset. |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
447 return new |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
448 ExportDirectoryTableImpl(dir.getRVA(), dir.getSize()); |
0 | 449 } |
450 }; | |
451 | |
452 debugDirectory = new MemoizedObject() { | |
453 public Object computeValue() { | |
454 DataDirectory dir = getDebug(); | |
455 if (dir.getRVA() == 0 || dir.getSize() == 0) { | |
456 return null; | |
457 } | |
458 return new DebugDirectoryImpl(rvaToFileOffset(dir.getRVA()), dir.getSize()); | |
459 } | |
460 }; | |
461 } | |
462 | |
463 public DataDirectory getExportTable() throws COFFException { | |
464 return (DataDirectory) dataDirectories[checkIndex(0)].getValue(); | |
465 } | |
466 public DataDirectory getImportTable() throws COFFException { | |
467 return (DataDirectory) dataDirectories[checkIndex(1)].getValue(); | |
468 } | |
469 public DataDirectory getResourceTable() throws COFFException { | |
470 return (DataDirectory) dataDirectories[checkIndex(2)].getValue(); | |
471 } | |
472 public DataDirectory getExceptionTable() throws COFFException { | |
473 return (DataDirectory) dataDirectories[checkIndex(3)].getValue(); | |
474 } | |
475 public DataDirectory getCertificateTable() throws COFFException { | |
476 return (DataDirectory) dataDirectories[checkIndex(4)].getValue(); | |
477 } | |
478 public DataDirectory getBaseRelocationTable() throws COFFException { | |
479 return (DataDirectory) dataDirectories[checkIndex(5)].getValue(); | |
480 } | |
481 public DataDirectory getDebug() throws COFFException { | |
482 return (DataDirectory) dataDirectories[checkIndex(6)].getValue(); | |
483 } | |
484 public DataDirectory getArchitecture() throws COFFException { | |
485 return (DataDirectory) dataDirectories[checkIndex(7)].getValue(); | |
486 } | |
487 public DataDirectory getGlobalPtr() throws COFFException { | |
488 return (DataDirectory) dataDirectories[checkIndex(8)].getValue(); | |
489 } | |
490 public DataDirectory getTLSTable() throws COFFException { | |
491 return (DataDirectory) dataDirectories[checkIndex(9)].getValue(); | |
492 } | |
493 public DataDirectory getLoadConfigTable() throws COFFException { | |
494 return (DataDirectory) dataDirectories[checkIndex(10)].getValue(); | |
495 } | |
496 public DataDirectory getBoundImportTable() throws COFFException { | |
497 return (DataDirectory) dataDirectories[checkIndex(11)].getValue(); | |
498 } | |
499 public DataDirectory getImportAddressTable() throws COFFException { | |
500 return (DataDirectory) dataDirectories[checkIndex(12)].getValue(); | |
501 } | |
502 public DataDirectory getDelayImportDescriptor() throws COFFException { | |
503 return (DataDirectory) dataDirectories[checkIndex(13)].getValue(); | |
504 } | |
505 public DataDirectory getCOMPlusRuntimeHeader() throws COFFException { | |
506 return (DataDirectory) dataDirectories[checkIndex(14)].getValue(); | |
507 } | |
508 | |
509 public ExportDirectoryTable getExportDirectoryTable() throws COFFException { | |
510 return (ExportDirectoryTable) exportDirectoryTable.getValue(); | |
511 } | |
512 | |
513 public DebugDirectory getDebugDirectory() throws COFFException { | |
514 return (DebugDirectory) debugDirectory.getValue(); | |
515 } | |
516 | |
517 private int checkIndex(int index) throws COFFException { | |
518 if ((index < 0) || (index >= dataDirectories.length)) { | |
519 throw new COFFException("Directory " + index + " unavailable (only " + | |
520 numberOfRvaAndSizes + " tables present)"); | |
521 } | |
522 return index; | |
523 } | |
524 } | |
525 | |
526 class DataDirectoryImpl implements DataDirectory { | |
527 int rva; | |
528 int size; | |
529 | |
530 DataDirectoryImpl(int offset) { | |
531 seek(offset); | |
532 rva = readInt(); | |
533 size = readInt(); | |
534 } | |
535 | |
536 public int getRVA() { return rva; } | |
537 public int getSize() { return size; } | |
538 } | |
539 | |
540 class ExportDirectoryTableImpl implements ExportDirectoryTable { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
541 private int exportDataDirRVA; |
0 | 542 private int offset; |
543 private int size; | |
544 | |
545 private int exportFlags; | |
546 private int timeDateStamp; | |
547 private short majorVersion; | |
548 private short minorVersion; | |
549 private int nameRVA; | |
550 private int ordinalBase; | |
551 private int addressTableEntries; | |
552 private int numberOfNamePointers; | |
553 private int exportAddressTableRVA; | |
554 private int namePointerTableRVA; | |
555 private int ordinalTableRVA; | |
556 | |
557 private MemoizedObject dllName; | |
558 | |
559 private MemoizedObject exportNameTable; | |
560 private MemoizedObject exportNamePointerTable; | |
561 private MemoizedObject exportOrdinalTable; | |
562 private MemoizedObject exportAddressTable; | |
563 | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
564 ExportDirectoryTableImpl(int exportDataDirRVA, int size) { |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
565 this.exportDataDirRVA = exportDataDirRVA; |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
566 offset = rvaToFileOffset(exportDataDirRVA); |
0 | 567 this.size = size; |
568 seek(offset); | |
569 exportFlags = readInt(); | |
570 timeDateStamp = readInt(); | |
571 majorVersion = readShort(); | |
572 minorVersion = readShort(); | |
573 nameRVA = readInt(); | |
574 ordinalBase = readInt(); | |
575 addressTableEntries = readInt(); | |
576 numberOfNamePointers = readInt(); | |
577 exportAddressTableRVA = readInt(); | |
578 namePointerTableRVA = readInt(); | |
579 ordinalTableRVA = readInt(); | |
580 | |
581 dllName = new MemoizedObject() { | |
582 public Object computeValue() { | |
583 seek(rvaToFileOffset(getNameRVA())); | |
584 return readCString(); | |
585 } | |
586 }; | |
587 | |
588 exportNamePointerTable = new MemoizedObject() { | |
589 public Object computeValue() { | |
590 int[] pointers = new int[getNumberOfNamePointers()]; | |
591 seek(rvaToFileOffset(getNamePointerTableRVA())); | |
592 // Must make two passes to avoid rvaToFileOffset | |
593 // destroying seek() position | |
594 for (int i = 0; i < pointers.length; i++) { | |
595 pointers[i] = readInt(); | |
596 } | |
597 for (int i = 0; i < pointers.length; i++) { | |
598 pointers[i] = rvaToFileOffset(pointers[i]); | |
599 } | |
600 return pointers; | |
601 } | |
602 }; | |
603 | |
604 exportNameTable = new MemoizedObject() { | |
605 public Object computeValue() { | |
606 return new ExportNameTable(getExportNamePointerTable()); | |
607 } | |
608 }; | |
609 | |
610 exportOrdinalTable = new MemoizedObject() { | |
611 public Object computeValue() { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
612 // number of ordinals is same as the number of name pointers |
0 | 613 short[] ordinals = new short[getNumberOfNamePointers()]; |
614 seek(rvaToFileOffset(getOrdinalTableRVA())); | |
615 for (int i = 0; i < ordinals.length; i++) { | |
616 ordinals[i] = readShort(); | |
617 } | |
618 return ordinals; | |
619 } | |
620 }; | |
621 | |
622 exportAddressTable = new MemoizedObject() { | |
623 public Object computeValue() { | |
624 int[] addresses = new int[getNumberOfAddressTableEntries()]; | |
625 seek(rvaToFileOffset(getExportAddressTableRVA())); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
626 // The Export Address Table values are a union of two |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
627 // possible values: |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
628 // Export RVA - The address of the exported symbol when |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
629 // loaded into memory, relative to the image base. |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
630 // This value doesn't get converted into a file offset. |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
631 // Forwarder RVA - The pointer to a null-terminated ASCII |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
632 // string in the export section. This value gets |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
633 // converted into a file offset because we have to |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
634 // fetch the string. |
0 | 635 for (int i = 0; i < addresses.length; i++) { |
636 addresses[i] = readInt(); | |
637 } | |
638 return addresses; | |
639 } | |
640 }; | |
641 } | |
642 | |
643 public int getExportFlags() { return exportFlags; } | |
644 public int getTimeDateStamp() { return timeDateStamp; } | |
645 public short getMajorVersion() { return majorVersion; } | |
646 public short getMinorVersion() { return minorVersion; } | |
647 public int getNameRVA() { return nameRVA; } | |
648 | |
649 public String getDLLName() { | |
650 return (String) dllName.getValue(); | |
651 } | |
652 | |
653 public int getOrdinalBase() { return ordinalBase; } | |
654 public int getNumberOfAddressTableEntries() { return addressTableEntries; } | |
655 public int getNumberOfNamePointers() { return numberOfNamePointers; } | |
656 public int getExportAddressTableRVA() { return exportAddressTableRVA; } | |
657 public int getNamePointerTableRVA() { return namePointerTableRVA; } | |
658 public int getOrdinalTableRVA() { return ordinalTableRVA; } | |
659 | |
660 public String getExportName(int i) { | |
661 return getExportNameTable().get(i); | |
662 } | |
663 | |
664 public short getExportOrdinal(int i) { | |
665 return getExportOrdinalTable()[i]; | |
666 } | |
667 | |
668 public boolean isExportAddressForwarder(short ordinal) { | |
669 int addr = getExportAddress(ordinal); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
670 return ((exportDataDirRVA <= addr) && |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
671 (addr < (exportDataDirRVA + size))); |
0 | 672 } |
673 | |
674 public String getExportAddressForwarder(short ordinal) { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
675 seek(rvaToFileOffset(getExportAddress(ordinal))); |
0 | 676 return readCString(); |
677 } | |
678 | |
679 public int getExportAddress(short ordinal) { | |
680 | |
681 /////////////////////// | |
682 // FIXME: MAJOR HACK // | |
683 /////////////////////// | |
684 | |
685 // According to the documentation, the first line here is | |
686 // correct. However, it doesn't seem to work. The second | |
687 // one, however, does. | |
688 | |
689 // OK, it's probably due to using negative indices in the | |
690 // export address table in "real life"...need to rethink | |
691 // this when I'm more awake | |
692 | |
693 // return getExportAddressTable()[ordinal - ordinalBase]; | |
694 return getExportAddressTable()[ordinal]; | |
695 } | |
696 | |
697 private ExportNameTable getExportNameTable() { | |
698 return (ExportNameTable) exportNameTable.getValue(); | |
699 } | |
700 | |
701 private int[] getExportNamePointerTable() { | |
702 return (int[]) exportNamePointerTable.getValue(); | |
703 } | |
704 | |
705 private short[] getExportOrdinalTable() { | |
706 return (short[]) exportOrdinalTable.getValue(); | |
707 } | |
708 | |
709 private int[] getExportAddressTable() { | |
710 return (int[]) exportAddressTable.getValue(); | |
711 } | |
712 } | |
713 | |
714 class ExportNameTable { | |
715 private MemoizedObject[] names; | |
716 | |
717 ExportNameTable(final int[] exportNamePointerTable) { | |
718 names = new MemoizedObject[exportNamePointerTable.length]; | |
719 for (int i = 0; i < exportNamePointerTable.length; i++) { | |
720 final int idx = i; | |
721 names[idx] = new MemoizedObject() { | |
722 public Object computeValue() { | |
723 seek(exportNamePointerTable[idx]); | |
724 return readCString(); | |
725 } | |
726 }; | |
727 }; | |
728 } | |
729 | |
730 String get(int i) { | |
731 return (String) names[i].getValue(); | |
732 } | |
733 } | |
734 | |
735 class DebugDirectoryImpl implements DebugDirectory { | |
736 private int offset; | |
737 private int size; | |
738 private int numEntries; | |
739 | |
740 private static final int DEBUG_DIRECTORY_ENTRY_SIZE = 28; | |
741 | |
742 DebugDirectoryImpl(int offset, int size) { | |
743 this.offset = offset; | |
744 this.size = size; | |
745 | |
746 if ((size % DEBUG_DIRECTORY_ENTRY_SIZE) != 0) { | |
747 throw new COFFException("Corrupt DebugDirectory at offset 0x" + | |
748 Integer.toHexString(offset)); | |
749 } | |
750 | |
751 numEntries = size / DEBUG_DIRECTORY_ENTRY_SIZE; | |
752 } | |
753 | |
754 public int getNumEntries() { return numEntries; } | |
755 public DebugDirectoryEntry getEntry(int i) { | |
756 if ((i < 0) || (i >= getNumEntries())) throw new IndexOutOfBoundsException(); | |
757 return new DebugDirectoryEntryImpl(offset + i * DEBUG_DIRECTORY_ENTRY_SIZE); | |
758 } | |
759 } | |
760 | |
761 class DebugDirectoryEntryImpl implements DebugDirectoryEntry, DebugTypes { | |
762 private int characteristics; | |
763 private int timeDateStamp; | |
764 private short majorVersion; | |
765 private short minorVersion; | |
766 private int type; | |
767 private int sizeOfData; | |
768 private int addressOfRawData; | |
769 private int pointerToRawData; | |
770 | |
771 DebugDirectoryEntryImpl(int offset) { | |
772 seek(offset); | |
773 characteristics = readInt(); | |
774 timeDateStamp = readInt(); | |
775 majorVersion = readShort(); | |
776 minorVersion = readShort(); | |
777 type = readInt(); | |
778 sizeOfData = readInt(); | |
779 addressOfRawData = readInt(); | |
780 pointerToRawData = readInt(); | |
781 } | |
782 | |
783 public int getCharacteristics() { return characteristics; } | |
784 public int getTimeDateStamp() { return timeDateStamp; } | |
785 public short getMajorVersion() { return majorVersion; } | |
786 public short getMinorVersion() { return minorVersion; } | |
787 public int getType() { return type; } | |
788 public int getSizeOfData() { return sizeOfData; } | |
789 public int getAddressOfRawData() { return addressOfRawData; } | |
790 public int getPointerToRawData() { return pointerToRawData; } | |
791 | |
792 public DebugVC50 getDebugVC50() { | |
793 // See whether we can recognize VC++ 5.0 debug information. | |
794 try { | |
795 if (getType() != IMAGE_DEBUG_TYPE_CODEVIEW) return null; | |
796 | |
797 int offset = getPointerToRawData(); | |
798 seek(offset); | |
799 if (readByte() == 'N' && | |
800 readByte() == 'B' && | |
801 readByte() == '1' && | |
802 readByte() == '1') { | |
803 return new DebugVC50Impl(offset); | |
804 } | |
805 } catch (COFFException e) { | |
806 e.printStackTrace(); | |
807 } | |
808 return null; | |
809 } | |
810 | |
811 public byte getRawDataByte(int i) { | |
812 if (i < 0 || i >= getSizeOfData()) { | |
813 throw new IndexOutOfBoundsException(); | |
814 } | |
815 seek(getPointerToRawData() + i); | |
816 return readByte(); | |
817 } | |
818 } | |
819 | |
820 class DebugVC50Impl implements DebugVC50, DebugVC50TypeLeafIndices { | |
821 private int lfaBase; | |
822 | |
823 private int subsectionDirectoryOffset; | |
824 private MemoizedObject subsectionDirectory; | |
825 | |
826 DebugVC50Impl(int offset) { | |
827 lfaBase = offset; | |
828 seek(offset); | |
829 readInt(); // Discard NB11 | |
830 subsectionDirectoryOffset = globalOffset(readInt()); | |
831 | |
832 // Ensure information is complete | |
833 verify(); | |
834 | |
835 subsectionDirectory = new MemoizedObject() { | |
836 public Object computeValue() { | |
837 return new DebugVC50SubsectionDirectoryImpl(getSubsectionDirectoryOffset()); | |
838 } | |
839 }; | |
840 } | |
841 | |
842 public int getSubsectionDirectoryOffset() { | |
843 return subsectionDirectoryOffset; | |
844 } | |
845 | |
846 public DebugVC50SubsectionDirectory getSubsectionDirectory() { | |
847 return (DebugVC50SubsectionDirectory) subsectionDirectory.getValue(); | |
848 } | |
849 | |
850 private int globalOffset(int offset) { | |
851 return offset + lfaBase; | |
852 } | |
853 | |
854 private void verify() { | |
855 // Seek to subsection directory manually and look for | |
856 // signature following it. This finishes validating that we | |
857 // have VC++ 5.0 debug info. Throw COFFException if not | |
858 // found; will cause caller to return null. | |
859 seek(subsectionDirectoryOffset); | |
860 int headerLength = readShort(); | |
861 int entryLength = readShort(); | |
862 int numEntries = readInt(); | |
863 int endOffset = subsectionDirectoryOffset + headerLength + numEntries * entryLength; | |
864 seek(endOffset); | |
865 | |
866 if (readByte() == 'N' && | |
867 readByte() == 'B' && | |
868 readByte() == '1' && | |
869 readByte() == '1') { | |
870 return; | |
871 } | |
872 | |
873 throw new COFFException("Did not find NB11 signature at end of debug info"); | |
874 } | |
875 | |
876 class DebugVC50SubsectionDirectoryImpl | |
877 implements DebugVC50SubsectionDirectory, | |
878 DebugVC50SubsectionTypes { | |
879 private int offset; | |
880 private short dirHeaderLength; | |
881 private short dirEntryLength; | |
882 private int numEntries; | |
883 | |
884 DebugVC50SubsectionDirectoryImpl(int offset) { | |
885 this.offset = offset; | |
886 // Read header | |
887 seek(offset); | |
888 dirHeaderLength = readShort(); | |
889 dirEntryLength = readShort(); | |
890 numEntries = readInt(); | |
891 } | |
892 | |
893 public short getHeaderLength() { return dirHeaderLength; } | |
894 public short getEntryLength() { return dirEntryLength; } | |
895 public int getNumEntries() { return numEntries; } | |
896 | |
897 public DebugVC50Subsection getSubsection(int i) { | |
898 // Fetch the subsection type and instantiate the correct | |
899 // type of subsection based on it | |
900 seek(offset + dirHeaderLength + (i * dirEntryLength)); | |
901 short ssType = readShort(); | |
902 short iMod = readShort(); // Unneeded? | |
903 int lfo = globalOffset(readInt()); | |
904 int cb = readInt(); | |
905 switch (ssType) { | |
906 case SST_MODULE: | |
907 return new DebugVC50SSModuleImpl(ssType, iMod, cb, lfo); | |
908 case SST_TYPES: | |
909 return new DebugVC50SSTypesImpl(ssType, iMod, cb, lfo); | |
910 case SST_PUBLIC: | |
911 return new DebugVC50SSPublicImpl(ssType, iMod, cb, lfo); | |
912 case SST_PUBLIC_SYM: | |
913 return new DebugVC50SSPublicSymImpl(ssType, iMod, cb, lfo); | |
914 case SST_SYMBOLS: | |
915 return new DebugVC50SSSymbolsImpl(ssType, iMod, cb, lfo); | |
916 case SST_ALIGN_SYM: | |
917 return new DebugVC50SSAlignSymImpl(ssType, iMod, cb, lfo); | |
918 case SST_SRC_LN_SEG: | |
919 return new DebugVC50SSSrcLnSegImpl(ssType, iMod, cb, lfo); | |
920 case SST_SRC_MODULE: | |
921 return new DebugVC50SSSrcModuleImpl(ssType, iMod, cb, lfo); | |
922 case SST_LIBRARIES: | |
923 return new DebugVC50SSLibrariesImpl(ssType, iMod, cb, lfo); | |
924 case SST_GLOBAL_SYM: | |
925 return new DebugVC50SSGlobalSymImpl(ssType, iMod, cb, lfo); | |
926 case SST_GLOBAL_PUB: | |
927 return new DebugVC50SSGlobalPubImpl(ssType, iMod, cb, lfo); | |
928 case SST_GLOBAL_TYPES: | |
929 return new DebugVC50SSGlobalTypesImpl(ssType, iMod, cb, lfo); | |
930 case SST_MPC: | |
931 return new DebugVC50SSMPCImpl(ssType, iMod, cb, lfo); | |
932 case SST_SEG_MAP: | |
933 return new DebugVC50SSSegMapImpl(ssType, iMod, cb, lfo); | |
934 case SST_SEG_NAME: | |
935 return new DebugVC50SSSegNameImpl(ssType, iMod, cb, lfo); | |
936 case SST_PRE_COMP: | |
937 return new DebugVC50SSPreCompImpl(ssType, iMod, cb, lfo); | |
938 case SST_UNUSED: | |
939 return null; | |
940 case SST_OFFSET_MAP_16: | |
941 return new DebugVC50SSOffsetMap16Impl(ssType, iMod, cb, lfo); | |
942 case SST_OFFSET_MAP_32: | |
943 return new DebugVC50SSOffsetMap32Impl(ssType, iMod, cb, lfo); | |
944 case SST_FILE_INDEX: | |
945 return new DebugVC50SSFileIndexImpl(ssType, iMod, cb, lfo); | |
946 case SST_STATIC_SYM: | |
947 return new DebugVC50SSStaticSymImpl(ssType, iMod, cb, lfo); | |
948 default: | |
949 throw new COFFException("Unknown section type " + ssType); | |
950 } | |
951 } | |
952 } | |
953 | |
954 //////////////////////////////////// | |
955 // // | |
956 // Implementations of subsections // | |
957 // // | |
958 //////////////////////////////////// | |
959 | |
960 class DebugVC50SubsectionImpl implements DebugVC50Subsection { | |
961 private short ssType; | |
962 private short iMod; | |
963 private int ssSize; | |
964 | |
965 DebugVC50SubsectionImpl(short ssType, short iMod, int ssSize, int offset) { | |
966 this.ssType = ssType; | |
967 this.iMod = iMod; | |
968 this.ssSize = ssSize; | |
969 } | |
970 | |
971 public short getSubsectionType() { return ssType; } | |
972 public short getSubsectionModuleIndex() { return iMod; } | |
973 public int getSubsectionSize() { return ssSize; } | |
974 } | |
975 | |
976 class DebugVC50SSModuleImpl extends DebugVC50SubsectionImpl implements DebugVC50SSModule { | |
977 private int offset; | |
978 private short ovlNumber; | |
979 private short iLib; | |
980 private short cSeg; | |
981 private short style; | |
982 private MemoizedObject segInfo; | |
983 private MemoizedObject name; | |
984 | |
985 private static final int HEADER_SIZE = 8; | |
986 private static final int SEG_INFO_SIZE = 12; | |
987 | |
988 DebugVC50SSModuleImpl(short ssType, short iMod, int ssSize, final int offset) { | |
989 super(ssType, iMod, ssSize, offset); | |
990 this.offset = offset; | |
991 seek(offset); | |
992 ovlNumber = readShort(); | |
993 iLib = readShort(); | |
994 cSeg = readShort(); | |
995 style = readShort(); | |
996 segInfo = new MemoizedObject() { | |
997 public Object computeValue() { | |
998 int base = offset + HEADER_SIZE; | |
999 DebugVC50SegInfo[] res = new DebugVC50SegInfo[cSeg]; | |
1000 for (int i = 0; i < cSeg; i++) { | |
1001 res[i] = new DebugVC50SegInfoImpl(base); | |
1002 base += SEG_INFO_SIZE; | |
1003 } | |
1004 return res; | |
1005 } | |
1006 }; | |
1007 name = new MemoizedObject() { | |
1008 public Object computeValue() { | |
1009 return readLengthPrefixedStringAt(offset + (HEADER_SIZE + cSeg * SEG_INFO_SIZE)); | |
1010 } | |
1011 }; | |
1012 } | |
1013 | |
1014 public short getOverlayNumber() { return ovlNumber; } | |
1015 public short getLibrariesIndex() { return iLib; } | |
1016 public short getNumCodeSegments() { return cSeg; } | |
1017 public short getDebuggingStyle() { return style; } | |
1018 public DebugVC50SegInfo getSegInfo(int i) { return ((DebugVC50SegInfo[]) segInfo.getValue())[i]; } | |
1019 public String getName() { return (String) name.getValue(); } | |
1020 } | |
1021 | |
1022 class DebugVC50SegInfoImpl implements DebugVC50SegInfo { | |
1023 private short seg; | |
1024 private int offset; | |
1025 private int cbSeg; | |
1026 | |
1027 DebugVC50SegInfoImpl(int offset) { | |
1028 seek(offset); | |
1029 seg = readShort(); | |
1030 readShort(); // pad | |
1031 offset = readInt(); | |
1032 cbSeg = readInt(); | |
1033 } | |
1034 | |
1035 public short getSegment() { return seg; } | |
1036 public int getOffset() { return offset; } | |
1037 public int getSegmentCodeSize() { return cbSeg; } | |
1038 } | |
1039 | |
1040 class DebugVC50SSTypesImpl extends DebugVC50SubsectionImpl implements DebugVC50SSTypes { | |
1041 DebugVC50SSTypesImpl(short ssType, short iMod, int ssSize, int offset) { | |
1042 super(ssType, iMod, ssSize, offset); | |
1043 } | |
1044 } | |
1045 | |
1046 class DebugVC50SSPublicImpl extends DebugVC50SubsectionImpl implements DebugVC50SSPublic { | |
1047 DebugVC50SSPublicImpl(short ssType, short iMod, int ssSize, int offset) { | |
1048 super(ssType, iMod, ssSize, offset); | |
1049 } | |
1050 } | |
1051 | |
1052 class DebugVC50SSPublicSymImpl extends DebugVC50SubsectionImpl implements DebugVC50SSPublicSym { | |
1053 DebugVC50SSPublicSymImpl(short ssType, short iMod, int ssSize, int offset) { | |
1054 super(ssType, iMod, ssSize, offset); | |
1055 } | |
1056 } | |
1057 | |
1058 class DebugVC50SSSymbolsImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSymbols { | |
1059 DebugVC50SSSymbolsImpl(short ssType, short iMod, int ssSize, int offset) { | |
1060 super(ssType, iMod, ssSize, offset); | |
1061 } | |
1062 } | |
1063 | |
1064 class DebugVC50SSAlignSymImpl extends DebugVC50SubsectionImpl implements DebugVC50SSAlignSym { | |
1065 private int offset; | |
1066 | |
1067 DebugVC50SSAlignSymImpl(short ssType, short iMod, int ssSize, int offset) { | |
1068 super(ssType, iMod, ssSize, offset); | |
1069 this.offset = offset; | |
1070 } | |
1071 | |
1072 public DebugVC50SymbolIterator getSymbolIterator() { | |
1073 return new DebugVC50SymbolIteratorImpl(offset, getSubsectionSize()); | |
1074 } | |
1075 } | |
1076 | |
1077 class DebugVC50SSSrcLnSegImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSrcLnSeg { | |
1078 DebugVC50SSSrcLnSegImpl(short ssType, short iMod, int ssSize, int offset) { | |
1079 super(ssType, iMod, ssSize, offset); | |
1080 } | |
1081 } | |
1082 | |
1083 class DebugVC50SSSrcModuleImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSrcModule { | |
1084 private int offset; | |
1085 private short cFile; | |
1086 private short cSeg; | |
1087 private MemoizedObject baseSrcFiles; | |
1088 private MemoizedObject segOffsets; | |
1089 private MemoizedObject segs; | |
1090 | |
1091 DebugVC50SSSrcModuleImpl(short ssType, short iMod, int ssSize, final int offset) { | |
1092 super(ssType, iMod, ssSize, offset); | |
1093 | |
1094 this.offset = offset; | |
1095 seek(offset); | |
1096 cFile = readShort(); | |
1097 cSeg = readShort(); | |
1098 | |
1099 baseSrcFiles = new MemoizedObject() { | |
1100 public Object computeValue() { | |
1101 int[] offsets = new int[getNumSourceFiles()]; | |
1102 seek(offset + 4); | |
1103 for (int i = 0; i < getNumSourceFiles(); i++) { | |
1104 offsets[i] = offset + readInt(); | |
1105 } | |
1106 DebugVC50SrcModFileDescImpl[] res = new DebugVC50SrcModFileDescImpl[offsets.length]; | |
1107 for (int i = 0; i < res.length; i++) { | |
1108 res[i] = new DebugVC50SrcModFileDescImpl(offsets[i], offset); | |
1109 } | |
1110 return res; | |
1111 } | |
1112 }; | |
1113 | |
1114 segOffsets = new MemoizedObject() { | |
1115 public Object computeValue() { | |
1116 seek(offset + 4 * (getNumSourceFiles() + 1)); | |
1117 int[] res = new int[2 * getNumCodeSegments()]; | |
1118 for (int i = 0; i < 2 * getNumCodeSegments(); i++) { | |
1119 res[i] = readInt(); | |
1120 } | |
1121 return res; | |
1122 } | |
1123 }; | |
1124 | |
1125 segs = new MemoizedObject() { | |
1126 public Object computeValue() { | |
1127 seek(offset + 4 * (getNumSourceFiles() + 1) + 8 * getNumCodeSegments()); | |
1128 short[] res = new short[getNumCodeSegments()]; | |
1129 for (int i = 0; i < getNumCodeSegments(); i++) { | |
1130 res[i] = readShort(); | |
1131 } | |
1132 return res; | |
1133 } | |
1134 }; | |
1135 } | |
1136 | |
1137 public int getNumSourceFiles() { return cFile & 0xFFFF; } | |
1138 public int getNumCodeSegments() { return cSeg & 0xFFFF; } | |
1139 public DebugVC50SrcModFileDesc getSourceFileDesc(int i) { | |
1140 return ((DebugVC50SrcModFileDescImpl[]) baseSrcFiles.getValue())[i]; | |
1141 } | |
1142 | |
1143 public int getSegmentStartOffset(int i) { | |
1144 return ((int[]) segOffsets.getValue())[2*i]; | |
1145 } | |
1146 | |
1147 public int getSegmentEndOffset(int i) { | |
1148 return ((int[]) segOffsets.getValue())[2*i+1]; | |
1149 } | |
1150 | |
1151 public int getSegment(int i) { | |
1152 return ((short[]) segs.getValue())[i] & 0xFFFF; | |
1153 } | |
1154 } | |
1155 | |
1156 class DebugVC50SrcModFileDescImpl implements DebugVC50SrcModFileDesc { | |
1157 private short cSeg; | |
1158 private MemoizedObject baseSrcLn; | |
1159 private MemoizedObject segOffsets; | |
1160 private MemoizedObject name; | |
1161 | |
1162 DebugVC50SrcModFileDescImpl(final int offset, final int baseOffset) { | |
1163 seek(offset); | |
1164 cSeg = readShort(); | |
1165 | |
1166 baseSrcLn = new MemoizedObject() { | |
1167 public Object computeValue() { | |
1168 seek(offset + 4); | |
1169 int[] offsets = new int[getNumCodeSegments()]; | |
1170 for (int i = 0; i < getNumCodeSegments(); i++) { | |
1171 offsets[i] = baseOffset + readInt(); | |
1172 } | |
1173 DebugVC50SrcModLineNumberMapImpl[] res = | |
1174 new DebugVC50SrcModLineNumberMapImpl[getNumCodeSegments()]; | |
1175 for (int i = 0; i < getNumCodeSegments(); i++) { | |
1176 res[i] = new DebugVC50SrcModLineNumberMapImpl(offsets[i]); | |
1177 } | |
1178 return res; | |
1179 } | |
1180 }; | |
1181 | |
1182 segOffsets = new MemoizedObject() { | |
1183 public Object computeValue() { | |
1184 seek(offset + 4 * (getNumCodeSegments() + 1)); | |
1185 int[] res = new int[2 * getNumCodeSegments()]; | |
1186 for (int i = 0; i < 2 * getNumCodeSegments(); i++) { | |
1187 res[i] = readInt(); | |
1188 } | |
1189 return res; | |
1190 } | |
1191 }; | |
1192 | |
1193 name = new MemoizedObject() { | |
1194 public Object computeValue() { | |
1195 seek(offset + 4 + 12 * getNumCodeSegments()); | |
1196 // NOTE: spec says name length is two bytes, but it's really one | |
1197 int cbName = readByte() & 0xFF; | |
1198 byte[] res = new byte[cbName]; | |
1199 readBytes(res); | |
1200 try { | |
1201 return new String(res, US_ASCII); | |
1202 } catch (UnsupportedEncodingException e) { | |
1203 throw new COFFException(e); | |
1204 } | |
1205 } | |
1206 }; | |
1207 } | |
1208 | |
1209 public int getNumCodeSegments() { return cSeg & 0xFFFF; } | |
1210 | |
1211 public DebugVC50SrcModLineNumberMap getLineNumberMap(int i) { | |
1212 return ((DebugVC50SrcModLineNumberMapImpl[]) baseSrcLn.getValue())[i]; | |
1213 } | |
1214 | |
1215 public int getSegmentStartOffset(int i) { | |
1216 return ((int[]) segOffsets.getValue())[2*i]; | |
1217 } | |
1218 | |
1219 public int getSegmentEndOffset(int i) { | |
1220 return ((int[]) segOffsets.getValue())[2*i+1]; | |
1221 } | |
1222 | |
1223 public String getSourceFileName() { | |
1224 return (String) name.getValue(); | |
1225 } | |
1226 } | |
1227 | |
1228 class DebugVC50SrcModLineNumberMapImpl implements DebugVC50SrcModLineNumberMap { | |
1229 private short seg; | |
1230 private short cPair; | |
1231 private MemoizedObject offsets; | |
1232 private MemoizedObject lineNumbers; | |
1233 | |
1234 DebugVC50SrcModLineNumberMapImpl(final int offset) { | |
1235 seek(offset); | |
1236 seg = readShort(); | |
1237 cPair = readShort(); | |
1238 offsets = new MemoizedObject() { | |
1239 public Object computeValue() { | |
1240 seek(offset + 4); | |
1241 int[] res = new int[getNumSourceLinePairs()]; | |
1242 for (int i = 0; i < getNumSourceLinePairs(); i++) { | |
1243 res[i] = readInt(); | |
1244 } | |
1245 return res; | |
1246 } | |
1247 }; | |
1248 | |
1249 lineNumbers = new MemoizedObject() { | |
1250 public Object computeValue() { | |
1251 seek(offset + 4 * (getNumSourceLinePairs() + 1)); | |
1252 short[] res = new short[getNumSourceLinePairs()]; | |
1253 for (int i = 0; i < getNumSourceLinePairs(); i++) { | |
1254 res[i] = readShort(); | |
1255 } | |
1256 return res; | |
1257 } | |
1258 }; | |
1259 } | |
1260 | |
1261 public int getSegment() { return seg; } | |
1262 public int getNumSourceLinePairs() { return cPair; } | |
1263 public int getCodeOffset(int i) { | |
1264 return ((int[]) offsets.getValue())[i]; | |
1265 } | |
1266 public int getLineNumber(int i) { | |
1267 return ((short[]) lineNumbers.getValue())[i] & 0xFFFF; | |
1268 } | |
1269 } | |
1270 | |
1271 class DebugVC50SSLibrariesImpl extends DebugVC50SubsectionImpl implements DebugVC50SSLibraries { | |
1272 DebugVC50SSLibrariesImpl(short ssType, short iMod, int ssSize, int offset) { | |
1273 super(ssType, iMod, ssSize, offset); | |
1274 } | |
1275 | |
1276 // FIXME: NOT FINISHED | |
1277 } | |
1278 | |
1279 class DebugVC50SSSymbolBaseImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSymbolBase { | |
1280 private int offset; | |
1281 private short symHash; | |
1282 private short addrHash; | |
1283 private int cbSymbol; | |
1284 private int cbSymHash; | |
1285 private int cbAddrHash; | |
1286 | |
1287 private static final int HEADER_SIZE = 16; | |
1288 | |
1289 DebugVC50SSSymbolBaseImpl(short ssType, short iMod, int ssSize, int offset) { | |
1290 super(ssType, iMod, ssSize, offset); | |
1291 this.offset = offset; | |
1292 seek(offset); | |
1293 symHash = readShort(); | |
1294 addrHash = readShort(); | |
1295 cbSymbol = readInt(); | |
1296 cbSymHash = readInt(); | |
1297 cbAddrHash = readInt(); | |
1298 } | |
1299 | |
1300 public short getSymHashIndex() { return symHash; } | |
1301 public short getAddrHashIndex() { return addrHash; } | |
1302 public int getSymTabSize() { return cbSymbol; } | |
1303 public int getSymHashSize() { return cbSymHash; } | |
1304 public int getAddrHashSize() { return cbAddrHash; } | |
1305 | |
1306 public DebugVC50SymbolIterator getSymbolIterator() { | |
1307 return new DebugVC50SymbolIteratorImpl(offset + HEADER_SIZE, cbSymbol); | |
1308 } | |
1309 } | |
1310 | |
1311 class DebugVC50SSGlobalSymImpl extends DebugVC50SSSymbolBaseImpl implements DebugVC50SSGlobalSym { | |
1312 DebugVC50SSGlobalSymImpl(short ssType, short iMod, int ssSize, int offset) { | |
1313 super(ssType, iMod, ssSize, offset); | |
1314 } | |
1315 } | |
1316 class DebugVC50SSGlobalPubImpl extends DebugVC50SSSymbolBaseImpl implements DebugVC50SSGlobalPub { | |
1317 DebugVC50SSGlobalPubImpl(short ssType, short iMod, int ssSize, int offset) { | |
1318 super(ssType, iMod, ssSize, offset); | |
1319 } | |
1320 } | |
1321 | |
1322 class DebugVC50SSGlobalTypesImpl extends DebugVC50SubsectionImpl implements DebugVC50SSGlobalTypes { | |
1323 private int offset; | |
1324 private int cType; | |
1325 | |
1326 DebugVC50SSGlobalTypesImpl(short ssType, short iMod, int ssSize, int offset) { | |
1327 super(ssType, iMod, ssSize, offset); | |
1328 this.offset = offset; | |
1329 seek(offset); | |
1330 readInt(); // Discard "flags" | |
1331 cType = readInt(); | |
1332 } | |
1333 | |
1334 public int getNumTypes() { return cType; } | |
1335 // FIXME: should memoize these | |
1336 public int getTypeOffset(int i) { | |
1337 seek(offset + 4 * (i + 2)); | |
1338 return readInt() + offsetOfFirstType(); | |
1339 } | |
1340 | |
1341 public DebugVC50TypeIterator getTypeIterator() { | |
1342 return new DebugVC50TypeIteratorImpl(this, | |
1343 offsetOfFirstType(), | |
1344 cType); | |
1345 } | |
1346 | |
1347 private int offsetOfFirstType() { | |
1348 return offset + 4 * (getNumTypes() + 2); | |
1349 } | |
1350 } | |
1351 | |
1352 class DebugVC50SSMPCImpl extends DebugVC50SubsectionImpl implements DebugVC50SSMPC { | |
1353 DebugVC50SSMPCImpl(short ssType, short iMod, int ssSize, int offset) { | |
1354 super(ssType, iMod, ssSize, offset); | |
1355 } | |
1356 } | |
1357 | |
1358 class DebugVC50SSSegMapImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSegMap { | |
1359 private short cSeg; | |
1360 private short cSegLog; | |
1361 private MemoizedObject segDescs; | |
1362 | |
1363 DebugVC50SSSegMapImpl(short ssType, short iMod, int ssSize, final int offset) { | |
1364 super(ssType, iMod, ssSize, offset); | |
1365 seek(offset); | |
1366 cSeg = readShort(); | |
1367 cSegLog = readShort(); | |
1368 segDescs = new MemoizedObject() { | |
1369 public Object computeValue() { | |
1370 DebugVC50SegDesc[] descs = new DebugVC50SegDesc[cSeg]; | |
1371 for (int i = 0; i < cSeg; i++) { | |
1372 descs[i] = new DebugVC50SegDescImpl(offset + 4 + (20 * i)); | |
1373 } | |
1374 return descs; | |
1375 } | |
1376 }; | |
1377 } | |
1378 | |
1379 public short getNumSegDesc() { return cSeg; } | |
1380 public short getNumLogicalSegDesc() { return cSegLog; } | |
1381 public DebugVC50SegDesc getSegDesc(int i) { return ((DebugVC50SegDesc[]) segDescs.getValue())[i]; } | |
1382 } | |
1383 | |
1384 class DebugVC50SegDescImpl implements DebugVC50SegDesc { | |
1385 private short flags; | |
1386 private short ovl; | |
1387 private short group; | |
1388 private short frame; | |
1389 private short iSegName; | |
1390 private short iClassName; | |
1391 private int offset; | |
1392 private int cbSeg; | |
1393 | |
1394 DebugVC50SegDescImpl(int offset) { | |
1395 seek(offset); | |
1396 flags = readShort(); | |
1397 ovl = readShort(); | |
1398 group = readShort(); | |
1399 frame = readShort(); | |
1400 iSegName = readShort(); | |
1401 iClassName = readShort(); | |
1402 offset = readInt(); | |
1403 cbSeg = readInt(); | |
1404 } | |
1405 | |
1406 public short getFlags() { return flags; } | |
1407 public short getOverlayNum() { return ovl; } | |
1408 public short getGroup() { return group; } | |
1409 public short getFrame() { return frame; } | |
1410 public short getName() { return iSegName; } | |
1411 public short getClassName() { return iClassName; } | |
1412 public int getOffset() { return offset; } | |
1413 public int getSize() { return cbSeg; } | |
1414 } | |
1415 | |
1416 | |
1417 class DebugVC50SSSegNameImpl extends DebugVC50SubsectionImpl implements DebugVC50SSSegName { | |
1418 private int offset; | |
1419 private int size; | |
1420 private MemoizedObject names; | |
1421 | |
1422 DebugVC50SSSegNameImpl(short ssType, short iMod, int ssSize, int offset) { | |
1423 super(ssType, iMod, ssSize, offset); | |
1424 this.offset = offset; | |
1425 this.size = ssSize; | |
1426 seek(offset); | |
1427 names = new MemoizedObject() { | |
1428 public Object computeValue() { | |
1429 int i = 0; | |
1430 List data = new ArrayList(); | |
1431 while (i < size) { | |
1432 String s = readCString(); | |
1433 data.add(s); | |
1434 i += s.length(); | |
1435 } | |
1436 String[] res = new String[data.size()]; | |
1437 res = (String[]) data.toArray(res); | |
1438 return res; | |
1439 } | |
1440 }; | |
1441 } | |
1442 | |
1443 public String getSegName(int i) { | |
1444 return ((String[]) names.getValue())[i]; | |
1445 } | |
1446 } | |
1447 | |
1448 class DebugVC50SSPreCompImpl extends DebugVC50SubsectionImpl implements DebugVC50SSPreComp { | |
1449 DebugVC50SSPreCompImpl(short ssType, short iMod, int ssSize, int offset) { | |
1450 super(ssType, iMod, ssSize, offset); | |
1451 } | |
1452 } | |
1453 | |
1454 class DebugVC50SSOffsetMap16Impl extends DebugVC50SubsectionImpl implements DebugVC50SSOffsetMap16 { | |
1455 DebugVC50SSOffsetMap16Impl(short ssType, short iMod, int ssSize, int offset) { | |
1456 super(ssType, iMod, ssSize, offset); | |
1457 } | |
1458 } | |
1459 | |
1460 class DebugVC50SSOffsetMap32Impl extends DebugVC50SubsectionImpl implements DebugVC50SSOffsetMap32 { | |
1461 DebugVC50SSOffsetMap32Impl(short ssType, short iMod, int ssSize, int offset) { | |
1462 super(ssType, iMod, ssSize, offset); | |
1463 } | |
1464 } | |
1465 | |
1466 class DebugVC50SSFileIndexImpl extends DebugVC50SubsectionImpl implements DebugVC50SSFileIndex { | |
1467 private int offset; | |
1468 private short cMod; // Number of modules in the executable | |
1469 private short cRef; // Total number of file name references | |
1470 private MemoizedObject modStart; | |
1471 private MemoizedObject cRefCnt; | |
1472 // FIXME: probably useless; needs fixup to be converted into | |
1473 // indices rather than offsets | |
1474 private MemoizedObject nameRef; | |
1475 private MemoizedObject names; | |
1476 | |
1477 DebugVC50SSFileIndexImpl(short ssType, short iMod, int ssSize, final int offset) { | |
1478 super(ssType, iMod, ssSize, offset); | |
1479 this.offset = offset; | |
1480 seek(offset); | |
1481 cMod = readShort(); | |
1482 cRef = readShort(); | |
1483 modStart = new MemoizedObject() { | |
1484 public Object computeValue() { | |
1485 short[] vals = new short[cMod]; | |
1486 seek(4 + offset); | |
1487 for (int i = 0; i < cMod; i++) { | |
1488 vals[i] = readShort(); | |
1489 } | |
1490 return vals; | |
1491 } | |
1492 }; | |
1493 cRefCnt = new MemoizedObject() { | |
1494 public Object computeValue() { | |
1495 short[] vals = new short[cMod]; | |
1496 seek(4 + offset + (2 * cMod)); | |
1497 for (int i = 0; i < cMod; i++) { | |
1498 vals[i] = readShort(); | |
1499 } | |
1500 return vals; | |
1501 } | |
1502 }; | |
1503 nameRef = new MemoizedObject() { | |
1504 public Object computeValue() { | |
1505 int[] vals = new int[cRef]; | |
1506 seek(4 + offset + (4 * cMod)); | |
1507 for (int i = 0; i < cMod; i++) { | |
1508 vals[i] = readInt(); | |
1509 } | |
1510 return vals; | |
1511 } | |
1512 }; | |
1513 names = new MemoizedObject() { | |
1514 public Object computeValue() { | |
1515 String[] vals = new String[cRef]; | |
1516 for (int i = 0; i < cRef; i++) { | |
1517 vals[i] = readCString(); | |
1518 } | |
1519 return vals; | |
1520 } | |
1521 }; | |
1522 } | |
1523 | |
1524 public short getNumModules() { return cMod; } | |
1525 public short getNumReferences() { return cRef; } | |
1526 public short[] getModStart() { return (short[]) modStart.getValue(); } | |
1527 public short[] getRefCount() { return (short[]) cRefCnt.getValue(); } | |
1528 public int[] getNameRef() { return (int[]) nameRef.getValue(); } | |
1529 public String[] getNames() { return (String[]) names.getValue(); } | |
1530 } | |
1531 | |
1532 class DebugVC50SSStaticSymImpl extends DebugVC50SSSymbolBaseImpl implements DebugVC50SSStaticSym { | |
1533 DebugVC50SSStaticSymImpl(short ssType, short iMod, int ssSize, int offset) { | |
1534 super(ssType, iMod, ssSize, offset); | |
1535 } | |
1536 } | |
1537 | |
1538 ////////////////////////////////////////////////// | |
1539 // // | |
1540 // Implementations of symbol and type iterators // | |
1541 // // | |
1542 ////////////////////////////////////////////////// | |
1543 | |
1544 class DebugVC50SymbolIteratorImpl implements DebugVC50SymbolIterator { | |
1545 private int base; | |
1546 private int size; | |
1547 private int pos; | |
1548 private int curSymSize; | |
1549 private int curSymType; | |
1550 | |
1551 private static final int HEADER_SIZE = 4; | |
1552 | |
1553 DebugVC50SymbolIteratorImpl(int base, int size) { | |
1554 this(base, size, base); | |
1555 } | |
1556 | |
1557 private DebugVC50SymbolIteratorImpl(int base, int size, int pos) { | |
1558 this.base = base; | |
1559 this.size = size; | |
1560 this.pos = pos; | |
1561 seek(pos); | |
1562 curSymSize = readShort() & 0xFFFF; | |
1563 curSymType = readShort() & 0xFFFF; | |
1564 } | |
1565 | |
1566 public boolean done() { | |
1567 return (pos == (base + size)); | |
1568 } | |
1569 | |
1570 public void next() throws NoSuchElementException { | |
1571 if (done()) throw new NoSuchElementException("No more symbols"); | |
1572 pos += curSymSize + 2; | |
1573 seek(pos); | |
1574 curSymSize = readShort() & 0xFFFF; | |
1575 curSymType = readShort() & 0xFFFF; | |
1576 } | |
1577 | |
1578 public short getLength() { | |
1579 return (short) curSymSize; | |
1580 } | |
1581 | |
1582 public int getType() { | |
1583 return curSymType; | |
1584 } | |
1585 | |
1586 public int getOffset() { | |
1587 return pos + HEADER_SIZE; | |
1588 } | |
1589 | |
1590 ///////////////////////// | |
1591 // S_COMPILE accessors // | |
1592 ///////////////////////// | |
1593 | |
1594 public byte getCompilerTargetProcessor() { | |
1595 symSeek(0); | |
1596 return readByte(); | |
1597 } | |
1598 | |
1599 public int getCompilerFlags() { | |
1600 symSeek(1); | |
1601 int res = 0; | |
1602 for (int i = 0; i < 3; i++) { | |
1603 int b = readByte() & 0xFF; | |
1604 res = (res << 8) | b; | |
1605 } | |
1606 return res; | |
1607 } | |
1608 | |
1609 public String getComplierVersion() { | |
1610 return readLengthPrefixedStringAt(4); | |
1611 } | |
1612 | |
1613 ////////////////////////// | |
1614 // S_REGISTER accessors // | |
1615 ////////////////////////// | |
1616 | |
1617 public int getRegisterSymbolType() { | |
1618 symSeek(0); | |
1619 return readInt(); | |
1620 } | |
1621 | |
1622 public short getRegisterEnum() { | |
1623 symSeek(4); | |
1624 return readShort(); | |
1625 } | |
1626 | |
1627 public String getRegisterSymbolName() { | |
1628 return readLengthPrefixedStringAt(6); | |
1629 } | |
1630 | |
1631 ////////////////////////// | |
1632 // S_CONSTANT accessors // | |
1633 ////////////////////////// | |
1634 | |
1635 public int getConstantType() { | |
1636 symSeek(0); | |
1637 return readInt(); | |
1638 } | |
1639 | |
1640 public int getConstantValueAsInt() throws DebugVC50WrongNumericTypeException { | |
1641 return readIntNumericLeafAt(4); | |
1642 } | |
1643 | |
1644 public long getConstantValueAsLong() throws DebugVC50WrongNumericTypeException { | |
1645 return readLongNumericLeafAt(4); | |
1646 } | |
1647 | |
1648 public float getConstantValueAsFloat() throws DebugVC50WrongNumericTypeException { | |
1649 return readFloatNumericLeafAt(4); | |
1650 } | |
1651 | |
1652 public double getConstantValueAsDouble() throws DebugVC50WrongNumericTypeException { | |
1653 return readDoubleNumericLeafAt(4); | |
1654 } | |
1655 | |
1656 public String getConstantName() { | |
1657 return readLengthPrefixedStringAt(4 + numericLeafLengthAt(4)); | |
1658 } | |
1659 | |
1660 ///////////////////// | |
1661 // S_UDT accessors // | |
1662 ///////////////////// | |
1663 | |
1664 public int getUDTType() { | |
1665 symSeek(0); | |
1666 return readInt(); | |
1667 } | |
1668 | |
1669 public String getUDTName() { | |
1670 return readLengthPrefixedStringAt(4); | |
1671 } | |
1672 | |
1673 ///////////////////////// | |
1674 // S_SSEARCH accessors // | |
1675 ///////////////////////// | |
1676 | |
1677 public int getSearchSymbolOffset() { | |
1678 symSeek(0); | |
1679 return readInt(); | |
1680 } | |
1681 | |
1682 public short getSearchSegment() { | |
1683 symSeek(4); | |
1684 return readShort(); | |
1685 } | |
1686 | |
1687 ///////////////////// | |
1688 // S_END accessors // | |
1689 ///////////////////// | |
1690 | |
1691 // (No accessors) | |
1692 | |
1693 ////////////////////// | |
1694 // S_SKIP accessors // | |
1695 ////////////////////// | |
1696 | |
1697 // (No accessors) | |
1698 | |
1699 /////////////////////////// | |
1700 // S_CVRESERVE accessors // | |
1701 /////////////////////////// | |
1702 | |
1703 // (No accessors) | |
1704 | |
1705 ///////////////////////// | |
1706 // S_OBJNAME accessors // | |
1707 ///////////////////////// | |
1708 | |
1709 public int getObjectCodeViewSignature() { | |
1710 symSeek(0); | |
1711 return readInt(); | |
1712 } | |
1713 | |
1714 public String getObjectName() { | |
1715 return readLengthPrefixedStringAt(4); | |
1716 } | |
1717 | |
1718 //////////////////////// | |
1719 // S_ENDARG accessors // | |
1720 //////////////////////// | |
1721 | |
1722 // (No accessors) | |
1723 | |
1724 ////////////////////////// | |
1725 // S_COBOLUDT accessors // | |
1726 ////////////////////////// | |
1727 | |
1728 // (Elided as they are irrelevant) | |
1729 | |
1730 ///////////////////////// | |
1731 // S_MANYREG accessors // | |
1732 ///////////////////////// | |
1733 | |
1734 public int getManyRegType() { | |
1735 symSeek(0); | |
1736 return readInt(); | |
1737 } | |
1738 | |
1739 public byte getManyRegCount() { | |
1740 symSeek(4); | |
1741 return readByte(); | |
1742 } | |
1743 | |
1744 public byte getManyRegRegister(int i) { | |
1745 symSeek(5 + i); | |
1746 return readByte(); | |
1747 } | |
1748 | |
1749 public String getManyRegName() { | |
1750 return readLengthPrefixedStringAt(5 + getManyRegCount()); | |
1751 } | |
1752 | |
1753 //////////////////////// | |
1754 // S_RETURN accessors // | |
1755 //////////////////////// | |
1756 | |
1757 public short getReturnFlags() { | |
1758 symSeek(0); | |
1759 return readShort(); | |
1760 } | |
1761 | |
1762 public byte getReturnStyle() { | |
1763 symSeek(2); | |
1764 return readByte(); | |
1765 } | |
1766 | |
1767 public byte getReturnRegisterCount() { | |
1768 symSeek(3); | |
1769 return readByte(); | |
1770 } | |
1771 | |
1772 public byte getReturnRegister(int i) { | |
1773 symSeek(4 + i); | |
1774 return readByte(); | |
1775 } | |
1776 | |
1777 /////////////////////////// | |
1778 // S_ENTRYTHIS accessors // | |
1779 /////////////////////////// | |
1780 | |
1781 public void advanceToEntryThisSymbol() { | |
1782 seek(pos + 4); | |
1783 int tmpSymSize = readShort(); | |
1784 int tmpSymType = readShort(); | |
1785 if (Assert.ASSERTS_ENABLED) { | |
1786 // Make sure that ends of inner and outer symbols line | |
1787 // up, otherwise need more work | |
1788 Assert.that(pos + curSymSize + 2 == pos + 4 + tmpSymSize, | |
1789 "advanceToEntryThisSymbol needs more work"); | |
1790 } | |
1791 pos += 4; | |
1792 curSymSize = tmpSymSize; | |
1793 curSymType = tmpSymType; | |
1794 } | |
1795 | |
1796 /////////////////////////////////////////////////////////////////////// | |
1797 // // | |
1798 // // | |
1799 // Symbols for (Intel) 16:32 Segmented and 32-bit Flat Architectures // | |
1800 // // | |
1801 // // | |
1802 /////////////////////////////////////////////////////////////////////// | |
1803 | |
1804 ///////////////////////// | |
1805 // S_BPREL32 accessors // | |
1806 ///////////////////////// | |
1807 | |
1808 public int getBPRelOffset() { | |
1809 symSeek(0); | |
1810 return readInt(); | |
1811 } | |
1812 | |
1813 public int getBPRelType() { | |
1814 symSeek(4); | |
1815 return readInt(); | |
1816 } | |
1817 | |
1818 public String getBPRelName() { | |
1819 return readLengthPrefixedStringAt(8); | |
1820 } | |
1821 | |
1822 /////////////////////////////////////// | |
1823 // S_LDATA32 and S_GDATA32 accessors // | |
1824 /////////////////////////////////////// | |
1825 | |
1826 public int getLGDataType() { | |
1827 symSeek(0); | |
1828 return readInt(); | |
1829 } | |
1830 | |
1831 public int getLGDataOffset() { | |
1832 symSeek(4); | |
1833 return readInt(); | |
1834 } | |
1835 | |
1836 public short getLGDataSegment() { | |
1837 symSeek(8); | |
1838 return readShort(); | |
1839 } | |
1840 | |
1841 public String getLGDataName() { | |
1842 return readLengthPrefixedStringAt(10); | |
1843 } | |
1844 | |
1845 /////////////////////// | |
1846 // S_PUB32 accessors // | |
1847 /////////////////////// | |
1848 | |
1849 // FIXME: has the same format as the above; consider updating | |
1850 // documentation. No separate accessors provided. | |
1851 | |
1852 /////////////////////////////////////// | |
1853 // S_LPROC32 and S_GPROC32 accessors // | |
1854 /////////////////////////////////////// | |
1855 | |
1856 public DebugVC50SymbolIterator getLGProcParent() { | |
1857 int offs = getLGProcParentOffset(); | |
1858 if (offs == 0) return null; | |
1859 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
1860 } | |
1861 | |
1862 public int getLGProcParentOffset() { | |
1863 symSeek(0); | |
1864 int offs = readInt(); | |
1865 if (offs == 0) return 0; | |
1866 return base + offs; | |
1867 } | |
1868 | |
1869 public DebugVC50SymbolIterator getLGProcEnd() { | |
1870 int offs = getLGProcEndOffset(); | |
1871 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
1872 } | |
1873 | |
1874 public int getLGProcEndOffset() { | |
1875 symSeek(4); | |
1876 int offs = readInt(); | |
1877 if (Assert.ASSERTS_ENABLED) { | |
1878 Assert.that(offs != 0, "should not have null end offset for procedure symbols"); | |
1879 } | |
1880 return base + offs; | |
1881 } | |
1882 | |
1883 public DebugVC50SymbolIterator getLGProcNext() { | |
1884 int offs = getLGProcNextOffset(); | |
1885 if (offs == 0) return null; | |
1886 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
1887 } | |
1888 | |
1889 public int getLGProcNextOffset() { | |
1890 symSeek(8); | |
1891 int offs = readInt(); | |
1892 if (offs == 0) return 0; | |
1893 return base + offs; | |
1894 } | |
1895 | |
1896 public int getLGProcLength() { | |
1897 symSeek(12); | |
1898 return readInt(); | |
1899 } | |
1900 | |
1901 public int getLGProcDebugStart() { | |
1902 symSeek(16); | |
1903 return readInt(); | |
1904 } | |
1905 | |
1906 public int getLGProcDebugEnd() { | |
1907 symSeek(20); | |
1908 return readInt(); | |
1909 } | |
1910 | |
1911 public int getLGProcType() { | |
1912 symSeek(24); | |
1913 return readInt(); | |
1914 } | |
1915 | |
1916 public int getLGProcOffset() { | |
1917 symSeek(28); | |
1918 return readInt(); | |
1919 } | |
1920 | |
1921 public short getLGProcSegment() { | |
1922 symSeek(32); | |
1923 return readShort(); | |
1924 } | |
1925 | |
1926 public byte getLGProcFlags() { | |
1927 symSeek(34); | |
1928 return readByte(); | |
1929 } | |
1930 | |
1931 public String getLGProcName() { | |
1932 return readLengthPrefixedStringAt(35); | |
1933 } | |
1934 | |
1935 ///////////////////////// | |
1936 // S_THUNK32 accessors // | |
1937 ///////////////////////// | |
1938 | |
1939 public DebugVC50SymbolIterator getThunkParent() { | |
1940 int offs = getThunkParentOffset(); | |
1941 if (offs == 0) return null; | |
1942 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
1943 } | |
1944 | |
1945 public int getThunkParentOffset() { | |
1946 symSeek(0); | |
1947 int offs = readInt(); | |
1948 if (offs == 0) return 0; | |
1949 return base + offs; | |
1950 } | |
1951 | |
1952 public DebugVC50SymbolIterator getThunkEnd() { | |
1953 symSeek(4); | |
1954 int offs = readInt(); | |
1955 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
1956 } | |
1957 | |
1958 public int getThunkEndOffset() { | |
1959 symSeek(4); | |
1960 int offs = readInt(); | |
1961 if (Assert.ASSERTS_ENABLED) { | |
1962 Assert.that(offs != 0, "should not have null end offset for thunk symbols"); | |
1963 } | |
1964 return base + offs; | |
1965 } | |
1966 | |
1967 public DebugVC50SymbolIterator getThunkNext() { | |
1968 int offs = getThunkNextOffset(); | |
1969 if (offs == 0) return null; | |
1970 return new DebugVC50SymbolIteratorImpl(base, size, base + offs); | |
1971 } | |
1972 | |
1973 public int getThunkNextOffset() { | |
1974 symSeek(8); | |
1975 int offs = readInt(); | |
1976 if (offs == 0) return 0; | |
1977 return base + offs; | |
1978 } | |
1979 | |
1980 public int getThunkOffset() { | |
1981 symSeek(12); | |
1982 return readInt(); | |
1983 } | |
1984 | |
1985 public short getThunkSegment() { | |
1986 symSeek(16); | |
1987 return readShort(); | |
1988 } | |
1989 | |
1990 public short getThunkLength() { | |
1991 symSeek(18); | |
1992 return readShort(); | |
1993 } | |
1994 | |
1995 public byte getThunkType() { | |
1996 symSeek(20); | |
1997 return readByte(); | |
1998 } | |
1999 | |
2000 public String getThunkName() { | |
2001 return readLengthPrefixedStringAt(21); | |
2002 } | |
2003 | |
2004 public short getThunkAdjustorThisDelta() { | |
2005 symSeek(21 + lengthPrefixedStringLengthAt(21)); | |
2006 return readShort(); | |
2007 } | |
2008 | |
2009 public String getThunkAdjustorTargetName() { | |
2010 return readLengthPrefixedStringAt(23 + lengthPrefixedStringLengthAt(21)); | |
2011 } | |
2012 | |
2013 public short getThunkVCallDisplacement() { | |
2014 symSeek(21 + lengthPrefixedStringLengthAt(21)); | |
2015 return readShort(); | |
2016 } | |
2017 | |
2018 public int getThunkPCodeOffset() { | |
2019 symSeek(21 + lengthPrefixedStringLengthAt(21)); | |
2020 return readInt(); | |
2021 } | |
2022 | |
2023 public short getThunkPCodeSegment() { | |
2024 symSeek(25 + lengthPrefixedStringLengthAt(21)); | |
2025 return readShort(); | |
2026 } | |
2027 | |
2028 ///////////////////////// | |
2029 // S_BLOCK32 accessors // | |
2030 ///////////////////////// | |
2031 | |
2032 public DebugVC50SymbolIterator getBlockParent() { | |
2033 int offs = getBlockParentOffset(); | |
2034 if (offs == 0) return null; | |
2035 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
2036 } | |
2037 | |
2038 public int getBlockParentOffset() { | |
2039 symSeek(0); | |
2040 int offs = readInt(); | |
2041 if (offs == 0) return 0; | |
2042 return base + offs; | |
2043 } | |
2044 | |
2045 public DebugVC50SymbolIterator getBlockEnd() { | |
2046 symSeek(4); | |
2047 int offs = readInt(); | |
2048 return new DebugVC50SymbolIteratorImpl(base, size, offs); | |
2049 } | |
2050 | |
2051 public int getBlockEndOffset() { | |
2052 symSeek(4); | |
2053 int offs = readInt(); | |
2054 if (Assert.ASSERTS_ENABLED) { | |
2055 Assert.that(offs != 0, "should not have null end offset for block symbols"); | |
2056 } | |
2057 return base + offs; | |
2058 } | |
2059 | |
2060 public int getBlockLength() { | |
2061 symSeek(8); | |
2062 return readInt(); | |
2063 } | |
2064 | |
2065 public int getBlockOffset() { | |
2066 symSeek(12); | |
2067 return readInt(); | |
2068 } | |
2069 | |
2070 public short getBlockSegment() { | |
2071 symSeek(16); | |
2072 return readShort(); | |
2073 } | |
2074 | |
2075 public String getBlockName() { | |
2076 return readLengthPrefixedStringAt(18); | |
2077 } | |
2078 | |
2079 //////////////////////// | |
2080 // S_WITH32 accessors // | |
2081 //////////////////////// | |
2082 | |
2083 // FIXME: this is a Pascal construct; ignored for now | |
2084 | |
2085 ///////////////////////// | |
2086 // S_LABEL32 accessors // | |
2087 ///////////////////////// | |
2088 | |
2089 public int getLabelOffset() { | |
2090 symSeek(0); | |
2091 return readInt(); | |
2092 } | |
2093 | |
2094 public short getLabelSegment() { | |
2095 symSeek(4); | |
2096 return readShort(); | |
2097 } | |
2098 | |
2099 public byte getLabelFlags() { | |
2100 symSeek(6); | |
2101 return readByte(); | |
2102 } | |
2103 | |
2104 public String getLabelName() { | |
2105 return readLengthPrefixedStringAt(7); | |
2106 } | |
2107 | |
2108 //////////////////////////// | |
2109 // S_CEXMODEL32 accessors // | |
2110 //////////////////////////// | |
2111 | |
2112 public int getChangeOffset() { | |
2113 symSeek(0); | |
2114 return readInt(); | |
2115 } | |
2116 | |
2117 public short getChangeSegment() { | |
2118 symSeek(4); | |
2119 return readShort(); | |
2120 } | |
2121 | |
2122 public short getChangeModel() { | |
2123 symSeek(6); | |
2124 return readShort(); | |
2125 } | |
2126 | |
2127 //////////////////////////// | |
2128 // S_VFTTABLE32 accessors // | |
2129 //////////////////////////// | |
2130 | |
2131 public int getVTableRoot() { | |
2132 symSeek(0); | |
2133 return readInt(); | |
2134 } | |
2135 | |
2136 public int getVTablePath() { | |
2137 symSeek(4); | |
2138 return readInt(); | |
2139 } | |
2140 | |
2141 public int getVTableOffset() { | |
2142 symSeek(8); | |
2143 return readInt(); | |
2144 } | |
2145 | |
2146 public short getVTableSegment() { | |
2147 symSeek(12); | |
2148 return readShort(); | |
2149 } | |
2150 | |
2151 ////////////////////////// | |
2152 // S_REGREL32 accessors // | |
2153 ////////////////////////// | |
2154 | |
2155 public int getRegRelOffset() { | |
2156 symSeek(0); | |
2157 return readInt(); | |
2158 } | |
2159 | |
2160 public int getRegRelType() { | |
2161 symSeek(4); | |
2162 return readInt(); | |
2163 } | |
2164 | |
2165 public short getRegRelRegister() { | |
2166 symSeek(8); | |
2167 return readShort(); | |
2168 } | |
2169 | |
2170 public String getRegRelName() { | |
2171 return readLengthPrefixedStringAt(10); | |
2172 } | |
2173 | |
2174 /////////////////////////////////////////// | |
2175 // S_LTHREAD32 and S_GTHREAD32 accessors // | |
2176 /////////////////////////////////////////// | |
2177 | |
2178 public int getLThreadType() { | |
2179 symSeek(0); | |
2180 return readInt(); | |
2181 } | |
2182 | |
2183 public int getLThreadOffset() { | |
2184 symSeek(4); | |
2185 return readInt(); | |
2186 } | |
2187 | |
2188 public short getLThreadSegment() { | |
2189 symSeek(8); | |
2190 return readShort(); | |
2191 } | |
2192 | |
2193 public String getLThreadName() { | |
2194 return readLengthPrefixedStringAt(10); | |
2195 } | |
2196 | |
2197 //---------------------------------------------------------------------- | |
2198 // Internals only below this point | |
2199 // | |
2200 | |
2201 private void symSeek(int offsetInSym) { | |
2202 seek(pos + HEADER_SIZE + offsetInSym); | |
2203 } | |
2204 | |
2205 private int numericLeafLengthAt(int offsetInSym) { | |
2206 return DebugVC50Impl.this.numericLeafLengthAt(pos + HEADER_SIZE + offsetInSym); | |
2207 } | |
2208 | |
2209 private int readIntNumericLeafAt(int offsetInSym) { | |
2210 return DebugVC50Impl.this.readIntNumericLeafAt(pos + HEADER_SIZE + offsetInSym); | |
2211 } | |
2212 | |
2213 private long readLongNumericLeafAt(int offsetInSym) { | |
2214 return DebugVC50Impl.this.readLongNumericLeafAt(pos + HEADER_SIZE + offsetInSym); | |
2215 } | |
2216 | |
2217 private float readFloatNumericLeafAt(int offsetInSym) { | |
2218 return DebugVC50Impl.this.readFloatNumericLeafAt(pos + HEADER_SIZE + offsetInSym); | |
2219 } | |
2220 | |
2221 private double readDoubleNumericLeafAt(int offsetInSym) { | |
2222 return DebugVC50Impl.this.readDoubleNumericLeafAt(pos + HEADER_SIZE + offsetInSym); | |
2223 } | |
2224 | |
2225 private int lengthPrefixedStringLengthAt(int offsetInSym) { | |
2226 return DebugVC50Impl.this.lengthPrefixedStringLengthAt(pos + HEADER_SIZE + offsetInSym); | |
2227 } | |
2228 | |
2229 private String readLengthPrefixedStringAt(int offsetInSym) { | |
2230 return DebugVC50Impl.this.readLengthPrefixedStringAt(pos + HEADER_SIZE + offsetInSym); | |
2231 } | |
2232 } | |
2233 | |
2234 class DebugVC50TypeIteratorImpl implements DebugVC50TypeIterator, | |
2235 DebugVC50TypeLeafIndices, DebugVC50MemberAttributes, DebugVC50TypeEnums { | |
2236 private DebugVC50SSGlobalTypes parent; | |
2237 private int base; | |
2238 private int numTypes; | |
2239 private int typeIndex; | |
2240 private int typeRecordOffset; | |
2241 private int typeStringOffset; | |
2242 private int typeRecordSize; | |
2243 private int typeStringLeaf; | |
2244 | |
2245 DebugVC50TypeIteratorImpl(DebugVC50SSGlobalTypes parent, int base, int numTypes) { | |
2246 this(parent, base, numTypes, 0, base); | |
2247 } | |
2248 | |
2249 private DebugVC50TypeIteratorImpl(DebugVC50SSGlobalTypes parent, int base, int numTypes, int curType, int offset) { | |
2250 this.parent = parent; | |
2251 this.base = base; | |
2252 this.numTypes = numTypes; | |
2253 this.typeIndex = curType; | |
2254 if (!done()) { | |
2255 typeRecordOffset = offset; | |
2256 loadTypeRecord(); | |
2257 } | |
2258 } | |
2259 | |
2260 public boolean done() { | |
2261 return (typeIndex == numTypes); | |
2262 } | |
2263 | |
2264 public void next() throws NoSuchElementException { | |
2265 if (done()) throw new NoSuchElementException(); | |
2266 ++typeIndex; | |
2267 if (!done()) { | |
2268 typeRecordOffset = parent.getTypeOffset(typeIndex); | |
2269 loadTypeRecord(); | |
2270 } | |
2271 } | |
2272 | |
2273 public short getLength() { | |
2274 return (short) typeRecordSize; | |
2275 } | |
2276 | |
2277 public int getTypeIndex() { | |
2278 return biasTypeIndex(typeIndex); | |
2279 } | |
2280 | |
2281 public int getNumTypes() { | |
2282 return numTypes; | |
2283 } | |
2284 | |
2285 public boolean typeStringDone() { | |
2286 return (typeStringOffset - typeRecordOffset - 2) >= typeRecordSize; | |
2287 } | |
2288 | |
2289 public void typeStringNext() throws NoSuchElementException { | |
2290 if (typeStringDone()) throw new NoSuchElementException(); | |
2291 typeStringOffset += typeStringLength(); | |
2292 loadTypeString(); | |
2293 } | |
2294 | |
2295 public int typeStringLeaf() { | |
2296 return typeStringLeaf; | |
2297 } | |
2298 | |
2299 public int typeStringOffset() { | |
2300 return typeStringOffset; | |
2301 } | |
2302 | |
2303 /////////////////////////// | |
2304 // LF_MODIFIER accessors // | |
2305 /////////////////////////// | |
2306 | |
2307 public int getModifierIndex() { | |
2308 typeSeek(2); | |
2309 return readInt(); | |
2310 } | |
2311 | |
2312 public short getModifierAttribute() { | |
2313 typeSeek(6); | |
2314 return readShort(); | |
2315 } | |
2316 | |
2317 ////////////////////////// | |
2318 // LF_POINTER accessors // | |
2319 ////////////////////////// | |
2320 | |
2321 public int getPointerType() { | |
2322 typeSeek(2); | |
2323 return readInt(); | |
2324 } | |
2325 | |
2326 public int getPointerAttributes() { | |
2327 typeSeek(6); | |
2328 return readInt(); | |
2329 } | |
2330 | |
2331 public int getPointerBasedOnTypeIndex() { | |
2332 typeSeek(10); | |
2333 return readInt(); | |
2334 } | |
2335 | |
2336 public String getPointerBasedOnTypeName() { | |
2337 return readLengthPrefixedStringAt(14); | |
2338 } | |
2339 | |
2340 public int getPointerToMemberClass() { | |
2341 typeSeek(10); | |
2342 return readInt(); | |
2343 } | |
2344 | |
2345 public short getPointerToMemberFormat() { | |
2346 typeSeek(14); | |
2347 return readShort(); | |
2348 } | |
2349 | |
2350 //////////////////////// | |
2351 // LF_ARRAY accessors // | |
2352 //////////////////////// | |
2353 | |
2354 public int getArrayElementType() { | |
2355 typeSeek(2); | |
2356 return readInt(); | |
2357 } | |
2358 | |
2359 public int getArrayIndexType() { | |
2360 typeSeek(6); | |
2361 return readInt(); | |
2362 } | |
2363 | |
2364 public int getArrayLength() throws DebugVC50WrongNumericTypeException { | |
2365 return readIntNumericLeafAt(10); | |
2366 } | |
2367 | |
2368 public String getArrayName() { | |
2369 return readLengthPrefixedStringAt(10 + numericLeafLengthAt(10)); | |
2370 } | |
2371 | |
2372 ///////////////////////////////////////// | |
2373 // LF_CLASS and LF_STRUCTURE accessors // | |
2374 ///////////////////////////////////////// | |
2375 | |
2376 public short getClassCount() { | |
2377 typeSeek(2); | |
2378 return readShort(); | |
2379 } | |
2380 | |
2381 public short getClassProperty() { | |
2382 typeSeek(4); | |
2383 return readShort(); | |
2384 } | |
2385 | |
2386 public int getClassFieldList() { | |
2387 typeSeek(6); | |
2388 return readInt(); | |
2389 } | |
2390 | |
2391 public DebugVC50TypeIterator getClassFieldListIterator() { | |
2392 int index = unbiasTypeIndex(getClassFieldList()); | |
2393 int offset = parent.getTypeOffset(index); | |
2394 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2395 } | |
2396 | |
2397 public int getClassDerivationList() { | |
2398 typeSeek(10); | |
2399 return readInt(); | |
2400 } | |
2401 | |
2402 public int getClassVShape() { | |
2403 typeSeek(14); | |
2404 return readInt(); | |
2405 } | |
2406 | |
2407 public int getClassSize() throws DebugVC50WrongNumericTypeException { | |
2408 return readIntNumericLeafAt(18); | |
2409 } | |
2410 | |
2411 public String getClassName() { | |
2412 return readLengthPrefixedStringAt(18 + numericLeafLengthAt(18)); | |
2413 } | |
2414 | |
2415 //////////////////////// | |
2416 // LF_UNION accessors // | |
2417 //////////////////////// | |
2418 | |
2419 public short getUnionCount() { | |
2420 typeSeek(2); | |
2421 return readShort(); | |
2422 } | |
2423 | |
2424 public short getUnionProperty() { | |
2425 typeSeek(4); | |
2426 return readShort(); | |
2427 } | |
2428 | |
2429 public int getUnionFieldList() { | |
2430 typeSeek(6); | |
2431 return readInt(); | |
2432 } | |
2433 | |
2434 public DebugVC50TypeIterator getUnionFieldListIterator() { | |
2435 int index = unbiasTypeIndex(getUnionFieldList()); | |
2436 int offset = parent.getTypeOffset(index); | |
2437 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2438 } | |
2439 | |
2440 public int getUnionSize() throws DebugVC50WrongNumericTypeException { | |
2441 return readIntNumericLeafAt(10); | |
2442 } | |
2443 | |
2444 public String getUnionName() { | |
2445 return readLengthPrefixedStringAt(10 + numericLeafLengthAt(10)); | |
2446 } | |
2447 | |
2448 /////////////////////// | |
2449 // LF_ENUM accessors // | |
2450 /////////////////////// | |
2451 | |
2452 public short getEnumCount() { | |
2453 typeSeek(2); | |
2454 return readShort(); | |
2455 } | |
2456 | |
2457 public short getEnumProperty() { | |
2458 typeSeek(4); | |
2459 return readShort(); | |
2460 } | |
2461 | |
2462 public int getEnumType() { | |
2463 typeSeek(6); | |
2464 return readInt(); | |
2465 } | |
2466 | |
2467 public int getEnumFieldList() { | |
2468 typeSeek(10); | |
2469 return readInt(); | |
2470 } | |
2471 | |
2472 public DebugVC50TypeIterator getEnumFieldListIterator() { | |
2473 int index = unbiasTypeIndex(getEnumFieldList()); | |
2474 int offset = parent.getTypeOffset(index); | |
2475 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2476 } | |
2477 | |
2478 public String getEnumName() { | |
2479 return readLengthPrefixedStringAt(14); | |
2480 } | |
2481 | |
2482 //////////////////////////// | |
2483 // LF_PROCEDURE accessors // | |
2484 //////////////////////////// | |
2485 | |
2486 public int getProcedureReturnType() { | |
2487 typeSeek(2); | |
2488 return readInt(); | |
2489 } | |
2490 | |
2491 public byte getProcedureCallingConvention() { | |
2492 typeSeek(6); | |
2493 return readByte(); | |
2494 } | |
2495 | |
2496 public short getProcedureNumberOfParameters() { | |
2497 typeSeek(8); | |
2498 return readShort(); | |
2499 } | |
2500 | |
2501 public int getProcedureArgumentList() { | |
2502 typeSeek(10); | |
2503 return readInt(); | |
2504 } | |
2505 | |
2506 public DebugVC50TypeIterator getProcedureArgumentListIterator() { | |
2507 int index = unbiasTypeIndex(getProcedureArgumentList()); | |
2508 int offset = parent.getTypeOffset(index); | |
2509 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2510 } | |
2511 | |
2512 //////////////////////////// | |
2513 // LF_MFUNCTION accessors // | |
2514 //////////////////////////// | |
2515 | |
2516 public int getMFunctionReturnType() { | |
2517 typeSeek(2); | |
2518 return readInt(); | |
2519 } | |
2520 | |
2521 public int getMFunctionContainingClass() { | |
2522 typeSeek(6); | |
2523 return readInt(); | |
2524 } | |
2525 | |
2526 public int getMFunctionThis() { | |
2527 typeSeek(10); | |
2528 return readInt(); | |
2529 } | |
2530 | |
2531 public byte getMFunctionCallingConvention() { | |
2532 typeSeek(14); | |
2533 return readByte(); | |
2534 } | |
2535 | |
2536 public short getMFunctionNumberOfParameters() { | |
2537 typeSeek(16); | |
2538 return readShort(); | |
2539 } | |
2540 | |
2541 public int getMFunctionArgumentList() { | |
2542 typeSeek(18); | |
2543 return readInt(); | |
2544 } | |
2545 | |
2546 public DebugVC50TypeIterator getMFunctionArgumentListIterator() { | |
2547 int index = unbiasTypeIndex(getMFunctionArgumentList()); | |
2548 int offset = parent.getTypeOffset(index); | |
2549 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2550 } | |
2551 | |
2552 public int getMFunctionThisAdjust() { | |
2553 typeSeek(22); | |
2554 return readInt(); | |
2555 } | |
2556 | |
2557 ////////////////////////// | |
2558 // LF_VTSHAPE accessors // | |
2559 ////////////////////////// | |
2560 | |
2561 public short getVTShapeCount() { | |
2562 typeSeek(2); | |
2563 return readShort(); | |
2564 } | |
2565 | |
2566 public int getVTShapeDescriptor(int i) { | |
2567 typeSeek(4 + (i / 2)); | |
2568 int val = readByte() & 0xFF; | |
2569 if ((i % 2) != 0) { | |
2570 val = val >> 4; | |
2571 } | |
2572 return val; | |
2573 } | |
2574 | |
2575 ///////////////////////// | |
2576 // LF_BARRAY accessors // | |
2577 ///////////////////////// | |
2578 | |
2579 public int getBasicArrayType() { | |
2580 typeSeek(2); | |
2581 return readInt(); | |
2582 } | |
2583 | |
2584 //////////////////////// | |
2585 // LF_LABEL accessors // | |
2586 //////////////////////// | |
2587 | |
2588 public short getLabelAddressMode() { | |
2589 typeSeek(2); | |
2590 return readShort(); | |
2591 } | |
2592 | |
2593 /////////////////////////// | |
2594 // LF_DIMARRAY accessors // | |
2595 /////////////////////////// | |
2596 | |
2597 public int getDimArrayType() { | |
2598 typeSeek(2); | |
2599 return readInt(); | |
2600 } | |
2601 | |
2602 public int getDimArrayDimInfo() { | |
2603 typeSeek(6); | |
2604 return readInt(); | |
2605 } | |
2606 | |
2607 public String getDimArrayName() { | |
2608 return readLengthPrefixedStringAt(10); | |
2609 } | |
2610 | |
2611 ////////////////////////// | |
2612 // LF_VFTPATH accessors // | |
2613 ////////////////////////// | |
2614 | |
2615 public int getVFTPathCount() { | |
2616 typeSeek(2); | |
2617 return readInt(); | |
2618 } | |
2619 | |
2620 public int getVFTPathBase(int i) { | |
2621 typeSeek(6 + (4 * i)); | |
2622 return readInt(); | |
2623 } | |
2624 | |
2625 /////////////////////// | |
2626 // LF_SKIP accessors // | |
2627 /////////////////////// | |
2628 | |
2629 public int getSkipIndex() { | |
2630 typeSeek(2); | |
2631 return readInt(); | |
2632 } | |
2633 | |
2634 ////////////////////////// | |
2635 // LF_ARGLIST accessors // | |
2636 ////////////////////////// | |
2637 | |
2638 public int getArgListCount() { | |
2639 typeSeek(2); | |
2640 return readInt(); | |
2641 } | |
2642 | |
2643 public int getArgListType(int i) { | |
2644 typeSeek(6 + (4 * i)); | |
2645 return readInt(); | |
2646 } | |
2647 | |
2648 ///////////////////////// | |
2649 // LF_DEFARG accessors // | |
2650 ///////////////////////// | |
2651 | |
2652 public int getDefaultArgType() { | |
2653 typeSeek(2); | |
2654 return readInt(); | |
2655 } | |
2656 | |
2657 public String getDefaultArgExpression() { | |
2658 return readLengthPrefixedStringAt(6); | |
2659 } | |
2660 | |
2661 ////////////////////////// | |
2662 // LF_DERIVED accessors // | |
2663 ////////////////////////// | |
2664 | |
2665 public int getDerivedCount() { | |
2666 typeSeek(2); | |
2667 return readInt(); | |
2668 } | |
2669 | |
2670 public int getDerivedType(int i) { | |
2671 typeSeek(6); | |
2672 return readInt(); | |
2673 } | |
2674 | |
2675 /////////////////////////// | |
2676 // LF_BITFIELD accessors // | |
2677 /////////////////////////// | |
2678 | |
2679 public int getBitfieldFieldType() { | |
2680 typeSeek(2); | |
2681 return readInt(); | |
2682 } | |
2683 | |
2684 public byte getBitfieldLength() { | |
2685 typeSeek(6); | |
2686 return readByte(); | |
2687 } | |
2688 | |
2689 public byte getBitfieldPosition() { | |
2690 typeSeek(7); | |
2691 return readByte(); | |
2692 } | |
2693 | |
2694 //////////////////////// | |
2695 // LF_MLIST accessors // | |
2696 //////////////////////// | |
2697 | |
2698 public short getMListAttribute() { | |
2699 typeSeek(2); | |
2700 return readShort(); | |
2701 } | |
2702 | |
2703 public int getMListLength() { | |
2704 return (getLength() - 6 - (isMListIntroducingVirtual() ? 4 : 0)) / 4; | |
2705 } | |
2706 | |
2707 public int getMListType(int i) { | |
2708 typeSeek(6 + 4 * i); | |
2709 return readInt(); | |
2710 } | |
2711 | |
2712 public boolean isMListIntroducingVirtual() { | |
2713 return isIntroducingVirtual(getMListAttribute()); | |
2714 } | |
2715 | |
2716 public int getMListVtabOffset() { | |
2717 typeSeek(6 + 4 * getMListLength()); | |
2718 return readInt(); | |
2719 } | |
2720 | |
2721 ///////////////////////// | |
2722 // LF_REFSYM accessors // | |
2723 ///////////////////////// | |
2724 | |
2725 public DebugVC50SymbolIterator getRefSym() { | |
2726 typeSeek(2); | |
2727 int len = readShort() & 0xFFFF; | |
2728 return new DebugVC50SymbolIteratorImpl(typeStringOffset + 2, len); | |
2729 } | |
2730 | |
2731 ///////////////////////// | |
2732 // LF_BCLASS accessors // | |
2733 ///////////////////////// | |
2734 | |
2735 public short getBClassAttribute() { | |
2736 typeSeek(2); | |
2737 return readShort(); | |
2738 } | |
2739 | |
2740 public int getBClassType() { | |
2741 typeSeek(4); | |
2742 return readInt(); | |
2743 } | |
2744 | |
2745 public int getBClassOffset() throws DebugVC50WrongNumericTypeException { | |
2746 return readIntNumericLeafAt(8); | |
2747 } | |
2748 | |
2749 ////////////////////////// | |
2750 // LF_VBCLASS accessors // | |
2751 ////////////////////////// | |
2752 | |
2753 public short getVBClassAttribute() { | |
2754 typeSeek(2); | |
2755 return readShort(); | |
2756 } | |
2757 | |
2758 public int getVBClassBaseClassType() { | |
2759 typeSeek(4); | |
2760 return readInt(); | |
2761 } | |
2762 | |
2763 public int getVBClassVirtualBaseClassType() { | |
2764 typeSeek(8); | |
2765 return readInt(); | |
2766 } | |
2767 | |
2768 public int getVBClassVBPOff() throws DebugVC50WrongNumericTypeException { | |
2769 return readIntNumericLeafAt(12); | |
2770 } | |
2771 | |
2772 public int getVBClassVBOff() throws DebugVC50WrongNumericTypeException { | |
2773 return readIntNumericLeafAt(12 + numericLeafLengthAt(12)); | |
2774 } | |
2775 | |
2776 /////////////////////////// | |
2777 // LF_IVBCLASS accessors // | |
2778 /////////////////////////// | |
2779 | |
2780 public short getIVBClassAttribute() { | |
2781 typeSeek(2); | |
2782 return readShort(); | |
2783 } | |
2784 | |
2785 public int getIVBClassBType() { | |
2786 typeSeek(4); | |
2787 return readInt(); | |
2788 } | |
2789 | |
2790 public int getIVBClassVBPType() { | |
2791 typeSeek(8); | |
2792 return readInt(); | |
2793 } | |
2794 | |
2795 public int getIVBClassVBPOff() throws DebugVC50WrongNumericTypeException { | |
2796 return readIntNumericLeafAt(12); | |
2797 } | |
2798 | |
2799 public int getIVBClassVBOff() throws DebugVC50WrongNumericTypeException { | |
2800 return readIntNumericLeafAt(12 + numericLeafLengthAt(12)); | |
2801 } | |
2802 | |
2803 //////////////////////////// | |
2804 // LF_ENUMERATE accessors // | |
2805 //////////////////////////// | |
2806 | |
2807 public short getEnumerateAttribute() { | |
2808 typeSeek(2); | |
2809 return readShort(); | |
2810 } | |
2811 | |
2812 public long getEnumerateValue() { | |
2813 return readIntNumericLeafAt(4); | |
2814 } | |
2815 | |
2816 public String getEnumerateName() { | |
2817 return readLengthPrefixedStringAt(4 + numericLeafLengthAt(4)); | |
2818 } | |
2819 | |
2820 //////////////////////////// | |
2821 // LF_FRIENDFCN accessors // | |
2822 //////////////////////////// | |
2823 | |
2824 public int getFriendFcnType() { | |
2825 typeSeek(4); | |
2826 return readInt(); | |
2827 } | |
2828 | |
2829 public String getFriendFcnName() { | |
2830 return readLengthPrefixedStringAt(8); | |
2831 } | |
2832 | |
2833 //////////////////////// | |
2834 // LF_INDEX accessors // | |
2835 //////////////////////// | |
2836 | |
2837 public int getIndexValue() { | |
2838 typeSeek(4); | |
2839 return readInt(); | |
2840 } | |
2841 | |
2842 public DebugVC50TypeIterator getIndexIterator() { | |
2843 int index = unbiasTypeIndex(getIndexValue()); | |
2844 int offset = parent.getTypeOffset(index); | |
2845 return new DebugVC50TypeIteratorImpl(parent, base, numTypes, index, offset); | |
2846 } | |
2847 | |
2848 ///////////////////////// | |
2849 // LF_MEMBER accessors // | |
2850 ///////////////////////// | |
2851 | |
2852 public short getMemberAttribute() { | |
2853 typeSeek(2); | |
2854 return readShort(); | |
2855 } | |
2856 | |
2857 public int getMemberType() { | |
2858 typeSeek(4); | |
2859 return readInt(); | |
2860 } | |
2861 | |
2862 public int getMemberOffset() throws DebugVC50WrongNumericTypeException { | |
2863 return readIntNumericLeafAt(8); | |
2864 } | |
2865 | |
2866 public String getMemberName() { | |
2867 return readLengthPrefixedStringAt(8 + numericLeafLengthAt(8)); | |
2868 } | |
2869 | |
2870 /////////////////////////// | |
2871 // LF_STMEMBER accessors // | |
2872 /////////////////////////// | |
2873 | |
2874 public short getStaticAttribute() { | |
2875 typeSeek(2); | |
2876 return readShort(); | |
2877 } | |
2878 | |
2879 public int getStaticType() { | |
2880 typeSeek(4); | |
2881 return readInt(); | |
2882 } | |
2883 | |
2884 public String getStaticName() { | |
2885 return readLengthPrefixedStringAt(8); | |
2886 } | |
2887 | |
2888 ///////////////////////// | |
2889 // LF_METHOD accessors // | |
2890 ///////////////////////// | |
2891 | |
2892 public short getMethodCount() { | |
2893 typeSeek(2); | |
2894 return readShort(); | |
2895 } | |
2896 | |
2897 public int getMethodList() { | |
2898 typeSeek(4); | |
2899 return readInt(); | |
2900 } | |
2901 | |
2902 public String getMethodName() { | |
2903 return readLengthPrefixedStringAt(8); | |
2904 } | |
2905 | |
2906 ///////////////////////////// | |
2907 // LF_NESTEDTYPE accessors // | |
2908 ///////////////////////////// | |
2909 | |
2910 public int getNestedType() { | |
2911 typeSeek(4); | |
2912 return readInt(); | |
2913 } | |
2914 | |
2915 public String getNestedName() { | |
2916 return readLengthPrefixedStringAt(8); | |
2917 } | |
2918 | |
2919 /////////////////////////// | |
2920 // LF_VFUNCTAB accessors // | |
2921 /////////////////////////// | |
2922 | |
2923 public int getVFuncTabType() { | |
2924 typeSeek(4); | |
2925 return readInt(); | |
2926 } | |
2927 | |
2928 //////////////////////////// | |
2929 // LF_FRIENDCLS accessors // | |
2930 //////////////////////////// | |
2931 | |
2932 public int getFriendClsType() { | |
2933 typeSeek(4); | |
2934 return readInt(); | |
2935 } | |
2936 | |
2937 //////////////////////////// | |
2938 // LF_ONEMETHOD accessors // | |
2939 //////////////////////////// | |
2940 | |
2941 public short getOneMethodAttribute() { | |
2942 typeSeek(2); | |
2943 return readShort(); | |
2944 } | |
2945 | |
2946 public int getOneMethodType() { | |
2947 typeSeek(4); | |
2948 return readInt(); | |
2949 } | |
2950 | |
2951 public boolean isOneMethodIntroducingVirtual() { | |
2952 return isIntroducingVirtual(getOneMethodAttribute()); | |
2953 } | |
2954 | |
2955 public int getOneMethodVBaseOff() { | |
2956 typeSeek(8); | |
2957 return readInt(); | |
2958 } | |
2959 | |
2960 public String getOneMethodName() { | |
2961 int baseLen = 8 + (isOneMethodIntroducingVirtual() ? 4 : 0); | |
2962 return readLengthPrefixedStringAt(baseLen); | |
2963 } | |
2964 | |
2965 /////////////////////////// | |
2966 // LF_VFUNCOFF accessors // | |
2967 /////////////////////////// | |
2968 | |
2969 public int getVFuncOffType() { | |
2970 typeSeek(4); | |
2971 return readInt(); | |
2972 } | |
2973 | |
2974 public int getVFuncOffOffset() { | |
2975 typeSeek(8); | |
2976 return readInt(); | |
2977 } | |
2978 | |
2979 /////////////////////////////// | |
2980 // LF_NESTEDTYPEEX accessors // | |
2981 /////////////////////////////// | |
2982 | |
2983 public short getNestedExAttribute() { | |
2984 typeSeek(2); | |
2985 return readShort(); | |
2986 } | |
2987 | |
2988 public int getNestedExType() { | |
2989 typeSeek(4); | |
2990 return readInt(); | |
2991 } | |
2992 | |
2993 public String getNestedExName() { | |
2994 return readLengthPrefixedStringAt(8); | |
2995 } | |
2996 | |
2997 /////////////////////////////// | |
2998 // LF_MEMBERMODIFY accessors // | |
2999 /////////////////////////////// | |
3000 | |
3001 public short getMemberModifyAttribute() { | |
3002 typeSeek(2); | |
3003 return readShort(); | |
3004 } | |
3005 | |
3006 public int getMemberModifyType() { | |
3007 typeSeek(4); | |
3008 return readInt(); | |
3009 } | |
3010 | |
3011 public String getMemberModifyName() { | |
3012 return readLengthPrefixedStringAt(8); | |
3013 } | |
3014 | |
3015 //////////////////////////// | |
3016 // Numeric Leaf accessors // | |
3017 //////////////////////////// | |
3018 | |
3019 public short getNumericTypeAt(int byteOffset) { | |
3020 typeSeek(byteOffset); | |
3021 return readShort(); | |
3022 } | |
3023 | |
3024 public int getNumericLengthAt(int byteOffset) | |
3025 throws DebugVC50WrongNumericTypeException { | |
3026 return numericLeafLengthAt(byteOffset); | |
3027 } | |
3028 | |
3029 public int getNumericIntAt(int byteOffset) | |
3030 throws DebugVC50WrongNumericTypeException { | |
3031 return readIntNumericLeafAt(byteOffset); | |
3032 } | |
3033 | |
3034 public long getNumericLongAt(int byteOffset) | |
3035 throws DebugVC50WrongNumericTypeException { | |
3036 // FIXME | |
3037 throw new RuntimeException("Unimplemented"); | |
3038 } | |
3039 | |
3040 public float getNumericFloatAt(int byteOffset) | |
3041 throws DebugVC50WrongNumericTypeException { | |
3042 // FIXME | |
3043 throw new RuntimeException("Unimplemented"); | |
3044 } | |
3045 | |
3046 public double getNumericDoubleAt(int byteOffset) | |
3047 throws DebugVC50WrongNumericTypeException { | |
3048 // FIXME | |
3049 throw new RuntimeException("Unimplemented"); | |
3050 } | |
3051 | |
3052 public byte[] getNumericDataAt(int byteOffset) | |
3053 throws DebugVC50WrongNumericTypeException { | |
3054 // FIXME | |
3055 throw new RuntimeException("Unimplemented"); | |
3056 } | |
3057 | |
3058 //---------------------------------------------------------------------- | |
3059 // Internals only below this point | |
3060 // | |
3061 | |
3062 private void loadTypeRecord() { | |
3063 seek(typeRecordOffset); | |
3064 typeRecordSize = readShort() & 0xFFFF; | |
3065 typeStringOffset = typeRecordOffset + 2; | |
3066 loadTypeString(); | |
3067 } | |
3068 | |
3069 private void loadTypeString() { | |
3070 seek(typeStringOffset); | |
3071 int lo = readByte() & 0xFF; | |
3072 // See if it is one of the single-byte leaves | |
3073 if (lo >= LF_PAD0) { | |
3074 typeStringLeaf = lo; | |
3075 } else { | |
3076 int hi = readByte() & 0xFF; | |
3077 typeStringLeaf = (hi << 8) | lo; | |
3078 } | |
3079 } | |
3080 | |
3081 private void typeSeek(int offset) { | |
3082 seek(typeStringOffset + offset); | |
3083 } | |
3084 | |
3085 private int typeStringLength() { | |
3086 // LF_PAD | |
3087 if (typeStringLeaf >= 0xF0 && typeStringLeaf <= 0xFF) { | |
3088 return (typeStringLeaf - 0xF0); | |
3089 } | |
3090 | |
3091 switch (typeStringLeaf) { | |
3092 | |
3093 // Leaf indices for type records that can be referenced | |
3094 // from symbols: | |
3095 case LF_MODIFIER: return 8; | |
3096 case LF_POINTER: { | |
3097 int extraLen = 0; | |
3098 int attr = (getPointerAttributes() & POINTER_PTRTYPE_MASK) >> POINTER_PTRTYPE_SHIFT; | |
3099 int mode = (getPointerAttributes() & POINTER_PTRMODE_MASK) >> POINTER_PTRMODE_SHIFT; | |
3100 if (attr == POINTER_PTRTYPE_BASED_ON_TYPE) { | |
3101 extraLen = 4 + numericLeafLengthAt(typeStringOffset + 14); | |
3102 } else if (mode == POINTER_PTRMODE_PTR_TO_DATA_MEMBER || | |
3103 mode == POINTER_PTRMODE_PTR_TO_METHOD) { | |
3104 extraLen = 6; | |
3105 } | |
3106 return 10 + extraLen; | |
3107 } | |
3108 case LF_ARRAY: { | |
3109 int temp = 10 + numericLeafLengthAt(10); | |
3110 return temp + lengthPrefixedStringLengthAt(temp); | |
3111 } | |
3112 case LF_CLASS: | |
3113 case LF_STRUCTURE: { | |
3114 int temp = 18 + numericLeafLengthAt(18); | |
3115 return temp + lengthPrefixedStringLengthAt(temp); | |
3116 } | |
3117 case LF_UNION: { | |
3118 int temp = 10 + numericLeafLengthAt(10); | |
3119 return temp + lengthPrefixedStringLengthAt(temp); | |
3120 } | |
3121 case LF_ENUM: { | |
3122 return 14 + lengthPrefixedStringLengthAt(14); | |
3123 } | |
3124 case LF_PROCEDURE: return 14; | |
3125 case LF_MFUNCTION: return 26; | |
3126 case LF_VTSHAPE: return 4 + ((getVTShapeCount() + 1) / 2); | |
3127 case LF_COBOL0: | |
3128 case LF_COBOL1: throw new COFFException("COBOL symbols unimplemented"); | |
3129 case LF_BARRAY: return 6; | |
3130 case LF_LABEL: return 4; | |
3131 case LF_NULL: return 2; | |
3132 case LF_NOTTRAN: return 2; | |
3133 case LF_DIMARRAY: return 10 + lengthPrefixedStringLengthAt(10); | |
3134 case LF_VFTPATH: return 6 + 4 * getVFTPathCount(); | |
3135 case LF_PRECOMP: return 14 + lengthPrefixedStringLengthAt(14); | |
3136 case LF_ENDPRECOMP: return 6; | |
3137 case LF_OEM: throw new COFFException("OEM symbols unimplemented"); | |
3138 case LF_TYPESERVER: return 10 + lengthPrefixedStringLengthAt(10); | |
3139 | |
3140 case LF_SKIP: return 6 + numericLeafLengthAt(6); | |
3141 case LF_ARGLIST: return 6 + 4 * getArgListCount(); | |
3142 case LF_DEFARG: return 6 + lengthPrefixedStringLengthAt(6); | |
3143 // case LF_FIELDLIST: throw new COFFException("Should not see LF_FIELDLIST leaf"); | |
3144 case LF_FIELDLIST: return 2; | |
3145 case LF_DERIVED: return 6 + 4 * getDerivedCount(); | |
3146 case LF_BITFIELD: return 8; | |
3147 case LF_METHODLIST: { | |
3148 return 6 + 4 * getMListLength() + (isMListIntroducingVirtual() ? 4 : 0); | |
3149 } | |
3150 case LF_DIMCONU: | |
3151 case LF_DIMCONLU: | |
3152 case LF_DIMVARU: | |
3153 case LF_DIMVARLU: throw new COFFException("LF_DIMCONU, LF_DIMCONLU, LF_DIMVARU, and LF_DIMVARLU unsupported"); | |
3154 case LF_REFSYM: { | |
3155 seek(typeStringOffset + 2); | |
3156 return 4 + readShort(); | |
3157 } | |
3158 | |
3159 case LF_BCLASS: return 8 + numericLeafLengthAt(8); | |
3160 case LF_VBCLASS: | |
3161 case LF_IVBCLASS: { | |
3162 int temp = 12 + numericLeafLengthAt(12); | |
3163 return temp + numericLeafLengthAt(temp); | |
3164 } | |
3165 case LF_ENUMERATE: { | |
3166 int temp = 4 + numericLeafLengthAt(4); | |
3167 return temp + lengthPrefixedStringLengthAt(temp); | |
3168 } | |
3169 case LF_FRIENDFCN: return 8 + lengthPrefixedStringLengthAt(8); | |
3170 case LF_INDEX: return 8; | |
3171 case LF_MEMBER: { | |
3172 int temp = 8 + numericLeafLengthAt(8); | |
3173 return temp + lengthPrefixedStringLengthAt(temp); | |
3174 } | |
3175 case LF_STMEMBER: return 8 + lengthPrefixedStringLengthAt(8); | |
3176 case LF_METHOD: return 8 + lengthPrefixedStringLengthAt(8); | |
3177 case LF_NESTTYPE: return 8 + lengthPrefixedStringLengthAt(8); | |
3178 case LF_VFUNCTAB: return 8; | |
3179 case LF_FRIENDCLS: return 8; | |
3180 case LF_ONEMETHOD: { | |
3181 int baseLen = 8 + (isOneMethodIntroducingVirtual() ? 4 : 0); | |
3182 return baseLen + lengthPrefixedStringLengthAt(baseLen); | |
3183 } | |
3184 case LF_VFUNCOFF: return 12; | |
3185 case LF_NESTTYPEEX: return 8 + lengthPrefixedStringLengthAt(8); | |
3186 case LF_MEMBERMODIFY: return 8 + lengthPrefixedStringLengthAt(8); | |
3187 | |
3188 // Should not encounter numeric leaves with this routine | |
3189 case LF_CHAR: | |
3190 case LF_SHORT: | |
3191 case LF_USHORT: | |
3192 case LF_LONG: | |
3193 case LF_ULONG: | |
3194 case LF_REAL32: | |
3195 case LF_REAL64: | |
3196 case LF_REAL80: | |
3197 case LF_REAL128: | |
3198 case LF_QUADWORD: | |
3199 case LF_UQUADWORD: | |
3200 case LF_REAL48: | |
3201 case LF_COMPLEX32: | |
3202 case LF_COMPLEX64: | |
3203 case LF_COMPLEX80: | |
3204 case LF_COMPLEX128: | |
3205 case LF_VARSTRING: throw new RuntimeException("Unexpected numeric leaf " + typeStringLeaf + | |
3206 "in type string"); | |
3207 default: | |
3208 throw new COFFException("Unrecognized leaf " + typeStringLeaf + " in type string at offset " + | |
3209 typeStringOffset); | |
3210 } | |
3211 } | |
3212 | |
3213 private boolean isIntroducingVirtual(int mprop) { | |
3214 int masked = mprop & MEMATTR_MPROP_MASK; | |
3215 return ((masked == MEMATTR_MPROP_INTRODUCING_VIRTUAL) || | |
3216 (masked == MEMATTR_MPROP_PURE_INTRODUCING_VIRTUAL)); | |
3217 } | |
3218 | |
3219 private int numericLeafLengthAt(int offset) { | |
3220 return DebugVC50Impl.this.numericLeafLengthAt(typeStringOffset + offset); | |
3221 } | |
3222 | |
3223 private int readIntNumericLeafAt(int offset) { | |
3224 return DebugVC50Impl.this.readIntNumericLeafAt(typeStringOffset + offset); | |
3225 } | |
3226 | |
3227 private int lengthPrefixedStringLengthAt(int offset) { | |
3228 return DebugVC50Impl.this.lengthPrefixedStringLengthAt(typeStringOffset + offset); | |
3229 } | |
3230 | |
3231 private String readLengthPrefixedStringAt(int offset) { | |
3232 return DebugVC50Impl.this.readLengthPrefixedStringAt(typeStringOffset + offset); | |
3233 } | |
3234 } | |
3235 | |
3236 private int numericLeafLengthAt(int absoluteOffset) throws DebugVC50WrongNumericTypeException { | |
3237 seek(absoluteOffset); | |
3238 int leaf = readShort() & 0xFFFF; | |
3239 if (leaf < 0x8000) return 2; | |
3240 switch (leaf) { | |
3241 case LF_CHAR: return 3; | |
3242 case LF_SHORT: | |
3243 case LF_USHORT: return 4; | |
3244 case LF_LONG: | |
3245 case LF_ULONG: return 6; | |
3246 case LF_REAL32: return 6; | |
3247 case LF_REAL64: return 10; | |
3248 case LF_REAL80: return 12; | |
3249 case LF_REAL128: return 18; | |
3250 case LF_QUADWORD: | |
3251 case LF_UQUADWORD: return 18; | |
3252 case LF_REAL48: return 8; | |
3253 case LF_COMPLEX32: return 10; | |
3254 case LF_COMPLEX64: return 18; | |
3255 case LF_COMPLEX80: return 26; | |
3256 case LF_COMPLEX128: return 66; | |
3257 // FIXME: figure out format of variable-length strings | |
3258 case LF_VARSTRING: return 4 + readIntNumericLeafAt(absoluteOffset + 2); | |
3259 | |
3260 default: | |
3261 throw new DebugVC50WrongNumericTypeException("Illegal numeric leaf index " + leaf + | |
3262 " at offset " + absoluteOffset); | |
3263 } | |
3264 } | |
3265 | |
3266 private int readIntNumericLeafAt(int absoluteOffset) throws DebugVC50WrongNumericTypeException { | |
3267 seek(absoluteOffset); | |
3268 int leaf = readShort() & 0xFFFF; | |
3269 if (leaf < 0x8000) return leaf; | |
3270 switch (leaf) { | |
3271 case LF_CHAR: return readByte() & 0xFF; | |
3272 case LF_SHORT: | |
3273 case LF_USHORT: return readShort() & 0xFFFF; | |
3274 case LF_LONG: | |
3275 case LF_ULONG: return readInt(); | |
3276 | |
3277 default: | |
3278 throw new DebugVC50WrongNumericTypeException("Illegal numeric leaf index " + leaf); | |
3279 } | |
3280 } | |
3281 | |
3282 private long readLongNumericLeafAt(int absoluteOffset) throws DebugVC50WrongNumericTypeException { | |
3283 seek(absoluteOffset); | |
3284 int leaf = readShort() & 0xFFFF; | |
3285 if (leaf < 0x8000) return leaf; | |
3286 switch (leaf) { | |
3287 case LF_CHAR: return readByte() & 0xFF; | |
3288 case LF_SHORT: | |
3289 case LF_USHORT: return readShort() & 0xFFFF; | |
3290 case LF_LONG: | |
3291 case LF_ULONG: return readInt() & 0xFFFFFFFF; | |
3292 case LF_QUADWORD: | |
3293 case LF_UQUADWORD: return readLong(); | |
3294 | |
3295 default: | |
3296 throw new DebugVC50WrongNumericTypeException("Illegal numeric leaf index " + leaf); | |
3297 } | |
3298 } | |
3299 | |
3300 private float readFloatNumericLeafAt(int absoluteOffset) throws DebugVC50WrongNumericTypeException { | |
3301 seek(absoluteOffset); | |
3302 int leaf = readShort() & 0xFFFF; | |
3303 if (leaf != LF_REAL32) { | |
3304 throw new DebugVC50WrongNumericTypeException("Illegal numeric leaf index " + leaf); | |
3305 } | |
3306 return readFloat(); | |
3307 } | |
3308 | |
3309 private double readDoubleNumericLeafAt(int absoluteOffset) throws DebugVC50WrongNumericTypeException { | |
3310 seek(absoluteOffset); | |
3311 int leaf = readShort() & 0xFFFF; | |
3312 if (leaf != LF_REAL64) { | |
3313 throw new DebugVC50WrongNumericTypeException("Illegal numeric leaf index " + leaf); | |
3314 } | |
3315 return readDouble(); | |
3316 } | |
3317 | |
3318 private int lengthPrefixedStringLengthAt(int absoluteOffset) { | |
3319 // NOTE: the format of length-prefixed strings is not well | |
3320 // specified. There is a LF_VARSTRING numeric leaf (the | |
3321 // format of which is also not specified), but it seems that | |
3322 // most length-prefixed strings are comprised of a single | |
3323 // byte length followed by that many bytes of data. | |
3324 seek(absoluteOffset); | |
3325 int len = readByte() & 0xFF; | |
3326 return 1 + len; | |
3327 } | |
3328 | |
3329 private String readLengthPrefixedStringAt(int absoluteOffset) { | |
3330 // NOTE: it isn't clear whether LF_VARSTRING numeric leaves | |
3331 // ever show up, or in general what happens when the length | |
3332 // of the string is > 255 (FIXME) | |
3333 seek(absoluteOffset); | |
3334 int len = readByte() & 0xFF; | |
3335 byte[] res = new byte[len]; | |
3336 int numRead = readBytes(res); | |
3337 if (numRead != len) { | |
3338 throw new COFFException("Error reading length prefixed string in symbol at offset " + | |
3339 absoluteOffset); | |
3340 } | |
3341 try { | |
3342 return new String(res, US_ASCII); | |
3343 } catch (UnsupportedEncodingException e) { | |
3344 throw new COFFException(e); | |
3345 } | |
3346 } | |
3347 | |
3348 private int unbiasTypeIndex(int index) { | |
3349 return index - 0x1000; | |
3350 } | |
3351 | |
3352 private int biasTypeIndex(int index) { | |
3353 return index + 0x1000; | |
3354 } | |
3355 } // Class DebugVC50Impl | |
3356 | |
3357 class SectionHeaderImpl implements SectionHeader { | |
3358 private String name; | |
3359 private int virtualSize; | |
3360 private int virtualAddress; | |
3361 private int sizeOfRawData; | |
3362 private int pointerToRawData; | |
3363 private int pointerToRelocations; | |
3364 private int pointerToLineNumbers; | |
3365 private short numberOfRelocations; | |
3366 private short numberOfLineNumbers; | |
3367 private int characteristics; | |
3368 private MemoizedObject[] relocations; | |
3369 private MemoizedObject[] lineNumbers; | |
3370 | |
3371 public SectionHeaderImpl(int offset) throws COFFException { | |
3372 seek(offset); | |
3373 | |
3374 // FIXME: compute name lazily | |
3375 | |
3376 // Read name | |
3377 byte[] tmpName = new byte[8]; | |
3378 int numRead = readBytes(tmpName); | |
3379 if (numRead != 8) { | |
3380 throw new COFFException("Error reading name of section header at offset " + offset); | |
3381 } | |
3382 if (tmpName[0] == (byte) '/') { | |
3383 // Long name; must find real value in string table | |
3384 int index = 0; | |
3385 try { | |
3386 index = Integer.parseInt(new String(tmpName, 1, tmpName.length - 1, US_ASCII)); | |
3387 } catch (NumberFormatException e) { | |
3388 throw new COFFException("Error parsing string table index of name of section header " + | |
3389 "at offset " + offset); | |
3390 } catch (UnsupportedEncodingException e) { | |
3391 throw new COFFException(e); | |
3392 } | |
3393 // Look up in string table | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3394 // FIXME: this index value is assumed to be in the valid range |
0 | 3395 name = getStringTable().get(index); |
3396 } else { | |
3397 try { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3398 int length = 0; |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3399 // find last non-NULL |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3400 for (; length < tmpName.length && tmpName[length] != '\0';) { |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3401 length++; |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3402 } |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3403 // don't include NULL chars in returned name String |
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3404 name = new String(tmpName, 0, length, US_ASCII); |
0 | 3405 } catch (UnsupportedEncodingException e) { |
3406 throw new COFFException(e); | |
3407 } | |
3408 } | |
3409 virtualSize = readInt(); | |
3410 virtualAddress = readInt(); | |
3411 sizeOfRawData = readInt(); | |
3412 pointerToRawData = readInt(); | |
3413 pointerToRelocations = readInt(); | |
3414 pointerToLineNumbers = readInt(); | |
3415 numberOfRelocations = readShort(); | |
3416 numberOfLineNumbers = readShort(); | |
3417 characteristics = readInt(); | |
3418 | |
3419 // Set up relocations | |
3420 relocations = new MemoizedObject[numberOfRelocations]; | |
3421 for (int i = 0; i < numberOfRelocations; i++) { | |
3422 final int relocOffset = pointerToRelocations + i * RELOCATION_SIZE; | |
3423 relocations[i] = new MemoizedObject() { | |
3424 public Object computeValue() { | |
3425 return new COFFRelocationImpl(relocOffset); | |
3426 } | |
3427 }; | |
3428 } | |
3429 | |
3430 // Set up line numbers | |
3431 lineNumbers = new MemoizedObject[numberOfLineNumbers]; | |
3432 for (int i = 0; i < numberOfLineNumbers; i++) { | |
3433 final int lineNoOffset = pointerToLineNumbers + i * LINE_NUMBER_SIZE; | |
3434 lineNumbers[i] = new MemoizedObject() { | |
3435 public Object computeValue() { | |
3436 return new COFFLineNumberImpl(lineNoOffset); | |
3437 } | |
3438 }; | |
3439 } | |
3440 } | |
3441 | |
3442 public String getName() { return name; } | |
3443 public int getSize() { return virtualSize; } | |
3444 public int getVirtualAddress() { return virtualAddress; } | |
3445 public int getSizeOfRawData() { return sizeOfRawData; } | |
3446 public int getPointerToRawData() { return pointerToRawData; } | |
3447 public int getPointerToRelocations() { return pointerToRelocations; } | |
3448 public int getPointerToLineNumbers() { return pointerToLineNumbers; } | |
3449 public short getNumberOfRelocations() { return numberOfRelocations; } | |
3450 public short getNumberOfLineNumbers() { return numberOfLineNumbers; } | |
3451 public int getSectionFlags() { return characteristics; } | |
3452 public boolean hasSectionFlag(int flag ) { | |
3453 return ((characteristics & flag) != 0); | |
3454 } | |
3455 public COFFRelocation getCOFFRelocation(int index) { | |
3456 return (COFFRelocation) relocations[index].getValue(); | |
3457 } | |
3458 public COFFLineNumber getCOFFLineNumber(int index) { | |
3459 return (COFFLineNumber) lineNumbers[index]; | |
3460 } | |
3461 } | |
3462 | |
3463 class COFFSymbolImpl implements COFFSymbol, COFFSymbolConstants { | |
3464 private int offset; | |
3465 private String name; | |
3466 private int value; | |
3467 private short sectionNumber; | |
3468 private short type; | |
3469 private byte storageClass; | |
3470 private byte numberOfAuxSymbols; | |
3471 private MemoizedObject auxFunctionDefinitionRecord = new MemoizedObject() { | |
3472 public Object computeValue() { | |
3473 return new AuxFunctionDefinitionRecordImpl(offset + SYMBOL_SIZE); | |
3474 } | |
3475 }; | |
3476 private MemoizedObject auxBfEfRecord = new MemoizedObject() { | |
3477 public Object computeValue() { | |
3478 return new AuxBfEfRecordImpl(offset + SYMBOL_SIZE); | |
3479 } | |
3480 }; | |
3481 private MemoizedObject auxWeakExternalRecord = new MemoizedObject() { | |
3482 public Object computeValue() { | |
3483 return new AuxWeakExternalRecordImpl(offset + SYMBOL_SIZE); | |
3484 } | |
3485 }; | |
3486 private MemoizedObject auxFileRecord = new MemoizedObject() { | |
3487 public Object computeValue() { | |
3488 return new AuxFileRecordImpl(offset + SYMBOL_SIZE); | |
3489 } | |
3490 }; | |
3491 private MemoizedObject auxSectionDefinitionsRecord = new MemoizedObject() { | |
3492 public Object computeValue() { | |
3493 return new AuxSectionDefinitionsRecordImpl(offset + SYMBOL_SIZE); | |
3494 } | |
3495 }; | |
3496 | |
3497 public COFFSymbolImpl(int offset) throws COFFException { | |
3498 this.offset = offset; | |
3499 seek(offset); | |
3500 | |
3501 // Parse name | |
3502 byte[] tmpName = new byte[8]; | |
3503 int numRead = readBytes(tmpName); | |
3504 if (numRead != 8) { | |
3505 throw new COFFException("Error reading name of symbol at offset " + offset); | |
3506 } | |
3507 if ((tmpName[0] == 0) && | |
3508 (tmpName[1] == 0) && | |
3509 (tmpName[2] == 0) && | |
3510 (tmpName[3] == 0)) { | |
3511 // It's an offset into the string table. | |
3512 // FIXME: not sure about byte ordering... | |
3513 int stringOffset = (tmpName[4] << 24 | | |
3514 tmpName[5] << 16 | | |
3515 tmpName[6] << 8 | | |
3516 tmpName[7]); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3517 // FIXME: stringOffset is assumed to be in the valid range |
0 | 3518 name = getStringTable().getAtOffset(stringOffset); |
3519 } | |
3520 | |
3521 value = readInt(); | |
3522 sectionNumber = readShort(); | |
3523 type = readShort(); | |
3524 storageClass = readByte(); | |
3525 numberOfAuxSymbols = readByte(); | |
3526 } | |
3527 | |
3528 public int getOffset() { return offset; } | |
3529 public String getName() { return name; } | |
3530 public int getValue() { return value; } | |
3531 public short getSectionNumber() { return sectionNumber; } | |
3532 public short getType() { return type; } | |
3533 public byte getStorageClass() { return storageClass; } | |
3534 public byte getNumberOfAuxSymbols() { return numberOfAuxSymbols; } | |
3535 public boolean isFunctionDefinition() { | |
3536 return ((getStorageClass() == IMAGE_SYM_CLASS_EXTERNAL) && | |
3537 ((getType() >>> 8) == IMAGE_SYM_DTYPE_FUNCTION) && | |
3538 (getSectionNumber() > 0)); | |
3539 } | |
3540 public AuxFunctionDefinitionRecord getAuxFunctionDefinitionRecord() { | |
3541 return (AuxFunctionDefinitionRecord) auxFunctionDefinitionRecord.getValue(); | |
3542 } | |
3543 public boolean isBfOrEfSymbol() { | |
3544 return ((getName().equals(".bf") || getName().equals(".ef")) && | |
3545 (getStorageClass() == IMAGE_SYM_CLASS_FUNCTION)); | |
3546 } | |
3547 public AuxBfEfRecord getAuxBfEfRecord() { | |
3548 return (AuxBfEfRecord) auxBfEfRecord.getValue(); | |
3549 } | |
3550 public boolean isWeakExternal() { | |
3551 return ((getStorageClass() == IMAGE_SYM_CLASS_EXTERNAL) && | |
3552 (getSectionNumber() == IMAGE_SYM_UNDEFINED) && | |
3553 (getValue() == 0)); | |
3554 } | |
3555 public AuxWeakExternalRecord getAuxWeakExternalRecord() { | |
3556 return (AuxWeakExternalRecord) auxWeakExternalRecord.getValue(); | |
3557 } | |
3558 public boolean isFile() { | |
3559 return ((getName().equals(".file")) && | |
3560 (getStorageClass() == IMAGE_SYM_CLASS_FILE)); | |
3561 } | |
3562 public AuxFileRecord getAuxFileRecord() { | |
3563 return (AuxFileRecord) auxFileRecord.getValue(); | |
3564 } | |
3565 public boolean isSectionDefinition() { | |
3566 // FIXME: not sure how to ensure that symbol name is the | |
3567 // name of a section. | |
3568 return ((getName().charAt(0) == '.') && | |
3569 (getStorageClass() == IMAGE_SYM_CLASS_STATIC)); | |
3570 } | |
3571 public AuxSectionDefinitionsRecord getAuxSectionDefinitionsRecord() { | |
3572 return (AuxSectionDefinitionsRecord) auxSectionDefinitionsRecord.getValue(); | |
3573 } | |
3574 } | |
3575 | |
3576 class AuxFunctionDefinitionRecordImpl implements AuxFunctionDefinitionRecord { | |
3577 private int tagIndex; | |
3578 private int totalSize; | |
3579 private int pointerToLineNumber; | |
3580 private int pointerToNextFunction; | |
3581 | |
3582 AuxFunctionDefinitionRecordImpl(int offset) { | |
3583 seek(offset); | |
3584 tagIndex = readInt(); | |
3585 totalSize = readInt(); | |
3586 // NOTE zero-basing of this index | |
3587 pointerToLineNumber = readInt() - 1; | |
3588 pointerToNextFunction = readInt(); | |
3589 } | |
3590 | |
3591 public int getTagIndex() { return tagIndex; } | |
3592 public int getTotalSize() { return totalSize; } | |
3593 public int getPointerToLineNumber() { return pointerToLineNumber; } | |
3594 public int getPointerToNextFunction() { return pointerToNextFunction; } | |
3595 public int getType() { return FUNCTION_DEFINITION; } | |
3596 } | |
3597 | |
3598 class AuxBfEfRecordImpl implements AuxBfEfRecord { | |
3599 private short lineNumber; | |
3600 private int pointerToNextFunction; | |
3601 | |
3602 AuxBfEfRecordImpl(int offset) { | |
3603 seek(offset); | |
3604 readInt(); | |
3605 lineNumber = readShort(); | |
3606 readInt(); | |
3607 readShort(); | |
3608 pointerToNextFunction = readInt(); | |
3609 } | |
3610 | |
3611 public short getLineNumber() { return lineNumber; } | |
3612 public int getPointerToNextFunction() { return pointerToNextFunction; } | |
3613 public int getType() { return BF_EF_RECORD; } | |
3614 } | |
3615 | |
3616 class AuxWeakExternalRecordImpl implements AuxWeakExternalRecord { | |
3617 private int tagIndex; | |
3618 private int characteristics; | |
3619 | |
3620 AuxWeakExternalRecordImpl(int offset) { | |
3621 seek(offset); | |
3622 tagIndex = readInt(); | |
3623 characteristics = readInt(); | |
3624 } | |
3625 | |
3626 public int getTagIndex() { return tagIndex; } | |
3627 public int getCharacteristics() { return characteristics; } | |
3628 public int getType() { return WEAK_EXTERNAL; } | |
3629 } | |
3630 | |
3631 class AuxFileRecordImpl implements AuxFileRecord { | |
3632 private String name; | |
3633 | |
3634 AuxFileRecordImpl(int offset) { | |
3635 seek(offset); | |
3636 byte[] tmpName = new byte[18]; | |
3637 int numRead = readBytes(tmpName); | |
3638 if (numRead != 18) { | |
3639 throw new COFFException("Error reading auxiliary file record at offset " + offset); | |
3640 } | |
3641 try { | |
3642 name = new String(tmpName, US_ASCII); | |
3643 } catch (UnsupportedEncodingException e) { | |
3644 throw new COFFException(e); | |
3645 } | |
3646 } | |
3647 | |
3648 public String getName() { return name; } | |
3649 public int getType() { return FILE; } | |
3650 } | |
3651 | |
3652 class AuxSectionDefinitionsRecordImpl implements AuxSectionDefinitionsRecord { | |
3653 private int length; | |
3654 private short numberOfRelocations; | |
3655 private short numberOfLineNumbers; | |
3656 private int checkSum; | |
3657 private short number; | |
3658 private byte selection; | |
3659 | |
3660 AuxSectionDefinitionsRecordImpl(int offset) { | |
3661 seek(offset); | |
3662 length = readInt(); | |
3663 numberOfRelocations = readShort(); | |
3664 numberOfLineNumbers = readShort(); | |
3665 checkSum = readInt(); | |
3666 number = readShort(); | |
3667 selection = readByte(); | |
3668 } | |
3669 | |
3670 public int getLength() { return length; } | |
3671 public short getNumberOfRelocations() { return numberOfRelocations; } | |
3672 public short getNumberOfLineNumbers() { return numberOfLineNumbers; } | |
3673 public int getCheckSum() { return checkSum; } | |
3674 public short getNumber() { return number; } | |
3675 public byte getSelection() { return selection; } | |
3676 public int getType() { return SECTION_DEFINITION; } | |
3677 } | |
3678 | |
3679 class COFFRelocationImpl implements COFFRelocation { | |
3680 private int virtualAddress; | |
3681 private int symbolTableIndex; | |
3682 private short type; | |
3683 | |
3684 COFFRelocationImpl(int offset) { | |
3685 seek(offset); | |
3686 virtualAddress = readInt(); | |
3687 symbolTableIndex = readInt(); | |
3688 type = readShort(); | |
3689 } | |
3690 | |
3691 public int getVirtualAddress() { return virtualAddress; } | |
3692 public int getSymbolTableIndex() { return symbolTableIndex; } | |
3693 public short getType() { return type; } | |
3694 } | |
3695 | |
3696 class COFFLineNumberImpl implements COFFLineNumber { | |
3697 private int type; | |
3698 private short lineNumber; | |
3699 | |
3700 COFFLineNumberImpl(int offset) { | |
3701 seek(offset); | |
3702 type = readInt(); | |
3703 lineNumber = readShort(); | |
3704 } | |
3705 | |
3706 public int getType() { | |
3707 return type; | |
3708 } | |
3709 | |
3710 public short getLineNumber() { | |
3711 return lineNumber; | |
3712 } | |
3713 } | |
3714 | |
3715 class StringTable { | |
3716 class COFFString { | |
3717 String str; | |
3718 int offset; | |
3719 | |
3720 COFFString(String str, int offset) { | |
3721 this.str = str; this.offset = offset; | |
3722 } | |
3723 } | |
3724 | |
3725 COFFString[] strings; | |
3726 | |
3727 StringTable(int offset) { | |
3728 if (offset == 0) { | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3729 // no String Table |
0 | 3730 strings = new COFFString[0]; |
3731 return; | |
3732 } | |
3733 | |
3734 seek(offset); | |
2072
d6cd0d55d0b5
6987812: 2/3 SAJDI: "gHotSpotVMTypes was not initialized properly in the remote process"
dcubed
parents:
1552
diff
changeset
|
3735 int length = readInt(); // length includes itself |
0 | 3736 byte[] data = new byte[length - 4]; |
3737 int numBytesRead = readBytes(data); | |
3738 if (numBytesRead != data.length) { | |
3739 throw new COFFException("Error reading string table (read " + | |
3740 numBytesRead + " bytes, expected to read " + data.length + ")"); | |
3741 } | |
3742 int numStrings = 0; | |
3743 int ptr = 0; | |
3744 for (ptr = 0; ptr < data.length; ptr++) { | |
3745 if (data[ptr] == 0) { | |
3746 numStrings++; | |
3747 } | |
3748 } | |
3749 strings = new COFFString[numStrings]; | |
3750 int lastPtr = 0; | |
3751 ptr = 0; | |
3752 for (int i = 0; i < numStrings; i++) { | |
3753 while (data[ptr] != 0) { | |
3754 ptr++; | |
3755 } | |
3756 try { | |
3757 strings[i] = new COFFString(new String(data, lastPtr, ptr - lastPtr, US_ASCII), | |
3758 offset + ptr + 4); | |
3759 } catch (UnsupportedEncodingException e) { | |
3760 throw new COFFException(e); | |
3761 } | |
3762 ptr++; | |
3763 lastPtr = ptr; | |
3764 } | |
3765 } | |
3766 | |
3767 int getNum() { | |
3768 return strings.length; | |
3769 } | |
3770 | |
3771 String get(int i) { | |
3772 return strings[i].str; | |
3773 } | |
3774 | |
3775 /** This version takes an absolute offset in the file */ | |
3776 String getAtOffset(int offset) { | |
3777 int i = Arrays.binarySearch(strings, new COFFString(null, offset), | |
3778 new Comparator() { | |
3779 public int compare(Object o1, Object o2) { | |
3780 COFFString s1 = (COFFString) o1; | |
3781 COFFString s2 = (COFFString) o2; | |
3782 if (s1.offset == s2.offset) { | |
3783 return 0; | |
3784 } else if (s1.offset < s2.offset) { | |
3785 return -1; | |
3786 } else { | |
3787 return 1; | |
3788 } | |
3789 } | |
3790 }); | |
3791 if (i < 0) { | |
3792 throw new COFFException("No string found at file offset " + offset); | |
3793 } | |
3794 return strings[i].str; | |
3795 } | |
3796 } | |
3797 } | |
3798 | |
3799 void initialize() throws COFFException { | |
3800 // Figure out whether this file is an object file or an image | |
3801 // (either executable or DLL). | |
3802 seek(0x3c); // Error here probably indicates file format error | |
3803 try { | |
3804 int peOffset = readInt(); | |
3805 seek(peOffset); | |
3806 if ((readByte() == (byte) 'P') && | |
3807 (readByte() == (byte) 'E') && | |
3808 (readByte() == (byte) 0) && | |
3809 (readByte() == (byte) 0)) { | |
3810 isImage = true; | |
3811 imageHeaderOffset = getFilePointer(); | |
3812 } | |
3813 } | |
3814 catch (COFFException e) { | |
3815 // Expect failures here if not image file. | |
3816 } | |
3817 } | |
3818 | |
3819 byte readByteAt(long offset) throws COFFException { | |
3820 seek(offset); | |
3821 return readByte(); | |
3822 } | |
3823 | |
3824 byte readByte() throws COFFException { | |
3825 try { | |
3826 return file.readByte(); | |
3827 } catch (IOException e) { | |
3828 throw new COFFException(e.toString() + " at offset 0x" + | |
3829 Long.toHexString(filePos), e); | |
3830 } | |
3831 } | |
3832 | |
3833 int readBytesAt(long offset, byte[] b) throws COFFException { | |
3834 seek(offset); | |
3835 return readBytes(b); | |
3836 } | |
3837 | |
3838 int readBytes(byte[] b) throws COFFException { | |
3839 try { | |
3840 return file.read(b); | |
3841 } catch (IOException e) { | |
3842 throw new COFFException(e.toString() + " at offset 0x" + | |
3843 Long.toHexString(filePos), e); | |
3844 } | |
3845 } | |
3846 | |
3847 /** NOTE: reads little-endian short */ | |
3848 short readShortAt(long offset) throws COFFException { | |
3849 seek(offset); | |
3850 return readShort(); | |
3851 } | |
3852 | |
3853 /** NOTE: reads little-endian short */ | |
3854 short readShort() throws COFFException { | |
3855 try { | |
3856 return byteSwap(file.readShort()); | |
3857 } catch (IOException e) { | |
3858 throw new COFFException(e.toString() + " at offset 0x" + | |
3859 Long.toHexString(filePos), e); | |
3860 } | |
3861 } | |
3862 | |
3863 /** NOTE: reads little-endian int */ | |
3864 int readIntAt(long offset) throws COFFException { | |
3865 seek(offset); | |
3866 return readInt(); | |
3867 } | |
3868 | |
3869 /** NOTE: reads little-endian int */ | |
3870 int readInt() throws COFFException { | |
3871 try { | |
3872 return byteSwap(file.readInt()); | |
3873 } catch (IOException e) { | |
3874 throw new COFFException(e.toString() + " at offset 0x" + | |
3875 Long.toHexString(filePos), e); | |
3876 } | |
3877 } | |
3878 | |
3879 /** NOTE: reads little-endian long */ | |
3880 long readLongAt(long offset) throws COFFException { | |
3881 seek(offset); | |
3882 return readLong(); | |
3883 } | |
3884 | |
3885 /** NOTE: reads little-endian long */ | |
3886 long readLong() throws COFFException { | |
3887 try { | |
3888 return byteSwap(file.readLong()); | |
3889 } catch (IOException e) { | |
3890 throw new COFFException(e.toString() + " at offset 0x" + | |
3891 Long.toHexString(filePos), e); | |
3892 } | |
3893 } | |
3894 | |
3895 /** NOTE: reads little-endian float */ | |
3896 float readFloat() throws COFFException { | |
3897 int i = readInt(); | |
3898 return Float.intBitsToFloat(i); | |
3899 } | |
3900 | |
3901 /** NOTE: reads little-endian double */ | |
3902 double readDouble() throws COFFException { | |
3903 long l = readLong(); | |
3904 return Double.longBitsToDouble(l); | |
3905 } | |
3906 | |
3907 String readCString() throws COFFException { | |
3908 List data = new ArrayList(); | |
3909 byte b = 0; | |
3910 while ((b = readByte()) != 0) { | |
3911 data.add(new Byte(b)); | |
3912 } | |
3913 byte[] bytes = new byte[data.size()]; | |
3914 for (int i = 0; i < data.size(); i++) { | |
3915 bytes[i] = ((Byte) data.get(i)).byteValue(); | |
3916 } | |
3917 try { | |
3918 return new String(bytes, US_ASCII); | |
3919 } catch (UnsupportedEncodingException e) { | |
3920 throw new COFFException(e); | |
3921 } | |
3922 } | |
3923 | |
3924 void seek(long offset) throws COFFException { | |
3925 try { | |
3926 filePos = offset; | |
3927 file.seek(offset); | |
3928 } catch (IOException e) { | |
3929 throw new COFFException(e.toString() + " at offset 0x" + | |
3930 Long.toHexString(offset), e); | |
3931 } | |
3932 } | |
3933 | |
3934 long getFilePointer() throws COFFException { | |
3935 try { | |
3936 return file.getFilePointer(); | |
3937 } catch (IOException e) { | |
3938 throw new COFFException(e); | |
3939 } | |
3940 } | |
3941 | |
3942 short byteSwap(short arg) { | |
3943 return (short) ((arg << 8) | ((arg >>> 8) & 0xFF)); | |
3944 } | |
3945 | |
3946 int byteSwap(int arg) { | |
3947 return (((int) byteSwap((short) arg)) << 16) | (((int) (byteSwap((short) (arg >>> 16)))) & 0xFFFF); | |
3948 } | |
3949 | |
3950 long byteSwap(long arg) { | |
3951 return ((((long) byteSwap((int) arg)) << 32) | (((long) byteSwap((int) (arg >>> 32))) & 0xFFFFFFFF)); | |
3952 } | |
3953 | |
3954 public void close() throws COFFException { | |
3955 try { | |
3956 file.close(); | |
3957 } catch (IOException e) { | |
3958 throw new COFFException(e); | |
3959 } | |
3960 } | |
3961 } | |
3962 } |