1 /*
2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package sun.jvm.hotspot.runtime;
26
27 import java.io.*;
28 import java.net.*;
29 import java.util.*;
30 import java.util.regex.*;
31 import sun.jvm.hotspot.code.*;
32 import sun.jvm.hotspot.c1.*;
33 import sun.jvm.hotspot.code.*;
34 import sun.jvm.hotspot.debugger.*;
35 import sun.jvm.hotspot.interpreter.*;
36 import sun.jvm.hotspot.memory.*;
37 import sun.jvm.hotspot.oops.*;
38 import sun.jvm.hotspot.types.*;
39 import sun.jvm.hotspot.utilities.*;
40 import sun.jvm.hotspot.runtime.*;
41
42 /** <P> This class encapsulates the global state of the VM; the
43 universe, object heap, interpreter, etc. It is a Singleton and
44 must be initialized with a call to initialize() before calling
45 getVM(). </P>
46
47 <P> Many auxiliary classes (i.e., most of the VMObjects) keep
48 needed field offsets in the form of static Field objects. In a
49 debugging system, the VM might be shutdown and re-initialized (on
50 a differently-configured build, i.e., 32- vs. 64-bit), and all old
51 cached state (including fields and field offsets) must be
52 flushed. </P>
53
54 <P> An Observer pattern is used to implement the initialization of
55 such classes. Each such class, in its static initializer,
56 registers an Observer with the VM class via
57 VM.registerVMInitializedObserver(). This Observer is guaranteed to
58 be notified whenever the VM is initialized (or re-initialized). To
59 implement the first-time initialization, the observer is also
60 notified when it registers itself with the VM. (For bootstrapping
61 reasons, this implies that the constructor of VM can not
62 instantiate any such objects, since VM.soleInstance will not have
63 been set yet. This is a bootstrapping issue which may have to be
64 revisited later.) </P>
65 */
66
67 public class VM {
68 private static VM soleInstance;
69 private static List vmInitializedObservers = new ArrayList();
70 private List vmResumedObservers = new ArrayList();
71 private List vmSuspendedObservers = new ArrayList();
72 private TypeDataBase db;
73 private boolean isBigEndian;
74 /** This is only present if in a debugging system */
75 private JVMDebugger debugger;
76 private long stackBias;
77 private long logAddressSize;
78 private Universe universe;
79 private ObjectHeap heap;
80 private SymbolTable symbols;
81 private StringTable strings;
82 private SystemDictionary dict;
83 private Threads threads;
84 private ObjectSynchronizer synchronizer;
85 private JNIHandles handles;
86 private Interpreter interpreter;
87 private StubRoutines stubRoutines;
88 private Bytes bytes;
89
90 /** Flags indicating whether we are attached to a core, C1, or C2 build */
91 private boolean usingClientCompiler;
92 private boolean usingServerCompiler;
93 /** alignment constants */
94 private boolean isLP64;
95 private int bytesPerLong;
96 private int bytesPerWord;
97 private int objectAlignmentInBytes;
98 private int minObjAlignmentInBytes;
99 private int logMinObjAlignmentInBytes;
100 private int heapWordSize;
101 private int heapOopSize;
102 private int klassPtrSize;
103 private int oopSize;
104 /** This is only present in a non-core build */
105 private CodeCache codeCache;
106 /** This is only present in a C1 build */
107 private Runtime1 runtime1;
108 /** These constants come from globalDefinitions.hpp */
109 private int invocationEntryBCI;
110 private int invalidOSREntryBCI;
111 private ReversePtrs revPtrs;
112 private VMRegImpl vmregImpl;
113 private int reserveForAllocationPrefetch;
114
115 // System.getProperties from debuggee VM
116 private Properties sysProps;
117
118 // VM version strings come from Abstract_VM_Version class
119 private String vmRelease;
120 private String vmInternalInfo;
121
122 private Flag[] commandLineFlags;
123 private Map flagsMap;
124
125 private static Type intxType;
126 private static Type uintxType;
127 private static CIntegerType boolType;
128 private Boolean sharingEnabled;
129 private Boolean compressedOopsEnabled;
130 private Boolean compressedKlassPointersEnabled;
131
132 // command line flags supplied to VM - see struct Flag in globals.hpp
133 public static final class Flag {
134 private String type;
135 private String name;
136 private Address addr;
137 private String kind;
138 private int origin;
139
140 private Flag(String type, String name, Address addr, String kind, int origin) {
141 this.type = type;
142 this.name = name;
143 this.addr = addr;
144 this.kind = kind;
145 this.origin = origin;
146 }
147
148 public String getType() {
149 return type;
150 }
151
152 public String getName() {
153 return name;
154 }
155
156 public Address getAddress() {
157 return addr;
158 }
159
160 public String getKind() {
161 return kind;
162 }
163
164 public int getOrigin() {
165 return origin;
166 }
167
168 public boolean isBool() {
169 return type.equals("bool");
170 }
171
172 public boolean getBool() {
173 if (Assert.ASSERTS_ENABLED) {
174 Assert.that(isBool(), "not a bool flag!");
175 }
176 return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned())
177 != 0;
178 }
179
180 public boolean isIntx() {
181 return type.equals("intx");
182 }
183
184 public long getIntx() {
185 if (Assert.ASSERTS_ENABLED) {
186 Assert.that(isIntx(), "not a intx flag!");
187 }
188 return addr.getCIntegerAt(0, intxType.getSize(), false);
189 }
190
191 public boolean isUIntx() {
192 return type.equals("uintx");
193 }
194
195 public long getUIntx() {
196 if (Assert.ASSERTS_ENABLED) {
197 Assert.that(isUIntx(), "not a uintx flag!");
198 }
199 return addr.getCIntegerAt(0, uintxType.getSize(), true);
200 }
201
202 public String getValue() {
203 if (isBool()) {
204 return new Boolean(getBool()).toString();
205 } else if (isIntx()) {
206 return new Long(getIntx()).toString();
207 } else if (isUIntx()) {
208 return new Long(getUIntx()).toString();
209 } else {
210 return null;
211 }
212 }
213 };
214
215 private static void checkVMVersion(String vmRelease) {
216 if (System.getProperty("sun.jvm.hotspot.runtime.VM.disableVersionCheck") == null) {
217 // read sa build version.
218 String versionProp = "sun.jvm.hotspot.runtime.VM.saBuildVersion";
219 String saVersion = saProps.getProperty(versionProp);
220 if (saVersion == null)
221 throw new RuntimeException("Missing property " + versionProp);
222
223 // Strip nonproduct VM version substring (note: saVersion doesn't have it).
224 String vmVersion = vmRelease.replaceAll("(-fastdebug)|(-debug)|(-jvmg)|(-optimized)|(-profiled)","");
225
226 if (saVersion.equals(vmVersion)) {
227 // Exact match
228 return;
229 }
230 if (saVersion.indexOf('-') == saVersion.lastIndexOf('-') &&
231 vmVersion.indexOf('-') == vmVersion.lastIndexOf('-')) {
232 // Throw exception if different release versions:
233 // <major>.<minor>-b<n>
234 throw new VMVersionMismatchException(saVersion, vmRelease);
235 } else {
236 // Otherwise print warning to allow mismatch not release versions
237 // during development.
238 System.err.println("WARNING: Hotspot VM version " + vmRelease +
239 " does not match with SA version " + saVersion +
240 "." + " You may see unexpected results. ");
241 }
242 } else {
243 System.err.println("WARNING: You have disabled SA and VM version check. You may be " +
244 "using incompatible version of SA and you may see unexpected " +
245 "results.");
246 }
247 }
248
249 private static final boolean disableDerivedPointerTableCheck;
250 private static final Properties saProps;
251
252 static {
253 saProps = new Properties();
254 URL url = null;
255 try {
256 url = VM.class.getClassLoader().getResource("sa.properties");
257 saProps.load(new BufferedInputStream(url.openStream()));
258 } catch (Exception e) {
259 System.err.println("Unable to load properties " +
260 (url == null ? "null" : url.toString()) +
261 ": " + e.getMessage());
262 }
263
264 disableDerivedPointerTableCheck = System.getProperty("sun.jvm.hotspot.runtime.VM.disableDerivedPointerTableCheck") != null;
265 }
266
267 private VM(TypeDataBase db, JVMDebugger debugger, boolean isBigEndian) {
268 this.db = db;
269 this.debugger = debugger;
270 this.isBigEndian = isBigEndian;
271
272 // Note that we don't construct universe, heap, threads,
273 // interpreter, or stubRoutines here (any more). The current
274 // initialization mechanisms require that the VM be completely set
275 // up (i.e., out of its constructor, with soleInstance assigned)
276 // before their static initializers are run.
277
278 if (db.getAddressSize() == 4) {
279 logAddressSize = 2;
280 } else if (db.getAddressSize() == 8) {
281 logAddressSize = 3;
282 } else {
283 throw new RuntimeException("Address size " + db.getAddressSize() + " not yet supported");
284 }
285
286 // read VM version info
287 try {
288 Type vmVersion = db.lookupType("Abstract_VM_Version");
289 Address releaseAddr = vmVersion.getAddressField("_s_vm_release").getValue();
290 vmRelease = CStringUtilities.getString(releaseAddr);
291 Address vmInternalInfoAddr = vmVersion.getAddressField("_s_internal_vm_info_string").getValue();
292 vmInternalInfo = CStringUtilities.getString(vmInternalInfoAddr);
293
294 CIntegerType intType = (CIntegerType) db.lookupType("int");
295 CIntegerField reserveForAllocationPrefetchField = vmVersion.getCIntegerField("_reserve_for_allocation_prefetch");
296 reserveForAllocationPrefetch = (int)reserveForAllocationPrefetchField.getCInteger(intType);
297 } catch (Exception exp) {
298 throw new RuntimeException("can't determine target's VM version : " + exp.getMessage());
299 }
300
301 checkVMVersion(vmRelease);
302
303 stackBias = db.lookupIntConstant("STACK_BIAS").intValue();
304 invocationEntryBCI = db.lookupIntConstant("InvocationEntryBci").intValue();
305 invalidOSREntryBCI = db.lookupIntConstant("InvalidOSREntryBci").intValue();
306
307 // We infer the presence of C1 or C2 from a couple of fields we
308 // already have present in the type database
309 {
310 Type type = db.lookupType("Method");
311 if (type.getField("_from_compiled_entry", false, false) == null) {
312 // Neither C1 nor C2 is present
313 usingClientCompiler = false;
314 usingServerCompiler = false;
315 } else {
316 // Determine whether C2 is present
317 if (db.lookupType("Matcher", false) != null) {
318 usingServerCompiler = true;
319 } else {
320 usingClientCompiler = true;
321 }
322 }
323 }
324
325 if (debugger != null) {
326 isLP64 = debugger.getMachineDescription().isLP64();
327 }
328 bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue();
329 bytesPerWord = db.lookupIntConstant("BytesPerWord").intValue();
330 heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
331 oopSize = db.lookupIntConstant("oopSize").intValue();
332
333 intxType = db.lookupType("intx");
334 uintxType = db.lookupType("uintx");
335 boolType = (CIntegerType) db.lookupType("bool");
336
337 minObjAlignmentInBytes = getObjectAlignmentInBytes();
338 if (minObjAlignmentInBytes == 8) {
339 logMinObjAlignmentInBytes = 3;
340 } else if (minObjAlignmentInBytes == 16) {
341 logMinObjAlignmentInBytes = 4;
342 } else {
343 throw new RuntimeException("Object alignment " + minObjAlignmentInBytes + " not yet supported");
344 }
345
346 if (isCompressedOopsEnabled()) {
347 // Size info for oops within java objects is fixed
348 heapOopSize = (int)getIntSize();
349 } else {
350 heapOopSize = (int)getOopSize();
351 }
352
353 if (isCompressedKlassPointersEnabled()) {
354 klassPtrSize = (int)getIntSize();
355 } else {
356 klassPtrSize = (int)getOopSize(); // same as an oop
357 }
358 }
359
360 /** This could be used by a reflective runtime system */
361 public static void initialize(TypeDataBase db, boolean isBigEndian) {
362 if (soleInstance != null) {
363 throw new RuntimeException("Attempt to initialize VM twice");
364 }
365 soleInstance = new VM(db, null, isBigEndian);
366 for (Iterator iter = vmInitializedObservers.iterator(); iter.hasNext(); ) {
367 ((Observer) iter.next()).update(null, null);
368 }
369 }
370
371 /** This is used by the debugging system */
372 public static void initialize(TypeDataBase db, JVMDebugger debugger) {
373 if (soleInstance != null) {
374 // Using multiple SA Tool classes in the same process creates a call here.
375 return;
376 }
377 soleInstance = new VM(db, debugger, debugger.getMachineDescription().isBigEndian());
378
379 for (Iterator iter = vmInitializedObservers.iterator(); iter.hasNext(); ) {
380 ((Observer) iter.next()).update(null, null);
381 }
382
383 debugger.putHeapConst(soleInstance.getHeapOopSize(), soleInstance.getKlassPtrSize(),
384 Universe.getNarrowOopBase(), Universe.getNarrowOopShift(),
385 Universe.getNarrowKlassBase(), Universe.getNarrowKlassShift());
386 }
387
388 /** This is used by the debugging system */
389 public static void shutdown() {
390 soleInstance = null;
391 }
392
393 /** This is used by both the debugger and any runtime system. It is
394 the basic mechanism by which classes which mimic underlying VM
395 functionality cause themselves to be initialized. The given
396 observer will be notified (with arguments (null, null)) when the
397 VM is re-initialized, as well as when it registers itself with
398 the VM. */
399 public static void registerVMInitializedObserver(Observer o) {
400 vmInitializedObservers.add(o);
401 o.update(null, null);
402 }
403
404 /** This is the primary accessor used by both the debugger and any
405 potential runtime system */
406 public static VM getVM() {
407 if (soleInstance == null) {
408 throw new RuntimeException("VM.initialize() was not yet called");
409 }
410 return soleInstance;
411 }
412
413 /** This is only used by the debugging system. The given observer
414 will be notified if the underlying VM resumes execution. NOTE
415 that the given observer is not triggered if the VM is currently
416 running and therefore differs in behavior from {@link
417 #registerVMInitializedObserver} (because of the possibility of
418 race conditions if the observer is added while the VM is being
419 suspended or resumed). */
420 public void registerVMResumedObserver(Observer o) {
421 vmResumedObservers.add(o);
422 }
423
424 /** This is only used by the debugging system. The given observer
425 will be notified if the underlying VM suspends execution. NOTE
426 that the given observer is not triggered if the VM is currently
427 suspended and therefore differs in behavior from {@link
428 #registerVMInitializedObserver} (because of the possibility of
429 race conditions if the observer is added while the VM is being
430 suspended or resumed). */
431 public void registerVMSuspendedObserver(Observer o) {
432 vmSuspendedObservers.add(o);
433 }
434
435 /** This is only used by the debugging system. Informs all
436 registered resumption observers that the VM has been resumed.
437 The application is responsible for actually having performed the
438 resumption. No OopHandles must be used after this point, as they
439 may move in the target address space due to garbage
440 collection. */
441 public void fireVMResumed() {
442 for (Iterator iter = vmResumedObservers.iterator(); iter.hasNext(); ) {
443 ((Observer) iter.next()).update(null, null);
444 }
445 }
446
447 /** This is only used by the debugging system. Informs all
448 registered suspension observers that the VM has been suspended.
449 The application is responsible for actually having performed the
450 suspension. Garbage collection must be forbidden at this point;
451 for example, a JPDA-level suspension is not adequate since the
452 VM thread may still be running. */
453 public void fireVMSuspended() {
454 for (Iterator iter = vmSuspendedObservers.iterator(); iter.hasNext(); ) {
455 ((Observer) iter.next()).update(null, null);
456 }
457 }
458
459 /** Returns the OS this VM is running on. Notice that by delegating
460 to the debugger we can transparently support remote
461 debugging. */
462 public String getOS() {
463 if (debugger != null) {
464 return debugger.getOS();
465 }
466 return PlatformInfo.getOS();
467 }
468
469 /** Returns the CPU this VM is running on. Notice that by delegating
470 to the debugger we can transparently support remote
471 debugging. */
472 public String getCPU() {
473 if (debugger != null) {
474 return debugger.getCPU();
475 }
476 return PlatformInfo.getCPU();
477 }
478
479 public Type lookupType(String cTypeName) {
480 return db.lookupType(cTypeName);
481 }
482
483 public Integer lookupIntConstant(String name) {
484 return db.lookupIntConstant(name);
485 }
486
487 // Convenience function for conversions
488 static public long getAddressValue(Address addr) {
489 return VM.getVM().getDebugger().getAddressValue(addr);
490 }
491
492 public long getAddressSize() {
493 return db.getAddressSize();
494 }
495
496 public long getOopSize() {
497 return oopSize;
498 }
499
500 public long getLogAddressSize() {
501 return logAddressSize;
502 }
503
504 public long getIntSize() {
505 return db.getJIntType().getSize();
506 }
507
508 /** NOTE: this offset is in BYTES in this system! */
509 public long getStackBias() {
510 return stackBias;
511 }
512
513 /** Indicates whether the underlying machine supports the LP64 data
514 model. This is needed for conditionalizing code in a few places */
515 public boolean isLP64() {
516 if (Assert.ASSERTS_ENABLED) {
517 Assert.that(isDebugging(), "Debugging system only for now");
518 }
519 return isLP64;
520 }
521
522 /** Get bytes-per-long == long/double natural alignment. */
523 public int getBytesPerLong() {
524 return bytesPerLong;
525 }
526
527 public int getBytesPerWord() {
528 return bytesPerWord;
529 }
530
531 /** Get minimum object alignment in bytes. */
532 public int getMinObjAlignmentInBytes() {
533 return minObjAlignmentInBytes;
534 }
535 public int getLogMinObjAlignmentInBytes() {
536 return logMinObjAlignmentInBytes;
537 }
538
539 public int getHeapWordSize() {
540 return heapWordSize;
541 }
542
543 public int getHeapOopSize() {
544 return heapOopSize;
545 }
546
547 public int getKlassPtrSize() {
548 return klassPtrSize;
549 }
550 /** Utility routine for getting data structure alignment correct */
551 public long alignUp(long size, long alignment) {
552 return (size + alignment - 1) & ~(alignment - 1);
553 }
554
555 /** Utility routine for getting data structure alignment correct */
556 public long alignDown(long size, long alignment) {
557 return size & ~(alignment - 1);
558 }
559
560 /** Utility routine for building an int from two "unsigned" 16-bit
561 shorts */
562 public int buildIntFromShorts(short low, short high) {
563 return (((int) high) << 16) | (((int) low) & 0xFFFF);
564 }
565
566 /** Utility routine for building a long from two "unsigned" 32-bit
567 ints in <b>platform-dependent</b> order */
568 public long buildLongFromIntsPD(int oneHalf, int otherHalf) {
569 if (isBigEndian) {
570 return (((long) otherHalf) << 32) | (((long) oneHalf) & 0x00000000FFFFFFFFL);
571 } else{
572 return (((long) oneHalf) << 32) | (((long) otherHalf) & 0x00000000FFFFFFFFL);
573 }
574 }
575
576 public TypeDataBase getTypeDataBase() {
577 return db;
578 }
579
580 public Universe getUniverse() {
581 if (universe == null) {
582 universe = new Universe();
583 }
584 return universe;
585 }
586
587 public ObjectHeap getObjectHeap() {
588 if (heap == null) {
589 heap = new ObjectHeap(db);
590 }
591 return heap;
592 }
593
594 public SymbolTable getSymbolTable() {
595 if (symbols == null) {
596 symbols = SymbolTable.getTheTable();
597 }
598 return symbols;
599 }
600
601 public StringTable getStringTable() {
602 if (strings == null) {
603 strings = StringTable.getTheTable();
604 }
605 return strings;
606 }
607
608 public SystemDictionary getSystemDictionary() {
609 if (dict == null) {
610 dict = new SystemDictionary();
611 }
612 return dict;
613 }
614
615 public Threads getThreads() {
616 if (threads == null) {
617 threads = new Threads();
618 }
619 return threads;
620 }
621
622 public ObjectSynchronizer getObjectSynchronizer() {
623 if (synchronizer == null) {
624 synchronizer = new ObjectSynchronizer();
625 }
626 return synchronizer;
627 }
628
629 public JNIHandles getJNIHandles() {
630 if (handles == null) {
631 handles = new JNIHandles();
632 }
633 return handles;
634 }
635
636 public Interpreter getInterpreter() {
637 if (interpreter == null) {
638 interpreter = new Interpreter();
639 }
640 return interpreter;
641 }
642
643 public StubRoutines getStubRoutines() {
644 if (stubRoutines == null) {
645 stubRoutines = new StubRoutines();
646 }
647 return stubRoutines;
648 }
649
650 public VMRegImpl getVMRegImplInfo() {
651 if (vmregImpl == null) {
652 vmregImpl = new VMRegImpl();
653 }
654 return vmregImpl;
655 }
656
657 public Bytes getBytes() {
658 if (bytes == null) {
659 bytes = new Bytes(debugger.getMachineDescription());
660 }
661 return bytes;
662 }
663
664 /** Returns true if this is a isBigEndian, false otherwise */
665 public boolean isBigEndian() {
666 return isBigEndian;
667 }
668
669 /** Returns true if this is a "core" build, false if either C1 or C2
670 is present */
671 public boolean isCore() {
672 return (!(usingClientCompiler || usingServerCompiler));
673 }
674
675 /** Returns true if this is a C1 build, false otherwise */
676 public boolean isClientCompiler() {
677 return usingClientCompiler;
678 }
679
680 /** Returns true if this is a C2 build, false otherwise */
681 public boolean isServerCompiler() {
682 return usingServerCompiler;
683 }
684
685 /** Returns true if C2 derived pointer table should be used, false otherwise */
686 public boolean useDerivedPointerTable() {
687 return !disableDerivedPointerTableCheck;
688 }
689
690 /** Returns the code cache; should not be used if is core build */
691 public CodeCache getCodeCache() {
692 if (Assert.ASSERTS_ENABLED) {
693 Assert.that(!isCore(), "noncore builds only");
694 }
695 if (codeCache == null) {
696 codeCache = new CodeCache();
697 }
698 return codeCache;
699 }
700
701 /** Should only be called for C1 builds */
702 public Runtime1 getRuntime1() {
703 if (Assert.ASSERTS_ENABLED) {
704 Assert.that(isClientCompiler(), "C1 builds only");
705 }
706 if (runtime1 == null) {
707 runtime1 = new Runtime1();
708 }
709 return runtime1;
710 }
711
712 /** Test to see whether we're in debugging mode (NOTE: this really
713 should not be tested by this code; currently only used in
714 StackFrameStream) */
715 public boolean isDebugging() {
716 return (debugger != null);
717 }
718
719 /** This is only used by the debugging (i.e., non-runtime) system */
720 public JVMDebugger getDebugger() {
721 if (debugger == null) {
722 throw new RuntimeException("Attempt to use debugger in runtime system");
723 }
724 return debugger;
725 }
726
727 /** Indicates whether a given program counter is in Java code. This
728 includes but is not spanned by the interpreter and code cache.
729 Only used in the debugging system, for implementing
730 JavaThread.currentFrameGuess() on x86. */
731 public boolean isJavaPCDbg(Address addr) {
732 // FIXME: this is not a complete enough set: must include areas
733 // like vtable stubs
734 return (getInterpreter().contains(addr) ||
735 getCodeCache().contains(addr));
736 }
737
738 /** FIXME: figure out where to stick this */
739 public int getInvocationEntryBCI() {
740 return invocationEntryBCI;
741 }
742
743 /** FIXME: figure out where to stick this */
744 public int getInvalidOSREntryBCI() {
745 return invalidOSREntryBCI;
746 }
747
748 // FIXME: figure out where to stick this
749 public boolean wizardMode() {
750 return true;
751 }
752
753 public ReversePtrs getRevPtrs() {
754 return revPtrs;
755 }
756
757 public void setRevPtrs(ReversePtrs rp) {
758 revPtrs = rp;
759 }
760
761 // returns null, if not available.
762 public String getVMRelease() {
763 return vmRelease;
764 }
765
766 // returns null, if not available.
767 public String getVMInternalInfo() {
768 return vmInternalInfo;
769 }
770
771 public int getReserveForAllocationPrefetch() {
772 return reserveForAllocationPrefetch;
773 }
774
775 public boolean isSharingEnabled() {
776 if (sharingEnabled == null) {
777 Flag flag = getCommandLineFlag("UseSharedSpaces");
778 sharingEnabled = (flag == null)? Boolean.FALSE :
779 (flag.getBool()? Boolean.TRUE: Boolean.FALSE);
780 }
781 return sharingEnabled.booleanValue();
782 }
783
784 public boolean isCompressedOopsEnabled() {
785 if (compressedOopsEnabled == null) {
786 Flag flag = getCommandLineFlag("UseCompressedOops");
787 compressedOopsEnabled = (flag == null) ? Boolean.FALSE:
788 (flag.getBool()? Boolean.TRUE: Boolean.FALSE);
789 }
790 return compressedOopsEnabled.booleanValue();
791 }
792
793 public boolean isCompressedKlassPointersEnabled() {
794 if (compressedKlassPointersEnabled == null) {
795 Flag flag = getCommandLineFlag("UseCompressedKlassPointers");
796 compressedKlassPointersEnabled = (flag == null) ? Boolean.FALSE:
797 (flag.getBool()? Boolean.TRUE: Boolean.FALSE);
798 }
799 return compressedKlassPointersEnabled.booleanValue();
800 }
801
802 public int getObjectAlignmentInBytes() {
803 if (objectAlignmentInBytes == 0) {
804 Flag flag = getCommandLineFlag("ObjectAlignmentInBytes");
805 objectAlignmentInBytes = (flag == null) ? 8 : (int)flag.getIntx();
806 }
807 return objectAlignmentInBytes;
808 }
809
810 /** Indicates whether Thread-Local Allocation Buffers are used */
811 public boolean getUseTLAB() {
812 Flag flag = getCommandLineFlag("UseTLAB");
813 return (flag == null) ? false: flag.getBool();
814 }
815
816 // returns null, if not available.
817 public Flag[] getCommandLineFlags() {
818 if (commandLineFlags == null) {
819 readCommandLineFlags();
820 }
821
822 return commandLineFlags;
823 }
824
825 public Flag getCommandLineFlag(String name) {
826 if (flagsMap == null) {
827 flagsMap = new HashMap();
828 Flag[] flags = getCommandLineFlags();
829 for (int i = 0; i < flags.length; i++) {
830 flagsMap.put(flags[i].getName(), flags[i]);
831 }
832 }
833 return (Flag) flagsMap.get(name);
834 }
835
836 private void readCommandLineFlags() {
837 // get command line flags
838 TypeDataBase db = getTypeDataBase();
839 Type flagType = db.lookupType("Flag");
840 int numFlags = (int) flagType.getCIntegerField("numFlags").getValue();
841 // NOTE: last flag contains null values.
842 commandLineFlags = new Flag[numFlags - 1];
843
844 Address flagAddr = flagType.getAddressField("flags").getValue();
845
846 AddressField typeFld = flagType.getAddressField("type");
847 AddressField nameFld = flagType.getAddressField("name");
848 AddressField addrFld = flagType.getAddressField("addr");
849 AddressField kindFld = flagType.getAddressField("kind");
850 CIntField originFld = new CIntField(flagType.getCIntegerField("origin"), 0);
851
852 long flagSize = flagType.getSize(); // sizeof(Flag)
853
854 // NOTE: last flag contains null values.
855 for (int f = 0; f < numFlags - 1; f++) {
856 String type = CStringUtilities.getString(typeFld.getValue(flagAddr));
857 String name = CStringUtilities.getString(nameFld.getValue(flagAddr));
858 Address addr = addrFld.getValue(flagAddr);
859 String kind = CStringUtilities.getString(kindFld.getValue(flagAddr));
860 int origin = (int)originFld.getValue(flagAddr);
861 commandLineFlags[f] = new Flag(type, name, addr, kind, origin);
862 flagAddr = flagAddr.addOffsetTo(flagSize);
863 }
864
865 // sort flags by name
866 Arrays.sort(commandLineFlags, new Comparator() {
867 public int compare(Object o1, Object o2) {
868 Flag f1 = (Flag) o1;
869 Flag f2 = (Flag) o2;
870 return f1.getName().compareTo(f2.getName());
871 }
872 });
873 }
874
875 public String getSystemProperty(String key) {
876 Properties props = getSystemProperties();
877 return (props != null)? props.getProperty(key) : null;
878 }
879
880 public Properties getSystemProperties() {
881 if (sysProps == null) {
882 readSystemProperties();
883 }
884 return sysProps;
885 }
886
887 private void readSystemProperties() {
888 final InstanceKlass systemKls = getSystemDictionary().getSystemKlass();
889 systemKls.iterateStaticFields(new DefaultOopVisitor() {
890 ObjectReader objReader = new ObjectReader();
891 public void doOop(sun.jvm.hotspot.oops.OopField field, boolean isVMField) {
892 if (field.getID().getName().equals("props")) {
893 try {
894 sysProps = (Properties) objReader.readObject(field.getValue(getObj()));
895 } catch (Exception e) {
896 e.printStackTrace();
897 }
898 }
899 }
900 });
901 }
902 }