This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
Re: RFC: Tell do_allocate_static_fields which fields to allocate
This is a better patch.
It mimics the technique used when allocating an interpreted class.
It's all rather complicated, but that's hard to avoid as long as we
want to continue to support the "old" BC-ABI.
Andrew.
2006-05-09 Andrew Haley <aph@redhat.com>
* prims.cc (_Jv_soleIndirectCompiledEngine): New.
* include/execution.h (Jv_CompiledEngine::do_allocate_static_fields):
Remove body.
(_Jv_CompiledEngine::allocate_field_initializers): New.
(_Jv_CompiledEngine::_Jv_CompiledEngine): Initialize
allocate_field_initializers.
(class _Jv_IndirectCompiledClass): New.
(struct _Jv_IndirectCompiledEngine): New.
* java/lang/Class.h: (IndirectCompiledEngine): New.
* java/lang/natClassLoader.cc (_Jv_NewClassFromInitializer): Set
engine to _Jv_soleIndirectCompiledEngine
* link.cc (ensure_fields_laid_out): Call
engine->allocate_field_initializers().
Index: link.cc
===================================================================
--- link.cc (revision 113530)
+++ link.cc (working copy)
@@ -1527,6 +1527,8 @@
else
instance_size = java::lang::Object::class$.size();
+ klass->engine->allocate_field_initializers (klass);
+
for (int i = 0; i < klass->field_count; i++)
{
int field_size;
@@ -1539,7 +1541,6 @@
// It is safe to resolve the field here, since it's a
// primitive class, which does not cause loading to happen.
resolve_field (field, klass->loader);
-
field_size = field->type->size ();
field_align = get_alignment_from_class (field->type);
}
Index: java/lang/natClassLoader.cc
===================================================================
--- java/lang/natClassLoader.cc (revision 113530)
+++ java/lang/natClassLoader.cc (working copy)
@@ -200,6 +200,8 @@
&java::lang::Class::class$);
memcpy ((void*)new_class, (void*)class_initializer, sizeof *new_class);
+ new_class->engine = &_Jv_soleIndirectCompiledEngine;
+
if (_Jv_CheckABIVersion ((unsigned long) new_class->next_or_version))
(*_Jv_RegisterClassHook) (new_class);
Index: java/lang/Class.h
===================================================================
--- java/lang/Class.h (revision 113532)
+++ java/lang/Class.h (working copy)
@@ -96,6 +96,7 @@
class _Jv_Linker;
class _Jv_ExecutionEngine;
class _Jv_CompiledEngine;
+class _Jv_IndirectCompiledEngine;
class _Jv_InterpreterEngine;
#ifdef INTERPRETER
@@ -538,6 +539,7 @@
friend class ::_Jv_Linker;
friend class ::_Jv_ExecutionEngine;
friend class ::_Jv_CompiledEngine;
+ friend class ::_Jv_IndirectCompiledEngine;
friend class ::_Jv_InterpreterEngine;
friend void ::_Jv_sharedlib_register_hook (jclass klass);
Index: include/execution.h
===================================================================
--- include/execution.h (revision 113530)
+++ include/execution.h (working copy)
@@ -24,13 +24,15 @@
bool (*need_resolve_string_fields) ();
void (*verify) (jclass);
void (*allocate_static_fields) (jclass, int, int);
+ void (*allocate_field_initializers) (jclass);
void (*create_ncode) (jclass);
_Jv_ResolvedMethod *(*resolve_method) (_Jv_Method *, jclass,
jboolean);
void (*post_miranda_hook) (jclass);
};
-// This handles all gcj-compiled code, including BC ABI.
+// This handles gcj-compiled code except that compiled with
+// -findirect-classes.
struct _Jv_CompiledEngine : public _Jv_ExecutionEngine
{
public:
@@ -55,25 +57,14 @@
return NULL;
}
- static void do_allocate_static_fields (jclass klass,
- int pointer_size,
- int other_size)
+ static void do_allocate_static_fields (jclass,
+ int,
+ int)
{
- // Splitting the allocations here lets us scan reference fields
- // and avoid scanning non-reference fields.
- char *reference_fields = (char *) _Jv_AllocRawObj (pointer_size);
- char *non_reference_fields = (char *) _Jv_AllocBytes (other_size);
-
- for (int i = 0; i < klass->field_count; i++)
- {
- _Jv_Field *field = &klass->fields[i];
-
- if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0)
- continue;
+ }
- char *base = field->isRef() ? reference_fields : non_reference_fields;
- field->u.addr = base + field->u.boffset;
- }
+ static void do_allocate_field_initializers (jclass)
+ {
}
static void do_create_ncode (jclass)
@@ -92,6 +83,7 @@
need_resolve_string_fields = do_need_resolve_string_fields;
verify = do_verify;
allocate_static_fields = do_allocate_static_fields;
+ allocate_field_initializers = do_allocate_field_initializers;
create_ncode = do_create_ncode;
resolve_method = do_resolve_method;
post_miranda_hook = do_post_miranda_hook;
@@ -109,6 +101,81 @@
}
};
+class _Jv_IndirectCompiledClass
+{
+public:
+ void **field_initializers;
+};
+
+// This handles gcj-compiled code compiled with -findirect-classes.
+struct _Jv_IndirectCompiledEngine : public _Jv_CompiledEngine
+{
+ _Jv_IndirectCompiledEngine () : _Jv_CompiledEngine ()
+ {
+ allocate_static_fields = do_allocate_static_fields;
+ allocate_field_initializers = do_allocate_field_initializers;
+ }
+
+ static void do_allocate_field_initializers (jclass klass)
+ {
+ _Jv_IndirectCompiledClass *aux
+ = (_Jv_IndirectCompiledClass*)
+ _Jv_AllocRawObj (sizeof (_Jv_IndirectCompiledClass));
+ klass->aux_info = aux;
+
+ aux->field_initializers = (void **)_Jv_Malloc (klass->field_count
+ * sizeof (void*));
+
+ for (int i = 0; i < klass->field_count; i++)
+ {
+ _Jv_Field *field = &klass->fields[i];
+ if (field->flags & java::lang::reflect::Modifier::STATIC)
+ {
+ aux->field_initializers[i] = field->u.addr;
+ field->u.addr = NULL;
+ }
+ }
+ }
+
+ static void do_allocate_static_fields (jclass klass,
+ int pointer_size,
+ int other_size)
+ {
+ // Splitting the allocations here lets us scan reference fields
+ // and avoid scanning non-reference fields.
+ char *reference_fields = (char *) _Jv_AllocRawObj (pointer_size);
+ char *non_reference_fields = (char *) _Jv_AllocBytes (other_size);
+
+ _Jv_IndirectCompiledClass *aux
+ = (_Jv_IndirectCompiledClass*)klass->aux_info;
+
+ for (int i = 0; i < klass->field_count; i++)
+ {
+ _Jv_Field *field = &klass->fields[i];
+
+ if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0)
+ continue;
+
+ char *base = field->isRef() ? reference_fields : non_reference_fields;
+ field->u.addr = base + field->u.boffset;
+
+ if (aux->field_initializers[i])
+ {
+ int field_size;
+ if (! field->isRef ())
+ field_size = field->type->size ();
+ else
+ field_size = sizeof (jobject);
+
+ memcpy (field->u.addr, aux->field_initializers[i], field_size);
+ }
+ }
+ _Jv_Free (aux->field_initializers);
+ }
+};
+
+
+
// This handles interpreted code.
class _Jv_InterpreterEngine : public _Jv_ExecutionEngine
{
@@ -130,6 +197,10 @@
_Jv_UnregisterClass(klass);
}
+ static void do_allocate_field_initializers (jclass)
+ {
+ }
+
static void do_post_miranda_hook (jclass);
_Jv_InterpreterEngine ()
@@ -138,6 +209,7 @@
need_resolve_string_fields = do_need_resolve_string_fields;
verify = do_verify;
allocate_static_fields = do_allocate_static_fields;
+ allocate_field_initializers = do_allocate_field_initializers;
create_ncode = do_create_ncode;
resolve_method = do_resolve_method;
post_miranda_hook = do_post_miranda_hook;
@@ -158,5 +230,5 @@
extern _Jv_InterpreterEngine _Jv_soleInterpreterEngine;
extern _Jv_CompiledEngine _Jv_soleCompiledEngine;
-
+extern _Jv_IndirectCompiledEngine _Jv_soleIndirectCompiledEngine;
#endif // __JAVA_EXECUTION_H__
Index: prims.cc
===================================================================
--- prims.cc (revision 113532)
+++ prims.cc (working copy)
@@ -74,6 +74,9 @@
// Execution engine for compiled code.
_Jv_CompiledEngine _Jv_soleCompiledEngine;
+// Execution engine for code compiled with -findirect-classes
+_Jv_IndirectCompiledEngine _Jv_soleIndirectCompiledEngine;
+
// We allocate a single OutOfMemoryError exception which we keep
// around for use if we run out of memory.
static java::lang::OutOfMemoryError *no_memory;