Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/debugger/DebuggerBase.java @ 196:d1605aabd0a1 jdk7-b30
6719955: Update copyright year
Summary: Update copyright year for files that have been modified in 2008
Reviewed-by: ohair, tbell
| author | xdono |
|---|---|
| date | Wed, 02 Jul 2008 12:55:16 -0700 |
| parents | ba764ed4b6f2 |
| children | 660978a2a31a |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2001-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 package sun.jvm.hotspot.debugger; | |
| 26 | |
| 27 /** <P> DebuggerBase is a recommended base class for debugger | |
| 28 implementations. It can use a PageCache to cache data from the | |
| 29 target process. Note that this class would not be suitable if the | |
| 30 system were used to reflect upon itself; it would never be safe to | |
| 31 store the value in an OopHandle in anything but an OopHandle. | |
| 32 However, it provides a fair amount of code sharing to the current | |
| 33 dbx and win32 implementations. </P> | |
| 34 | |
| 35 <P> NOTE that much of the code sharing is achieved by having this | |
| 36 class implement many of the methods in the Win32Debugger and | |
| 37 DbxDebugger interfaces. </P> */ | |
| 38 | |
| 39 public abstract class DebuggerBase implements Debugger { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
40 |
| 0 | 41 // May be set lazily, but must be set before calling any of the read |
| 42 // routines below | |
| 43 protected MachineDescription machDesc; | |
| 44 protected DebuggerUtilities utils; | |
| 45 // Java primitive type sizes, set during bootstrapping. Do not call | |
| 46 // any of the Java read routines until these are set up. | |
| 47 protected long jbooleanSize; | |
| 48 protected long jbyteSize; | |
| 49 protected long jcharSize; | |
| 50 protected long jdoubleSize; | |
| 51 protected long jfloatSize; | |
| 52 protected long jintSize; | |
| 53 protected long jlongSize; | |
| 54 protected long jshortSize; | |
| 55 protected boolean javaPrimitiveTypesConfigured; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
56 // heap data. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
57 protected long oopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
58 protected long heapOopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
59 protected long heapBase; // heap base for compressed oops. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
60 protected long logMinObjAlignmentInBytes; // Used to decode compressed oops. |
| 0 | 61 // Should be initialized if desired by calling initCache() |
| 62 private PageCache cache; | |
| 63 | |
| 64 // State for faster accessors that don't allocate memory on each read | |
| 65 private boolean useFastAccessors; | |
| 66 private boolean bigEndian; | |
| 67 | |
| 68 // Page-fetching functionality for LRU cache | |
| 69 class Fetcher implements PageFetcher { | |
| 70 public Page fetchPage(long pageBaseAddress, long numBytes) { | |
| 71 // This assumes that if any byte is unmapped, that the entire | |
| 72 // page is. The common case, however, is that the page is | |
| 73 // mapped, so we always fetch the entire thing all at once to | |
| 74 // avoid two round-trip communications per page fetch, even | |
| 75 // though fetching of unmapped pages will be slow. | |
| 76 ReadResult res = readBytesFromProcess(pageBaseAddress, numBytes); | |
| 77 if (res.getData() == null) { | |
| 78 return new Page(pageBaseAddress, numBytes); | |
| 79 } | |
| 80 return new Page(pageBaseAddress, res.getData()); | |
| 81 } | |
| 82 } | |
| 83 | |
| 84 protected DebuggerBase() { | |
| 85 } | |
| 86 | |
| 87 /** From the JVMDebugger interface. This is the only public method | |
| 88 of this class. */ | |
| 89 public void configureJavaPrimitiveTypeSizes(long jbooleanSize, | |
| 90 long jbyteSize, | |
| 91 long jcharSize, | |
| 92 long jdoubleSize, | |
| 93 long jfloatSize, | |
| 94 long jintSize, | |
| 95 long jlongSize, | |
| 96 long jshortSize) { | |
| 97 this.jbooleanSize = jbooleanSize; | |
| 98 this.jbyteSize = jbyteSize; | |
| 99 this.jcharSize = jcharSize; | |
| 100 this.jdoubleSize = jdoubleSize; | |
| 101 this.jfloatSize = jfloatSize; | |
| 102 this.jintSize = jintSize; | |
| 103 this.jlongSize = jlongSize; | |
| 104 this.jshortSize = jshortSize; | |
| 105 | |
| 106 if (jbooleanSize < 1) { | |
| 107 throw new RuntimeException("jboolean size is too small"); | |
| 108 } | |
| 109 | |
| 110 if (jbyteSize < 1) { | |
| 111 throw new RuntimeException("jbyte size is too small"); | |
| 112 } | |
| 113 | |
| 114 if (jcharSize < 2) { | |
| 115 throw new RuntimeException("jchar size is too small"); | |
| 116 } | |
| 117 | |
| 118 if (jdoubleSize < 8) { | |
| 119 throw new RuntimeException("jdouble size is too small"); | |
| 120 } | |
| 121 | |
| 122 if (jfloatSize < 4) { | |
| 123 throw new RuntimeException("jfloat size is too small"); | |
| 124 } | |
| 125 | |
| 126 if (jintSize < 4) { | |
| 127 throw new RuntimeException("jint size is too small"); | |
| 128 } | |
| 129 | |
| 130 if (jlongSize < 8) { | |
| 131 throw new RuntimeException("jlong size is too small"); | |
| 132 } | |
| 133 | |
| 134 if (jshortSize < 2) { | |
| 135 throw new RuntimeException("jshort size is too small"); | |
| 136 } | |
| 137 | |
| 138 if (jintSize != jfloatSize) { | |
| 139 // If dataToJFloat were rewritten, this wouldn't be necessary | |
| 140 throw new RuntimeException("jint size and jfloat size must be equal"); | |
| 141 } | |
| 142 | |
| 143 if (jlongSize != jdoubleSize) { | |
| 144 // If dataToJDouble were rewritten, this wouldn't be necessary | |
| 145 throw new RuntimeException("jlong size and jdouble size must be equal"); | |
| 146 } | |
| 147 | |
| 148 useFastAccessors = | |
| 149 ((cache != null) && | |
| 150 (jbooleanSize == 1) && | |
| 151 (jbyteSize == 1) && | |
| 152 (jcharSize == 2) && | |
| 153 (jdoubleSize == 8) && | |
| 154 (jfloatSize == 4) && | |
| 155 (jintSize == 4) && | |
| 156 (jlongSize == 8) && | |
| 157 (jshortSize == 2)); | |
| 158 | |
| 159 javaPrimitiveTypesConfigured = true; | |
| 160 } | |
| 161 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
162 public void putHeapConst(long heapBase, long heapOopSize, long logMinObjAlignmentInBytes) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
163 this.heapBase = heapBase; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
164 this.heapOopSize = heapOopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
165 this.logMinObjAlignmentInBytes = logMinObjAlignmentInBytes; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
166 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
167 |
| 0 | 168 /** May be called by subclasses if desired to initialize the page |
| 169 cache but may not be overridden */ | |
| 170 protected final void initCache(long pageSize, long maxNumPages) { | |
| 171 cache = new PageCache(pageSize, maxNumPages, new Fetcher()); | |
| 172 if (machDesc != null) { | |
| 173 bigEndian = machDesc.isBigEndian(); | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 /** May be called by subclasses if needed (if the machine | |
| 178 description is not available at the time of cache | |
| 179 initialization, as on Solaris) but may not be overridden */ | |
| 180 protected final void setBigEndian(boolean bigEndian) { | |
| 181 this.bigEndian = bigEndian; | |
| 182 } | |
| 183 | |
| 184 /** May be called by subclasses to clear out the cache but may not | |
| 185 be overridden. For convenience, this can be called even if the | |
| 186 cache has not been initialized. */ | |
| 187 protected final void clearCache() { | |
| 188 if (cache != null) { | |
| 189 cache.clear(); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 /** May be called by subclasses to disable the cache (for example, | |
| 194 when the target process has been resumed) but may not be | |
| 195 overridden. For convenience, this can be called even if the | |
| 196 cache has not been initialized. */ | |
| 197 protected final void disableCache() { | |
| 198 if (cache != null) { | |
| 199 cache.disable(); | |
| 200 } | |
| 201 } | |
| 202 | |
| 203 /** May be called by subclasses to re-enable the cache (for example, | |
| 204 when the target process has been suspended) but may not be | |
| 205 overridden. For convenience, this can be called even if the | |
| 206 cache has not been initialized. */ | |
| 207 protected final void enableCache() { | |
| 208 if (cache != null) { | |
| 209 cache.enable(); | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 /** May be called by subclasses directly but may not be overridden */ | |
| 214 protected final byte[] readBytes(long address, long numBytes) | |
| 215 throws UnmappedAddressException, DebuggerException { | |
| 216 if (cache != null) { | |
| 217 return cache.getData(address, numBytes); | |
| 218 } else { | |
| 219 ReadResult res = readBytesFromProcess(address, numBytes); | |
| 220 if (res.getData() != null) { | |
| 221 return res.getData(); | |
| 222 } | |
| 223 throw new UnmappedAddressException(res.getFailureAddress()); | |
| 224 } | |
| 225 } | |
| 226 | |
| 227 /** May be called by subclasses directly but may not be overridden */ | |
| 228 protected final void writeBytes(long address, long numBytes, byte[] data) | |
| 229 throws UnmappedAddressException, DebuggerException { | |
| 230 if (cache != null) { | |
| 231 cache.clear(address, numBytes); | |
| 232 } | |
| 233 writeBytesToProcess(address, numBytes, data); | |
| 234 } | |
| 235 | |
| 236 public boolean readJBoolean(long address) | |
| 237 throws UnmappedAddressException, UnalignedAddressException { | |
| 238 checkJavaConfigured(); | |
| 239 utils.checkAlignment(address, jbooleanSize); | |
| 240 if (useFastAccessors) { | |
| 241 return (cache.getByte(address) != 0); | |
| 242 } else { | |
| 243 byte[] data = readBytes(address, jbooleanSize); | |
| 244 return utils.dataToJBoolean(data, jbooleanSize); | |
| 245 } | |
| 246 } | |
| 247 | |
| 248 public byte readJByte(long address) | |
| 249 throws UnmappedAddressException, UnalignedAddressException { | |
| 250 checkJavaConfigured(); | |
| 251 utils.checkAlignment(address, jbyteSize); | |
| 252 if (useFastAccessors) { | |
| 253 return cache.getByte(address); | |
| 254 } else { | |
| 255 byte[] data = readBytes(address, jbyteSize); | |
| 256 return utils.dataToJByte(data, jbyteSize); | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 261 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 262 public char readJChar(long address) | |
| 263 throws UnmappedAddressException, UnalignedAddressException { | |
| 264 checkJavaConfigured(); | |
| 265 utils.checkAlignment(address, jcharSize); | |
| 266 if (useFastAccessors) { | |
| 267 return cache.getChar(address, bigEndian); | |
| 268 } else { | |
| 269 byte[] data = readBytes(address, jcharSize); | |
| 270 return (char) utils.dataToJChar(data, jcharSize); | |
| 271 } | |
| 272 } | |
| 273 | |
| 274 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 275 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 276 public double readJDouble(long address) | |
| 277 throws UnmappedAddressException, UnalignedAddressException { | |
| 278 checkJavaConfigured(); | |
| 279 utils.checkAlignment(address, jdoubleSize); | |
| 280 if (useFastAccessors) { | |
| 281 return cache.getDouble(address, bigEndian); | |
| 282 } else { | |
| 283 byte[] data = readBytes(address, jdoubleSize); | |
| 284 return utils.dataToJDouble(data, jdoubleSize); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 289 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 290 public float readJFloat(long address) | |
| 291 throws UnmappedAddressException, UnalignedAddressException { | |
| 292 checkJavaConfigured(); | |
| 293 utils.checkAlignment(address, jfloatSize); | |
| 294 if (useFastAccessors) { | |
| 295 return cache.getFloat(address, bigEndian); | |
| 296 } else { | |
| 297 byte[] data = readBytes(address, jfloatSize); | |
| 298 return utils.dataToJFloat(data, jfloatSize); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 303 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 304 public int readJInt(long address) | |
| 305 throws UnmappedAddressException, UnalignedAddressException { | |
| 306 checkJavaConfigured(); | |
| 307 utils.checkAlignment(address, jintSize); | |
| 308 if (useFastAccessors) { | |
| 309 return cache.getInt(address, bigEndian); | |
| 310 } else { | |
| 311 byte[] data = readBytes(address, jintSize); | |
| 312 return utils.dataToJInt(data, jintSize); | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 317 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 318 public long readJLong(long address) | |
| 319 throws UnmappedAddressException, UnalignedAddressException { | |
| 320 checkJavaConfigured(); | |
| 321 utils.checkAlignment(address, jlongSize); | |
| 322 if (useFastAccessors) { | |
| 323 return cache.getLong(address, bigEndian); | |
| 324 } else { | |
| 325 byte[] data = readBytes(address, jlongSize); | |
| 326 return utils.dataToJLong(data, jlongSize); | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 331 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 332 public short readJShort(long address) | |
| 333 throws UnmappedAddressException, UnalignedAddressException { | |
| 334 checkJavaConfigured(); | |
| 335 utils.checkAlignment(address, jshortSize); | |
| 336 if (useFastAccessors) { | |
| 337 return cache.getShort(address, bigEndian); | |
| 338 } else { | |
| 339 byte[] data = readBytes(address, jshortSize); | |
| 340 return utils.dataToJShort(data, jshortSize); | |
| 341 } | |
| 342 } | |
| 343 | |
| 344 // NOTE: assumes value does not span pages (may be bad assumption on | |
| 345 // Solaris/x86; see unalignedAccessesOkay in DbxDebugger hierarchy) | |
| 346 public long readCInteger(long address, long numBytes, boolean isUnsigned) | |
| 347 throws UnmappedAddressException, UnalignedAddressException { | |
| 348 checkConfigured(); | |
| 349 utils.checkAlignment(address, numBytes); | |
| 350 if (useFastAccessors) { | |
| 351 if (isUnsigned) { | |
| 352 switch((int) numBytes) { | |
| 353 case 1: return cache.getByte(address) & 0xFF; | |
| 354 case 2: return cache.getShort(address, bigEndian) & 0xFFFF; | |
| 355 case 4: return cache.getInt(address, bigEndian) & 0xFFFFFFFFL; | |
| 356 case 8: return cache.getLong(address, bigEndian); | |
| 357 default: { | |
| 358 byte[] data = readBytes(address, numBytes); | |
| 359 return utils.dataToCInteger(data, isUnsigned); | |
| 360 } | |
| 361 } | |
| 362 } else { | |
| 363 switch((int) numBytes) { | |
| 364 case 1: return cache.getByte(address); | |
| 365 case 2: return cache.getShort(address, bigEndian); | |
| 366 case 4: return cache.getInt(address, bigEndian); | |
| 367 case 8: return cache.getLong(address, bigEndian); | |
| 368 default: { | |
| 369 byte[] data = readBytes(address, numBytes); | |
| 370 return utils.dataToCInteger(data, isUnsigned); | |
| 371 } | |
| 372 } | |
| 373 } | |
| 374 } else { | |
| 375 byte[] data = readBytes(address, numBytes); | |
| 376 return utils.dataToCInteger(data, isUnsigned); | |
| 377 } | |
| 378 } | |
| 379 | |
| 380 public void writeJBoolean(long address, boolean value) | |
| 381 throws UnmappedAddressException, UnalignedAddressException { | |
| 382 checkJavaConfigured(); | |
| 383 utils.checkAlignment(address, jbooleanSize); | |
| 384 byte[] data = utils.jbooleanToData(value); | |
| 385 writeBytes(address, jbooleanSize, data); | |
| 386 } | |
| 387 | |
| 388 public void writeJByte(long address, byte value) | |
| 389 throws UnmappedAddressException, UnalignedAddressException { | |
| 390 checkJavaConfigured(); | |
| 391 utils.checkAlignment(address, jbyteSize); | |
| 392 byte[] data = utils.jbyteToData(value); | |
| 393 writeBytes(address, jbyteSize, data); | |
| 394 } | |
| 395 | |
| 396 public void writeJChar(long address, char value) | |
| 397 throws UnmappedAddressException, UnalignedAddressException { | |
| 398 checkJavaConfigured(); | |
| 399 utils.checkAlignment(address, jcharSize); | |
| 400 byte[] data = utils.jcharToData(value); | |
| 401 writeBytes(address, jcharSize, data); | |
| 402 } | |
| 403 | |
| 404 public void writeJDouble(long address, double value) | |
| 405 throws UnmappedAddressException, UnalignedAddressException { | |
| 406 checkJavaConfigured(); | |
| 407 utils.checkAlignment(address, jdoubleSize); | |
| 408 byte[] data = utils.jdoubleToData(value); | |
| 409 writeBytes(address, jdoubleSize, data); | |
| 410 } | |
| 411 | |
| 412 public void writeJFloat(long address, float value) | |
| 413 throws UnmappedAddressException, UnalignedAddressException { | |
| 414 checkJavaConfigured(); | |
| 415 utils.checkAlignment(address, jfloatSize); | |
| 416 byte[] data = utils.jfloatToData(value); | |
| 417 writeBytes(address, jfloatSize, data); | |
| 418 } | |
| 419 | |
| 420 public void writeJInt(long address, int value) | |
| 421 throws UnmappedAddressException, UnalignedAddressException { | |
| 422 checkJavaConfigured(); | |
| 423 utils.checkAlignment(address, jintSize); | |
| 424 byte[] data = utils.jintToData(value); | |
| 425 writeBytes(address, jintSize, data); | |
| 426 } | |
| 427 | |
| 428 public void writeJLong(long address, long value) | |
| 429 throws UnmappedAddressException, UnalignedAddressException { | |
| 430 checkJavaConfigured(); | |
| 431 utils.checkAlignment(address, jlongSize); | |
| 432 byte[] data = utils.jlongToData(value); | |
| 433 writeBytes(address, jlongSize, data); | |
| 434 } | |
| 435 | |
| 436 public void writeJShort(long address, short value) | |
| 437 throws UnmappedAddressException, UnalignedAddressException { | |
| 438 checkJavaConfigured(); | |
| 439 utils.checkAlignment(address, jshortSize); | |
| 440 byte[] data = utils.jshortToData(value); | |
| 441 writeBytes(address, jshortSize, data); | |
| 442 } | |
| 443 | |
| 444 public void writeCInteger(long address, long numBytes, long value) | |
| 445 throws UnmappedAddressException, UnalignedAddressException { | |
| 446 checkConfigured(); | |
| 447 utils.checkAlignment(address, numBytes); | |
| 448 byte[] data = utils.cIntegerToData(numBytes, value); | |
| 449 writeBytes(address, numBytes, data); | |
| 450 } | |
| 451 | |
| 452 protected long readAddressValue(long address) | |
| 453 throws UnmappedAddressException, UnalignedAddressException { | |
| 454 return readCInteger(address, machDesc.getAddressSize(), true); | |
| 455 } | |
| 456 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
457 protected long readCompOopAddressValue(long address) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
458 throws UnmappedAddressException, UnalignedAddressException { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
459 long value = readCInteger(address, getHeapOopSize(), true); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
460 if (value != 0) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
461 // See oop.inline.hpp decode_heap_oop |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
462 value = (long)(heapBase + (long)(value << logMinObjAlignmentInBytes)); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
463 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
464 return value; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
465 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
466 |
| 0 | 467 protected void writeAddressValue(long address, long value) |
| 468 throws UnmappedAddressException, UnalignedAddressException { | |
| 469 writeCInteger(address, machDesc.getAddressSize(), value); | |
| 470 } | |
| 471 | |
| 472 /** Can be called by subclasses but can not be overridden */ | |
| 473 protected final void checkConfigured() { | |
| 474 if (machDesc == null) { | |
| 475 throw new RuntimeException("MachineDescription must have been set by this point"); | |
| 476 } | |
| 477 if (utils == null) { | |
| 478 throw new RuntimeException("DebuggerUtilities must have been set by this point"); | |
| 479 } | |
| 480 } | |
| 481 | |
| 482 /** Can be called by subclasses but can not be overridden */ | |
| 483 protected final void checkJavaConfigured() { | |
| 484 checkConfigured(); | |
| 485 | |
| 486 if (!javaPrimitiveTypesConfigured) { | |
| 487 throw new RuntimeException("Java primitive type sizes have not yet been configured"); | |
| 488 } | |
| 489 } | |
| 490 | |
| 491 /** Possibly override page cache size with user-specified property */ | |
| 492 protected int parseCacheNumPagesProperty(int defaultNum) { | |
| 493 String cacheNumPagesString = System.getProperty("cacheNumPages"); | |
| 494 if (cacheNumPagesString != null) { | |
| 495 try { | |
| 496 return Integer.parseInt(cacheNumPagesString); | |
| 497 } catch (Exception e) { | |
| 498 System.err.println("Error parsing cacheNumPages property:"); | |
| 499 e.printStackTrace(); | |
| 500 } | |
| 501 } | |
| 502 return defaultNum; | |
| 503 } | |
| 504 | |
| 505 /** Interim solution for allowing subclasses to write bytes to | |
| 506 process until we make that functionality available in the basic | |
| 507 Address interface */ | |
| 508 protected void invalidatePageCache(long startAddress, long numBytes) { | |
| 509 cache.clear(startAddress, numBytes); | |
| 510 } | |
| 511 | |
| 512 public long getJBooleanSize() { | |
| 513 return jbooleanSize; | |
| 514 } | |
| 515 | |
| 516 public long getJByteSize() { | |
| 517 return jbyteSize; | |
| 518 } | |
| 519 | |
| 520 public long getJCharSize() { | |
| 521 return jcharSize; | |
| 522 } | |
| 523 | |
| 524 public long getJDoubleSize() { | |
| 525 return jdoubleSize; | |
| 526 } | |
| 527 | |
| 528 public long getJFloatSize() { | |
| 529 return jfloatSize; | |
| 530 } | |
| 531 | |
| 532 public long getJIntSize() { | |
| 533 return jintSize; | |
| 534 } | |
| 535 | |
| 536 public long getJLongSize() { | |
| 537 return jlongSize; | |
| 538 } | |
| 539 | |
| 540 public long getJShortSize() { | |
| 541 return jshortSize; | |
| 542 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
543 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
544 public long getHeapOopSize() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
545 return heapOopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
546 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
547 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
548 public long getHeapBase() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
549 return heapBase; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
550 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
551 public long getLogMinObjAlignmentInBytes() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
552 return logMinObjAlignmentInBytes; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
553 } |
| 0 | 554 } |