38 Java frame pointer) which need to be factored out. These
39 operations are implemented by, for example,
40 SolarisSPARCJavaThread, and the concrete subclasses are
41 instantiated by the JavaThreadFactory in the Threads class. */
42
43 public class JavaThread extends Thread {
44 private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.JavaThread.DEBUG") != null;
45
46 private static long threadObjFieldOffset;
47 private static long lockStackTopOffset;
48 private static long lockStackBaseOffset;
49 private static AddressField anchorField;
50 private static AddressField lastJavaSPField;
51 private static AddressField lastJavaPCField;
52 private static CIntegerField threadStateField;
53 private static AddressField osThreadField;
54 private static AddressField stackBaseField;
55 private static CIntegerField stackSizeField;
56 private static CIntegerField terminatedField;
57 private static AddressField activeHandlesField;
58 private static long oopPtrSize;
59
60 private static JavaThreadPDAccess access;
61
62 // JavaThreadStates read from underlying process
63 private static int UNINITIALIZED;
64 private static int NEW;
65 private static int NEW_TRANS;
66 private static int IN_NATIVE;
67 private static int IN_NATIVE_TRANS;
68 private static int IN_VM;
69 private static int IN_VM_TRANS;
70 private static int IN_JAVA;
71 private static int IN_JAVA_TRANS;
72 private static int BLOCKED;
73 private static int BLOCKED_TRANS;
74
75 private static int NOT_TERMINATED;
76 private static int EXITING;
77
84 }
85 });
86 }
87
88 private static synchronized void initialize(TypeDataBase db) {
89 Type type = db.lookupType("JavaThread");
90 Type anchorType = db.lookupType("JavaFrameAnchor");
91 Type typeLockStack = db.lookupType("LockStack");
92
93 threadObjFieldOffset = type.getField("_threadObj").getOffset();
94
95 anchorField = type.getAddressField("_anchor");
96 lastJavaSPField = anchorType.getAddressField("_last_Java_sp");
97 lastJavaPCField = anchorType.getAddressField("_last_Java_pc");
98 threadStateField = type.getCIntegerField("_thread_state");
99 osThreadField = type.getAddressField("_osthread");
100 stackBaseField = type.getAddressField("_stack_base");
101 stackSizeField = type.getCIntegerField("_stack_size");
102 terminatedField = type.getCIntegerField("_terminated");
103 activeHandlesField = type.getAddressField("_active_handles");
104
105 lockStackTopOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_top").getOffset();
106 lockStackBaseOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_base[0]").getOffset();
107 oopPtrSize = VM.getVM().getAddressSize();
108
109 UNINITIALIZED = db.lookupIntConstant("_thread_uninitialized").intValue();
110 NEW = db.lookupIntConstant("_thread_new").intValue();
111 NEW_TRANS = db.lookupIntConstant("_thread_new_trans").intValue();
112 IN_NATIVE = db.lookupIntConstant("_thread_in_native").intValue();
113 IN_NATIVE_TRANS = db.lookupIntConstant("_thread_in_native_trans").intValue();
114 IN_VM = db.lookupIntConstant("_thread_in_vm").intValue();
115 IN_VM_TRANS = db.lookupIntConstant("_thread_in_vm_trans").intValue();
116 IN_JAVA = db.lookupIntConstant("_thread_in_Java").intValue();
117 IN_JAVA_TRANS = db.lookupIntConstant("_thread_in_Java_trans").intValue();
118 BLOCKED = db.lookupIntConstant("_thread_blocked").intValue();
119 BLOCKED_TRANS = db.lookupIntConstant("_thread_blocked_trans").intValue();
120
121 NOT_TERMINATED = db.lookupIntConstant("JavaThread::_not_terminated").intValue();
122 EXITING = db.lookupIntConstant("JavaThread::_thread_exiting").intValue();
123
359 Oop obj = null;
360 try {
361 Address addr = getAddress().addOffsetTo(threadObjFieldOffset);
362 VMOopHandle vmOopHandle = VMObjectFactory.newObject(VMOopHandle.class, addr);
363 obj = vmOopHandle.resolve();
364 } catch (Exception e) {
365 System.out.println("WARNING: could not get Thread object: " + e);
366 }
367 return obj;
368 }
369
370 /** Get the Java-side name of this thread */
371 public String getThreadName() {
372 Oop threadObj = getThreadObj();
373 if (threadObj == null) {
374 return "<null>";
375 }
376 return OopUtilities.threadOopGetName(threadObj);
377 }
378
379 //
380 // Oop traversal
381 //
382
383 public void oopsDo(AddressVisitor oopVisitor) {
384 super.oopsDo(oopVisitor);
385
386 // FIXME: add in the rest of the routine from the VM
387
388 // Traverse the execution stack
389 for(StackFrameStream fst = new StackFrameStream(this); !fst.isDone(); fst.next()) {
390 fst.getCurrent().oopsDo(oopVisitor, fst.getRegisterMap());
391 }
392 }
393
394 public boolean isInStack(Address a) {
395 if (Assert.ASSERTS_ENABLED) {
396 Assert.that(VM.getVM().isDebugging(), "Not yet implemented for non-debugging system");
397 }
398 Address sp = lastSPDbg();
|
38 Java frame pointer) which need to be factored out. These
39 operations are implemented by, for example,
40 SolarisSPARCJavaThread, and the concrete subclasses are
41 instantiated by the JavaThreadFactory in the Threads class. */
42
43 public class JavaThread extends Thread {
44 private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.JavaThread.DEBUG") != null;
45
46 private static long threadObjFieldOffset;
47 private static long lockStackTopOffset;
48 private static long lockStackBaseOffset;
49 private static AddressField anchorField;
50 private static AddressField lastJavaSPField;
51 private static AddressField lastJavaPCField;
52 private static CIntegerField threadStateField;
53 private static AddressField osThreadField;
54 private static AddressField stackBaseField;
55 private static CIntegerField stackSizeField;
56 private static CIntegerField terminatedField;
57 private static AddressField activeHandlesField;
58 private static CIntegerField lockIdField;
59 private static long oopPtrSize;
60
61 private static JavaThreadPDAccess access;
62
63 // JavaThreadStates read from underlying process
64 private static int UNINITIALIZED;
65 private static int NEW;
66 private static int NEW_TRANS;
67 private static int IN_NATIVE;
68 private static int IN_NATIVE_TRANS;
69 private static int IN_VM;
70 private static int IN_VM_TRANS;
71 private static int IN_JAVA;
72 private static int IN_JAVA_TRANS;
73 private static int BLOCKED;
74 private static int BLOCKED_TRANS;
75
76 private static int NOT_TERMINATED;
77 private static int EXITING;
78
85 }
86 });
87 }
88
89 private static synchronized void initialize(TypeDataBase db) {
90 Type type = db.lookupType("JavaThread");
91 Type anchorType = db.lookupType("JavaFrameAnchor");
92 Type typeLockStack = db.lookupType("LockStack");
93
94 threadObjFieldOffset = type.getField("_threadObj").getOffset();
95
96 anchorField = type.getAddressField("_anchor");
97 lastJavaSPField = anchorType.getAddressField("_last_Java_sp");
98 lastJavaPCField = anchorType.getAddressField("_last_Java_pc");
99 threadStateField = type.getCIntegerField("_thread_state");
100 osThreadField = type.getAddressField("_osthread");
101 stackBaseField = type.getAddressField("_stack_base");
102 stackSizeField = type.getCIntegerField("_stack_size");
103 terminatedField = type.getCIntegerField("_terminated");
104 activeHandlesField = type.getAddressField("_active_handles");
105 lockIdField = type.getCIntegerField("_lock_id");
106
107 lockStackTopOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_top").getOffset();
108 lockStackBaseOffset = type.getField("_lock_stack").getOffset() + typeLockStack.getField("_base[0]").getOffset();
109 oopPtrSize = VM.getVM().getAddressSize();
110
111 UNINITIALIZED = db.lookupIntConstant("_thread_uninitialized").intValue();
112 NEW = db.lookupIntConstant("_thread_new").intValue();
113 NEW_TRANS = db.lookupIntConstant("_thread_new_trans").intValue();
114 IN_NATIVE = db.lookupIntConstant("_thread_in_native").intValue();
115 IN_NATIVE_TRANS = db.lookupIntConstant("_thread_in_native_trans").intValue();
116 IN_VM = db.lookupIntConstant("_thread_in_vm").intValue();
117 IN_VM_TRANS = db.lookupIntConstant("_thread_in_vm_trans").intValue();
118 IN_JAVA = db.lookupIntConstant("_thread_in_Java").intValue();
119 IN_JAVA_TRANS = db.lookupIntConstant("_thread_in_Java_trans").intValue();
120 BLOCKED = db.lookupIntConstant("_thread_blocked").intValue();
121 BLOCKED_TRANS = db.lookupIntConstant("_thread_blocked_trans").intValue();
122
123 NOT_TERMINATED = db.lookupIntConstant("JavaThread::_not_terminated").intValue();
124 EXITING = db.lookupIntConstant("JavaThread::_thread_exiting").intValue();
125
361 Oop obj = null;
362 try {
363 Address addr = getAddress().addOffsetTo(threadObjFieldOffset);
364 VMOopHandle vmOopHandle = VMObjectFactory.newObject(VMOopHandle.class, addr);
365 obj = vmOopHandle.resolve();
366 } catch (Exception e) {
367 System.out.println("WARNING: could not get Thread object: " + e);
368 }
369 return obj;
370 }
371
372 /** Get the Java-side name of this thread */
373 public String getThreadName() {
374 Oop threadObj = getThreadObj();
375 if (threadObj == null) {
376 return "<null>";
377 }
378 return OopUtilities.threadOopGetName(threadObj);
379 }
380
381 public Address getLockId() {
382 return lockIdField.getAddress(addr);
383 }
384
385 //
386 // Oop traversal
387 //
388
389 public void oopsDo(AddressVisitor oopVisitor) {
390 super.oopsDo(oopVisitor);
391
392 // FIXME: add in the rest of the routine from the VM
393
394 // Traverse the execution stack
395 for(StackFrameStream fst = new StackFrameStream(this); !fst.isDone(); fst.next()) {
396 fst.getCurrent().oopsDo(oopVisitor, fst.getRegisterMap());
397 }
398 }
399
400 public boolean isInStack(Address a) {
401 if (Assert.ASSERTS_ENABLED) {
402 Assert.that(VM.getVM().isDebugging(), "Not yet implemented for non-debugging system");
403 }
404 Address sp = lastSPDbg();
|