Interpreter Offsets (was RE: ARM Interpreter)

Thu Aug 13 01:45:59 PDT 2009

Note: I have cross-posted this to zero-dev which is where this discussion
more logically belongs as it is not a packaging issue. I have left
distro-pkg-dev on this post so people can see the discussion is moving to
zero-dev, but please remove distro-pkg-dev from subsequent posts.

>> > So my first question is why is everything conditionalized on
>> > PRODUCT?  Not being able to build not-PRODUCT means no assertions,
>> > no debug helpers and no diagnostic options.  I'd like to see all
>> > these conditionals replaced with "#ifdef HOTSPOT_ASM".
>> 
>> The reason everything is conditionalised on PRODUCT is that the Asm
>> loop will not work with a non product build. This is because all the
>> offsets in the structures change on a non product build because of
>> the addition of debug info into the structures.
>
>That's really likely to break.  Would it be possible to have a table
>of all the constants you use, and fill it in at VM startup?  The C++
>interpreter's init code (bytecodeInterpreter.cpp, around line 560)
>would be a nice place.  I saw you inlined ZeroFrame::SHARK_FRAME too,
>that sort of thing could go there as well.

That would be too expensive in terms of performance. Every time it needed to
access a field it would need to load the offset from a table and then use
that offset in another load. Note that there is a possible 2 cycle load use
penalty between the two loads so this ends up taking 4 cycles instead of 1.

The way to handle this is to write a tool which generates the offsets
(called say 'mkoffsets'). You then in the build do something like

	gcc -o mkoffsets mkoffsets.cpp
	./mkoffsets > offsets.s

And the #include "offsets.s".

As it happens there is an interface in OpenJDK for doing exactly this sort
of thing. It is called VMStructs. I have written a version of mkoffsets.cpp
using VMStructs (see below).

I am not sure of the best way to handle the PRODUCT vs non PRODUCT issue.
There are two possible approaches.

1) The first is to generate both sets of offsets in the build and use #ifdef
PRODUCT to select the correct offsets.

Eg.
	gcc -o mkoffsets mkoffsets.cpp -DPRODUCT
	./mkoffsets > product_offsets.s
	gcc -o mkoffsets mkoffsets.cpp -DDEBUG
	./mkoffsets > debug_offsets.s

Then in the asm loop do

#ifdef PRODUCT
#include "product_offsets.s"
#else
#include "debug_offsets.s"
#endif

2) The 2nd is to ensure that mkoffsets is 'cleaned' for every build so that
if you switch between PRODUCT and non PRODUCT builds the offsets.s file
always gets regenerated.

I am leaning towards the first option as the consequences of the offsets
file not being regenerated correctly are horrible.

Regards,
Ed.

--- mkoffsets.cpp -------------------------------------------------
/*
 * Copyright 2009 Edward Nevill
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 */

#include "incls/_precompiled.incl"

class VMStructs {
public:
	static void print_vm_offsets(void);
};

#define outfile	stdout

void print_def(const char *s, int v)
{
	fprintf(outfile, "#define %-40s 0x%02x\n", s, v);
}

void nl(void)
{
	fputc('\n', outfile);
}

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) + ZeroStack::base_offset());
	print_def("THREAD_JAVA_SP", offset_of(JavaThread, _zero_stack) +
ZeroStack::sp_offset());
	print_def("THREAD_TOP_ZERO_FRAME", offset_of(JavaThread,
_top_zero_frame));
}

int main(void)
{
	print_def("JVM_CONSTANT_Utf8",		JVM_CONSTANT_Utf8);
	print_def("JVM_CONSTANT_Unicode",	JVM_CONSTANT_Unicode);
	print_def("JVM_CONSTANT_Float",		JVM_CONSTANT_Float);
	print_def("JVM_CONSTANT_Long",		JVM_CONSTANT_Long);
	print_def("JVM_CONSTANT_Double",	JVM_CONSTANT_Double);
	print_def("JVM_CONSTANT_Class",		JVM_CONSTANT_Class);
	print_def("JVM_CONSTANT_String",	JVM_CONSTANT_String);
	print_def("JVM_CONSTANT_Fieldref",	JVM_CONSTANT_Fieldref);
	print_def("JVM_CONSTANT_Methodref",	JVM_CONSTANT_Methodref);
	print_def("JVM_CONSTANT_InterfaceMethodref",
JVM_CONSTANT_InterfaceMethodref);
	print_def("JVM_CONSTANT_NameAndType",	JVM_CONSTANT_NameAndType);
	nl();
	print_def("JVM_CONSTANT_UnresolvedClass",
JVM_CONSTANT_UnresolvedClass);
	print_def("JVM_CONSTANT_ClassIndex",
JVM_CONSTANT_ClassIndex);
	print_def("JVM_CONSTANT_UnresolvedString",
JVM_CONSTANT_UnresolvedString);
	print_def("JVM_CONSTANT_StringIndex",
JVM_CONSTANT_StringIndex);

print_def("JVM_CONSTANT_UnresolvedClassInError",JVM_CONSTANT_UnresolvedClass
InError);
	nl();
	print_def("T_BOOLEAN",	T_BOOLEAN);
	print_def("T_CHAR",	T_CHAR);
	print_def("T_FLOAT",	T_FLOAT);
	print_def("T_DOUBLE",	T_DOUBLE);
	print_def("T_BYTE",	T_BYTE);
	print_def("T_SHORT",	T_SHORT);
	print_def("T_INT",	T_INT);
	print_def("T_LONG",	T_LONG);
	print_def("T_OBJECT",	T_OBJECT);
	print_def("T_ARRAY",	T_ARRAY);
	print_def("T_VOID",	T_VOID);
	nl();
	print_def("_thread_uninitialized",	_thread_uninitialized);
	print_def("_thread_new",		_thread_new);
	print_def("_thread_new_trans",		_thread_new_trans);
	print_def("_thread_in_native",		_thread_in_native);
	print_def("_thread_in_native_trans",	_thread_in_native_trans);
	print_def("_thread_in_vm",		_thread_in_vm);
	print_def("_thread_in_vm_trans",	_thread_in_vm_trans);
	print_def("_thread_in_Java",		_thread_in_Java);
	print_def("_thread_in_Java_trans",	_thread_in_Java_trans);
	print_def("_thread_blocked",		_thread_blocked);
	print_def("_thread_blocked_trans",	_thread_blocked_trans);
	print_def("_thread_max_state",		_thread_max_state);
	nl();
	print_def("class_unparsable_by_gc",
instanceKlass::unparsable_by_gc);
	print_def("class_allocated",		instanceKlass::allocated);
	print_def("class_loaded",		instanceKlass::loaded);
	print_def("class_linked",		instanceKlass::linked);
	print_def("class_being_initialized",
instanceKlass::being_initialized);
	print_def("class_fully_initialized",
instanceKlass::fully_initialized);
	print_def("class_init_error",
instanceKlass::initialization_error);
	nl();
	print_def("flag_methodInterface",	1 <<
ConstantPoolCacheEntry::methodInterface);
	print_def("flag_volatileField",		1 <<
ConstantPoolCacheEntry::volatileField);
	print_def("flag_vfinalMethod",		1 <<
ConstantPoolCacheEntry::vfinalMethod);
	print_def("flag_finalField",		1 <<
ConstantPoolCacheEntry::finalField);
	nl();
	VMStructs::print_vm_offsets();
	nl();
	print_def("VMSYMBOLS_ArithmeticException",
vmSymbols::java_lang_ArithmeticException_enum);
	print_def("VMSYMBOLS_ArrayIndexOutOfBounds",
vmSymbols::java_lang_ArrayIndexOutOfBoundsException_enum);
	print_def("VMSYMBOLS_ArrayStoreException",
vmSymbols::java_lang_ArrayStoreException_enum);
	print_def("VMSYMBOLS_ClassCastException",
vmSymbols::java_lang_ClassCastException_enum);
	print_def("VMSYMBOLS_NullPointerException",
vmSymbols::java_lang_NullPointerException_enum);
	print_def("VMSYMBOLS_AbstractMethodError",
vmSymbols::java_lang_AbstractMethodError_enum);
	print_def("VMSYMBOLS_IncompatibleClassChangeError",
vmSymbols::java_lang_IncompatibleClassChangeError_enum);
	print_def("VMSYMBOLS_InternalError",
vmSymbols::java_lang_InternalError_enum);

	return 0;
}