/hg/icedtea6: Added Thumb2 JIT + general tidying up
enevill at icedtea.classpath.org
enevill at icedtea.classpath.org
Thu Jan 21 09:50:32 PST 2010
changeset b227a81ef16c in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=b227a81ef16c
author: Edward Nevill <ed at camswl.com>
date: Thu Jan 21 17:56:18 2010 +0000
Added Thumb2 JIT + general tidying up
diffstat:
5 files changed, 3109 insertions(+), 5677 deletions(-)
ChangeLog | 9
ports/hotspot/make/linux/makefiles/zeroshark.make | 2
ports/hotspot/src/cpu/zero/vm/asm_helper.cpp | 485 +
ports/hotspot/src/cpu/zero/vm/bytecodes_arm.def | 3135 +-----------
ports/hotspot/src/cpu/zero/vm/cppInterpreter_arm.S | 5155 ++++++++------------
diffs (truncated from 10591 to 500 lines):
diff -r 8aa81a796b0b -r b227a81ef16c ChangeLog
--- a/ChangeLog Thu Jan 21 16:20:47 2010 +0100
+++ b/ChangeLog Thu Jan 21 17:56:18 2010 +0000
@@ -1,3 +1,12 @@ 2010-01-21 Matthias Klose <doko at ubuntu
+2010-01-21 Edward Nevill <ed at camswl.com>
+
+ * zeroshark.make, asm_helper.cpp, bytecodes_arm.def,
+ cppInterpreter_arm.S, thumb2.cpp (new file)
+ Added Thumb2 JIT (not build as default - yet)
+ Removal of, more, hard coded constants
+ Move 'complex' bytecodes from cppInterpreter_arm.S to asm_helper.cpp
+ General tidying up of cppInterpreter_arm.S
+
2010-01-21 Matthias Klose <doko at ubuntu.com>
* Makefile.am: Don't hide errors in statement sequences building
diff -r 8aa81a796b0b -r b227a81ef16c ports/hotspot/make/linux/makefiles/zeroshark.make
--- a/ports/hotspot/make/linux/makefiles/zeroshark.make Thu Jan 21 16:20:47 2010 +0100
+++ b/ports/hotspot/make/linux/makefiles/zeroshark.make Thu Jan 21 17:56:18 2010 +0000
@@ -29,6 +29,7 @@ ifeq ($(ZERO_LIBARCH),arm)
Obj_Files += asm_helper.o
Obj_Files += cppInterpreter_arm.o
+Obj_Files += thumb2.o
CFLAGS += -DHOTSPOT_ASM
@@ -38,6 +39,7 @@ CFLAGS += -DHOTSPOT_ASM
$(COMPILE.CC) -o $@ $< $(COMPILE_DONE)
cppInterpreter_arm.o: offsets_arm.s bytecodes_arm.s
+thumb2.o: offsets_arm.s
offsets_arm.s: mkoffsets
@echo Generating assembler offsets
diff -r 8aa81a796b0b -r b227a81ef16c ports/hotspot/src/cpu/zero/vm/asm_helper.cpp
--- a/ports/hotspot/src/cpu/zero/vm/asm_helper.cpp Thu Jan 21 16:20:47 2010 +0100
+++ b/ports/hotspot/src/cpu/zero/vm/asm_helper.cpp Thu Jan 21 17:56:18 2010 +0000
@@ -16,9 +16,59 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include "incls/_precompiled.incl"
+#define ARCH_THUMBEE (1<<16)
+#define ARCH_VFP (1<<17)
+#define ARCH_CLZ (1<<18)
#ifndef STATIC_OFFSETS
+
+#include "incls/_bytecodeInterpreter.cpp.incl"
+
+#include <linux/auxvec.h>
+#include <asm/hwcap.h>
+
+#define VECBUFF_SIZE 64
+
+extern "C" unsigned hwcap(void)
+{
+ int fd;
+ unsigned vecs[VECBUFF_SIZE];
+ unsigned *p;
+ int i, n;
+ unsigned rc = 0;
+ unsigned arch = 4;
+
+ fd = open("/proc/self/auxv", O_RDONLY);
+ if (fd < 0) return 0;
+ do {
+ n = read(fd, vecs, VECBUFF_SIZE * sizeof(unsigned));
+ p = vecs;
+ i = n/8;
+ while (--i >= 0) {
+ unsigned tag = *p++;
+ unsigned value = *p++;
+ if (tag == 0) goto fini;
+ if (tag == AT_HWCAP) {
+ if (value & HWCAP_THUMBEE) rc |= ARCH_THUMBEE;
+ if (value & HWCAP_VFP) rc |= ARCH_VFP;
+ } else if (tag == AT_PLATFORM) {
+ const char *s = (const char *)value;
+ int c;
+
+ if (*s++ == 'v') {
+ arch = 0;
+ while ((isdigit)(c = *s++)) arch = arch * 10 + c - '0';
+ }
+ }
+ }
+ } while (n == VECBUFF_SIZE * sizeof(unsigned));
+fini:
+ close(fd);
+// printf("arch = %d, rc = 0x%08x\n", arch, rc);
+ if (arch >= 5) rc |= ARCH_CLZ;
+ if (arch >= 7) rc |= ARCH_THUMBEE;
+ return rc | (1<<arch);
+}
/* Thease functions allow the ASM interpreter to call CPP virtual functions.
* Otherwise the ASM interpreter has to grup around in the VTABLE which is
@@ -44,9 +94,261 @@ extern "C" char *SharedRuntime_generate_
return SharedRuntime::generate_class_cast_message(name, klass);
}
+#define HELPER_THROW(thread, name, msg) Exceptions::_throw_msg(thread, __FILE__, __LINE__, name, msg)
+
+class VMStructs {
+public:
+ static inline klassOop klass_at_addr(constantPoolOop constants, u2 index) {
+ return (klassOop) *constants->obj_at_addr(index);
+ }
+};
+
+extern "C" oop Helper_new(interpreterState istate, unsigned index)
+{
+ JavaThread *thread = istate->thread();
+
+ constantPoolOop constants = istate->method()->constants();
+ oop result = NULL;
+ if (!constants->tag_at(index).is_unresolved_klass()) {
+ // Make sure klass is initialized and doesn't have a finalizer
+ oop entry = VMStructs::klass_at_addr(constants, index);
+ klassOop k_entry = (klassOop) entry;
+ instanceKlass* ik = (instanceKlass*) k_entry->klass_part();
+ if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {
+ size_t obj_size = ik->size_helper();
+ // If the TLAB isn't pre-zeroed then we'll have to do it
+ bool need_zero = !ZeroTLAB;
+ if (UseTLAB) {
+ result = (oop) thread->tlab().allocate(obj_size);
+ }
+ if (result == NULL) {
+ need_zero = true;
+ // Try allocate in shared eden
+ retry:
+ HeapWord* compare_to = *Universe::heap()->top_addr();
+ HeapWord* new_top = compare_to + obj_size;
+ if (new_top <= *Universe::heap()->end_addr()) {
+ if (Atomic::cmpxchg_ptr(new_top, Universe::heap()->top_addr(), compare_to) != compare_to) {
+ goto retry;
+ }
+ result = (oop) compare_to;
+ }
+ }
+ if (result != NULL) {
+ // Initialize object (if nonzero size and need) and then the header
+ if (need_zero ) {
+ HeapWord* to_zero = (HeapWord*) result + sizeof(oopDesc) / oopSize;
+ obj_size -= sizeof(oopDesc) / oopSize;
+ if (obj_size > 0 ) {
+ memset(to_zero, 0, obj_size * HeapWordSize);
+ }
+ }
+ if (UseBiasedLocking) {
+ result->set_mark(ik->prototype_header());
+ } else {
+ result->set_mark(markOopDesc::prototype());
+ }
+ result->set_klass_gap(0);
+ result->set_klass(k_entry);
+ return result;
+ }
+ }
+ }
+ // Slow case allocation
+ InterpreterRuntime::_new(thread, istate->method()->constants(), index);
+ result = thread->vm_result();
+ thread->set_vm_result(NULL);
+ return result;
+}
+
+extern "C" int Helper_instanceof(interpreterState istate, unsigned index, oop tos)
+{
+ if (tos == NULL) return 0;
+
+ // Constant pool may have actual klass or unresolved klass. If it is
+ // unresolved we must resolve it
+ if (istate->method()->constants()->tag_at(index).is_unresolved_klass()) {
+ InterpreterRuntime::quicken_io_cc(istate->thread());
+ if (istate->thread()->has_pending_exception()) return 0;
+ }
+ klassOop klassOf = VMStructs::klass_at_addr(istate->method()->constants(), index);
+ klassOop objKlassOop = tos->klass();
+ //
+ // Check for compatibilty. This check must not GC!!
+ // Seems way more expensive now that we must dispatch
+ //
+ return objKlassOop == klassOf || objKlassOop->klass_part()->is_subtype_of(klassOf);
+}
+
+extern "C" oop Helper_checkcast(interpreterState istate, unsigned index, oop tos)
+{
+ if (tos == NULL) return NULL;
+
+ // Constant pool may have actual klass or unresolved klass. If it is
+ // unresolved we must resolve it
+ if (istate->method()->constants()->tag_at(index).is_unresolved_klass()) {
+ oop except_oop;
+ InterpreterRuntime::quicken_io_cc(istate->thread());
+ if (except_oop = istate->thread()->pending_exception()) return except_oop;
+ }
+ klassOop klassOf = VMStructs::klass_at_addr(istate->method()->constants(), index);
+ klassOop objKlassOop = tos->klass(); //ebx
+ //
+ // Check for compatibilty. This check must not GC!!
+ // Seems way more expensive now that we must dispatch
+ //
+ if (objKlassOop != klassOf && !objKlassOop->klass_part()->is_subtype_of(klassOf)) {
+ ResourceMark rm(istate->thread());
+ const char* objName = Klass::cast(objKlassOop)->external_name();
+ const char* klassName = Klass::cast(klassOf)->external_name();
+ char* message = SharedRuntime::generate_class_cast_message(objName, klassName);
+ ThreadInVMfromJava trans(istate->thread());
+ HELPER_THROW(istate->thread(), vmSymbols::java_lang_ClassCastException(), message);
+ }
+ return istate->thread()->pending_exception();
+}
+
+extern "C" oop Helper_aastore(interpreterState istate, oop value, int index, arrayOop arrayref)
+{
+ if (arrayref == NULL) {
+ ThreadInVMfromJava trans(istate->thread());
+ HELPER_THROW(istate->thread(), vmSymbols::java_lang_NullPointerException(), "");
+ } else if ((uint32_t)index >= (uint32_t)arrayref->length()) {
+ char message[jintAsStringSize];
+ sprintf(message, "%d", index);
+ HELPER_THROW(istate->thread(), vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message);
+ } else {
+ if (value != NULL) {
+ /* Check assignability of value into arrayref */
+ klassOop rhsKlassOop = value->klass(); // EBX (subclass)
+ klassOop elemKlassOop = ((objArrayKlass*) arrayref->klass()->klass_part())->element_klass();
+ //
+ // Check for compatibilty. This check must not GC!!
+ // Seems way more expensive now that we must dispatch
+ //
+ if (rhsKlassOop != elemKlassOop && !rhsKlassOop->klass_part()->is_subtype_of(elemKlassOop)) {
+ HELPER_THROW(istate->thread(), vmSymbols::java_lang_ArrayStoreException(), "");
+ goto handle_exception;
+ }
+ }
+ oop* elem_loc = (oop*)(((address) arrayref->base(T_OBJECT)) + index * sizeof(oop));
+ // *(oop*)(((address) arrayref->base(T_OBJECT)) + index * sizeof(oop)) = value;
+ *elem_loc = value;
+ // Mark the card
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ static volatile jbyte* _byte_map_base = (volatile jbyte*)(((CardTableModRefBS*)bs)->byte_map_base);
+ OrderAccess::release_store(&_byte_map_base[(uintptr_t)elem_loc >> CardTableModRefBS::card_shift], 0);
+ }
+handle_exception:
+ return istate->thread()->pending_exception();
+}
+
+extern "C" void Helper_aputfield(oop obj)
+{
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ static volatile jbyte* _byte_map_base = (volatile jbyte*)(((CardTableModRefBS*)bs)->byte_map_base);
+ OrderAccess::release_store(&_byte_map_base[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
+}
+
+extern "C" oop Helper_synchronized_enter(JavaThread *thread, BasicObjectLock *mon)
+{
+ BasicLock *lock = mon->lock();
+ markOop displaced = lock->displaced_header();
+
+ if (thread->is_lock_owned((address)displaced->clear_lock_bits()))
+ lock->set_displaced_header(NULL);
+ else
+ InterpreterRuntime::monitorenter(thread, mon);
+ return thread->pending_exception();
+}
+
+extern "C" oop Helper_synchronized_exit(JavaThread *thread, BasicObjectLock *mon)
+{
+ {
+ HandleMark __hm(thread);
+ if (mon->obj() == NULL)
+ InterpreterRuntime::throw_illegal_monitor_state_exception(thread);
+ else
+ InterpreterRuntime::monitorexit(thread, mon);
+ }
+ return thread->pending_exception();
+}
+
+extern "C" oop Helper_SafePoint(JavaThread *thread)
+{
+ {
+ HandleMarkCleaner __hmc(thread);
+ }
+ SafepointSynchronize::block(thread);
+ return thread->pending_exception();
+}
+
+extern "C" void Helper_RaiseArrayBoundException(JavaThread *thread, int index)
+{
+ char message[jintAsStringSize];
+ sprintf(message, "%d", index);
+ {
+ ThreadInVMfromJava trans(thread);
+ Exceptions::_throw_msg(thread, "[Bytecoce Interpreter]", 99,
+ vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), message);
+ }
+}
+
+extern "C" void Helper_Raise(JavaThread *thread, symbolOopDesc *name, char const *msg)
+{
+ ThreadInVMfromJava trans(thread);
+ Exceptions::_throw_msg(thread, "[Bytecoce Interpreter]", 99, name, msg);
+}
+
+extern "C" void Helper_RaiseIllegalMonitorException(JavaThread *thread)
+{
+ HandleMark __hm(thread);
+ InterpreterRuntime::throw_illegal_monitor_state_exception(thread);
+}
+
+extern "C" address Helper_HandleException(interpreterState istate, JavaThread *thread)
+{
+ HandleMarkCleaner __hmc(thread);
+ Handle except_oop(thread, thread->pending_exception());
+ HandleMark __hm(thread);
+ intptr_t continuation_bci;
+ intptr_t *topOfStack;
+ address pc;
+
+ thread->clear_pending_exception();
+ continuation_bci = (intptr_t)InterpreterRuntime::exception_handler_for_exception(thread, except_oop());
+ except_oop = (oop) thread->vm_result();
+ thread->set_vm_result(NULL);
+ if (continuation_bci >= 0) {
+ topOfStack = (intptr_t *)istate->stack();
+ *topOfStack-- = (intptr_t)except_oop();
+ istate->set_stack(topOfStack);
+ pc = istate->method()->code_base() + continuation_bci;
+#if 0
+ tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", Klass::cast(except_oop->klass())->external_name(), except_oop());
+ tty->print_cr(" thrown in interpreter method <%s>", istate->method()->name_and_sig_as_C_string());
+ tty->print_cr(" at bci %d, continuing at %d for thread " INTPTR_FORMAT,
+ pc - (intptr_t)istate->method()->code_base(),
+ continuation_bci, thread);
+#endif
+ return pc;
+ }
+#if 0
+ tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", Klass::cast(except_oop->klass())->external_name(), except_oop());
+ tty->print_cr(" thrown in interpreter method <%s>", istate->method()->name_and_sig_as_C_string());
+ tty->print_cr(" at bci %d, unwinding for thread " INTPTR_FORMAT,
+ pc - (intptr_t) istate->method()->code_base(),
+ thread);
+#endif
+ thread->set_pending_exception(except_oop(), NULL, 0);
+ return 0;
+}
+
#endif // STATIC_OFFSETS
#ifdef STATIC_OFFSETS
+
+#include "incls/_precompiled.incl"
class VMStructs {
public:
@@ -57,6 +359,7 @@ public:
void print_def(const char *s, int v)
{
+ fprintf(outfile, "#undef %-40s\n", s);
fprintf(outfile, "#define %-40s 0x%02x\n", s, v);
}
@@ -65,80 +368,115 @@ void nl(void)
fputc('\n', outfile);
}
+// ZeroFrame is not friends with VMStructs, but it is with ZeroStackPrinter
+class ZeroStackPrinter {
+public:
+ static void print_vm_offsets(void);
+};
+
+void ZeroStackPrinter::print_vm_offsets(void)
+{
+ print_def("INTERPRETER_FRAME", ZeroFrame::INTERPRETER_FRAME);
+}
+
void VMStructs::print_vm_offsets(void)
{
- print_def("THREAD_PENDING_EXC", offset_of(JavaThread, _pending_exception));
- print_def("THREAD_SUSPEND_FLAGS", offset_of(JavaThread, _suspend_flags));
- print_def("THREAD_ACTIVE_HANDLES", offset_of(JavaThread, _active_handles));
- print_def("THREAD_LAST_HANDLE_MARK", offset_of(JavaThread, _last_handle_mark));
- print_def("THREAD_TLAB_TOP", offset_of(JavaThread, _tlab) + offset_of(ThreadLocalAllocBuffer, _top));
- print_def("THREAD_TLAB_END", offset_of(JavaThread, _tlab) + offset_of(ThreadLocalAllocBuffer, _end));
- print_def("THREAD_RESOURCEAREA", offset_of(JavaThread, _resource_area));
- print_def("THREAD_HANDLE_AREA", offset_of(JavaThread, _handle_area));
- print_def("THREAD_STACK_BASE", offset_of(JavaThread, _stack_base));
- print_def("THREAD_STACK_SIZE", offset_of(JavaThread, _stack_size));
- print_def("THREAD_LAST_JAVA_SP", offset_of(JavaThread, _anchor) + offset_of(JavaFrameAnchor, _last_Java_sp));
- print_def("THREAD_JNI_ENVIRONMENT", offset_of(JavaThread, _jni_environment));
- print_def("THREAD_VM_RESULT", offset_of(JavaThread, _vm_result));
- print_def("THREAD_STATE", offset_of(JavaThread, _thread_state));
- print_def("THREAD_DO_NOT_UNLOCK", offset_of(JavaThread, _do_not_unlock_if_synchronized));
-
- print_def("THREAD_JAVA_STACK_BASE", offset_of(JavaThread, _zero_stack) + in_bytes(ZeroStack::base_offset()));
- print_def("THREAD_JAVA_SP", offset_of(JavaThread, _zero_stack) + in_bytes(ZeroStack::sp_offset()));
- print_def("THREAD_TOP_ZERO_FRAME", offset_of(JavaThread, _top_zero_frame));
- print_def("THREAD_SPECIALRUNTIMEEXITCONDITION", offset_of(JavaThread, _special_runtime_exit_condition));
- nl();
- print_def("_thread_external_suspend", Thread::_external_suspend);
- print_def("_thread_ext_suspended", Thread::_ext_suspended);
- print_def("_thread_deopt_suspend", Thread::_deopt_suspend);
- nl();
- print_def("METHOD_CONSTMETHOD", offset_of(methodOopDesc, _constMethod));
- print_def("METHOD_CONSTANTS", offset_of(methodOopDesc, _constants));
- print_def("METHOD_METHODDATA", offset_of(methodOopDesc, _method_data));
- print_def("METHOD_INVOKECOUNT", offset_of(methodOopDesc, _interpreter_invocation_count));
- print_def("METHOD_ACCESSFLAGS", offset_of(methodOopDesc, _access_flags));
- print_def("METHOD_VTABLEINDEX", offset_of(methodOopDesc, _vtable_index));
- print_def("METHOD_RESULTINDEX", offset_of(methodOopDesc, _result_index));
- print_def("METHOD_METHODSIZE", offset_of(methodOopDesc, _method_size));
- print_def("METHOD_MAXSTACK", offset_of(methodOopDesc, _max_stack));
- print_def("METHOD_MAXLOCALS", offset_of(methodOopDesc, _max_locals));
- print_def("METHOD_SIZEOFPARAMETERS", offset_of(methodOopDesc, _size_of_parameters));
- print_def("METHOD_INVOCATIONCOUNTER", offset_of(methodOopDesc, _invocation_counter));
- print_def("METHOD_BACKEDGECOUNTER", offset_of(methodOopDesc, _backedge_counter));
- print_def("METHOD_FROM_INTERPRETED", offset_of(methodOopDesc, _from_interpreted_entry));
- // ECN: These two appear to be just tagged onto the end of the class
- print_def("METHOD_NATIVEHANDLER", sizeof(methodOopDesc));
- print_def("METHOD_SIGNATUREHANDLER", sizeof(methodOopDesc)+4);
- nl();
- print_def("CONSTMETHOD_CODESIZE", offset_of(constMethodOopDesc, _code_size));
- print_def("CONSTMETHOD_CODEOFFSET", sizeof(constMethodOopDesc));
- nl();
- print_def("JNIHANDLEBLOCK_TOP", offset_of(JNIHandleBlock, _top));
- nl();
- print_def("KLASS_PART", klassOopDesc::klass_part_offset_in_bytes());
- print_def("KLASS_ACCESSFLAGS", offset_of(Klass, _access_flags));
- print_def("INSTANCEKLASS_INITSTATE", offset_of(instanceKlass, _init_state));
- print_def("INSTANCEKLASS_VTABLE_LEN", offset_of(instanceKlass, _vtable_len));
- print_def("INSTANCEKLASS_ITABLE_LEN", offset_of(instanceKlass, _itable_len));
- print_def("INSTANCEKLASS_VTABLE_OFFSET", instanceKlass::vtable_start_offset() * sizeof(int *));
- print_def("OBJARRAYKLASS_ELEMENTKLASS", offset_of(objArrayKlass, _element_klass));
- nl();
- print_def("CONSTANTPOOL_TAGS", offset_of(constantPoolOopDesc, _tags));
- print_def("CONSTANTPOOL_CACHE", offset_of(constantPoolOopDesc, _cache));
- print_def("CONSTANTPOOL_BASE", sizeof(constantPoolOopDesc));
- nl();
- print_def("CP_OFFSET", in_bytes(constantPoolCacheOopDesc::base_offset()));
- nl();
- print_def("BASE_OFFSET_BYTE", arrayOopDesc::base_offset_in_bytes(T_BYTE));
- print_def("BASE_OFFSET_SHORT", arrayOopDesc::base_offset_in_bytes(T_SHORT));
- print_def("BASE_OFFSET_WORD", arrayOopDesc::base_offset_in_bytes(T_INT));
- print_def("BASE_OFFSET_LONG", arrayOopDesc::base_offset_in_bytes(T_LONG));
- nl();
- print_def("SIZEOF_HANDLEMARK", sizeof(HandleMark));
+ print_def("ISTATE_THREAD", offset_of(BytecodeInterpreter, _thread));
+ print_def("ISTATE_BCP", offset_of(BytecodeInterpreter, _bcp));
+ print_def("ISTATE_LOCALS", offset_of(BytecodeInterpreter, _locals));
+ print_def("ISTATE_CONSTANTS", offset_of(BytecodeInterpreter, _constants));
+ print_def("ISTATE_METHOD", offset_of(BytecodeInterpreter, _method));
+ print_def("ISTATE_STACK", offset_of(BytecodeInterpreter, _stack));
+ print_def("ISTATE_MSG", offset_of(BytecodeInterpreter, _msg));
+ print_def("ISTATE_OOP_TEMP", offset_of(BytecodeInterpreter, _oop_temp));
+ print_def("ISTATE_STACK_BASE",offset_of(BytecodeInterpreter, _stack_base));
+ print_def("ISTATE_STACK_LIMIT",offset_of(BytecodeInterpreter, _stack_limit));
+ print_def("ISTATE_MONITOR_BASE",offset_of(BytecodeInterpreter, _monitor_base));
+ print_def("ISTATE_SELF_LINK", offset_of(BytecodeInterpreter, _self_link));
+ print_def("ISTATE_FRAME_TYPE", sizeof(BytecodeInterpreter) + 0);
+ print_def("ISTATE_NEXT_FRAME", sizeof(BytecodeInterpreter) + 4);
+ print_def("FRAME_SIZE", sizeof(BytecodeInterpreter) + 8);
+ nl();
+ ZeroStackPrinter::print_vm_offsets();
+ nl();
+ print_def("THREAD_PENDING_EXC", offset_of(JavaThread, _pending_exception));
+ print_def("THREAD_SUSPEND_FLAGS", offset_of(JavaThread, _suspend_flags));
+ print_def("THREAD_ACTIVE_HANDLES", offset_of(JavaThread, _active_handles));
+ print_def("THREAD_LAST_HANDLE_MARK", offset_of(JavaThread, _last_handle_mark));
+ print_def("THREAD_TLAB_TOP", offset_of(JavaThread, _tlab) + offset_of(ThreadLocalAllocBuffer, _top));
+ print_def("THREAD_TLAB_END", offset_of(JavaThread, _tlab) + offset_of(ThreadLocalAllocBuffer, _end));
+ print_def("THREAD_RESOURCEAREA", offset_of(JavaThread, _resource_area));
+ print_def("THREAD_HANDLE_AREA", offset_of(JavaThread, _handle_area));
+ print_def("THREAD_STACK_BASE", offset_of(JavaThread, _stack_base));
+ print_def("THREAD_STACK_SIZE", offset_of(JavaThread, _stack_size));
+ print_def("THREAD_LAST_JAVA_SP", offset_of(JavaThread, _anchor) + offset_of(JavaFrameAnchor, _last_Java_sp));
+ print_def("THREAD_JNI_ENVIRONMENT", offset_of(JavaThread, _jni_environment));
+ print_def("THREAD_VM_RESULT", offset_of(JavaThread, _vm_result));
+ print_def("THREAD_STATE", offset_of(JavaThread, _thread_state));
+ print_def("THREAD_DO_NOT_UNLOCK", offset_of(JavaThread, _do_not_unlock_if_synchronized));
+
+ print_def("THREAD_JAVA_STACK_BASE", offset_of(JavaThread, _zero_stack) + in_bytes(ZeroStack::base_offset()));
+ print_def("THREAD_JAVA_SP", offset_of(JavaThread, _zero_stack) + in_bytes(ZeroStack::sp_offset()));
+ print_def("THREAD_TOP_ZERO_FRAME", offset_of(JavaThread, _top_zero_frame));
+ print_def("THREAD_SPECIALRUNTIMEEXITCONDITION", offset_of(JavaThread, _special_runtime_exit_condition));
+ nl();
+ print_def("_thread_external_suspend", Thread::_external_suspend);
+ print_def("_thread_ext_suspended", Thread::_ext_suspended);
+ print_def("_thread_deopt_suspend", Thread::_deopt_suspend);
+ nl();
+ print_def("METHOD_CONSTMETHOD", offset_of(methodOopDesc, _constMethod));
+ print_def("METHOD_CONSTANTS", offset_of(methodOopDesc, _constants));
+ print_def("METHOD_METHODDATA", offset_of(methodOopDesc, _method_data));
More information about the distro-pkg-dev
mailing list