Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/COFFFileParser.java @ 17467:55fb97c4c58d hs25-b65
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
Summary: Copyright year updated for files modified during 2013
Reviewed-by: twisti, iveresov
| author | mikael |
|---|---|
| date | Tue, 24 Dec 2013 11:48:39 -0800 |
| 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 } |