diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 8758c7736f79..98d90e6de65b 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,8 @@
+2006-06-16  Andrew Haley  <aph@redhat.com>
+
+	* class.c (make_class_data): When using flag_indirect_classes,
+	don't initialize the vtable of Class instances.
+
 2006-06-09  Andrew Haley  <aph@redhat.com>
 
 	PR java/1305
diff --git a/gcc/java/class.c b/gcc/java/class.c
index 972877d904eb..10992b870a34 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -1863,10 +1863,12 @@ make_class_data (tree type)
 
   START_RECORD_CONSTRUCTOR (temp, object_type_node);
   PUSH_FIELD_VALUE (temp, "vtable",
-		    build2 (PLUS_EXPR, dtable_ptr_type,
-			    build1 (ADDR_EXPR, dtable_ptr_type,
-				    class_dtable_decl),
-			    dtable_start_offset));
+		    (flag_indirect_classes 
+		     ? null_pointer_node
+		     : build2 (PLUS_EXPR, dtable_ptr_type,
+			       build1 (ADDR_EXPR, dtable_ptr_type,
+				       class_dtable_decl),
+			       dtable_start_offset)));
   if (! flag_hash_synchronization)
     PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
   FINISH_RECORD_CONSTRUCTOR (temp);
diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index c1d7d2bf1178..211e3a4e5d92 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,13 @@
+2006-06-16  Andrew Haley  <aph@redhat.com>
+
+	* java/lang/natClassLoader.cc (_Jv_NewClassFromInitializer): Don't
+	copy the whole Class instance from the initializer: instead, copy
+	everything but the first word (the vtable pointer).
+	Change prototype to (const char* class_initializer).
+	(_Jv_RegisterNewClasses): Change prototype to (const char**).
+	* java/lang/Class.h (_Jv_RegisterNewClasses): Change prototype to
+	(const char**).
+
 2006-06-15  Thomas Fitzsimmons  <fitzsim@redhat.com>
 
 	* classpath/Makefile.am: Do not recurse into tools directory.
diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index 0e5066fa9afb..aafd00c23f6c 100644
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -40,8 +40,8 @@ extern "Java"
 // We declare these here to avoid including gcj/cni.h.
 extern "C" void _Jv_InitClass (jclass klass);
 extern "C" jclass _Jv_NewClassFromInitializer 
-   (const jclass class_initializer);
-extern "C" void _Jv_RegisterNewClasses (void **classes);
+   (const char *class_initializer);
+extern "C" void _Jv_RegisterNewClasses (char **classes);
 extern "C" void _Jv_RegisterClasses (const jclass *classes);
 extern "C" void _Jv_RegisterClasses_Counted (const jclass *classes,
 					     size_t count);
@@ -447,7 +447,7 @@ private:
 					       int method_idx);
 
   friend void ::_Jv_InitClass (jclass klass);
-  friend java::lang::Class* ::_Jv_NewClassFromInitializer (const jclass class_initializer);
+  friend java::lang::Class* ::_Jv_NewClassFromInitializer (const char *class_initializer);
   friend void _Jv_RegisterNewClasses (void **classes);
 
   friend _Jv_Method* ::_Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *, 
diff --git a/libjava/java/lang/natClassLoader.cc b/libjava/java/lang/natClassLoader.cc
index 6b3c3ef9cd53..b05c0b1045be 100644
--- a/libjava/java/lang/natClassLoader.cc
+++ b/libjava/java/lang/natClassLoader.cc
@@ -218,11 +218,20 @@ _Jv_RegisterClasses_Counted (const jclass * classes, size_t count)
 
 // Create a class on the heap from an initializer struct.
 jclass
-_Jv_NewClassFromInitializer (const jclass class_initializer)
+_Jv_NewClassFromInitializer (const char *class_initializer)
 {
-  jclass new_class = (jclass)_Jv_AllocObj (sizeof *new_class,
-					   &java::lang::Class::class$);  
-  memcpy ((void*)new_class, (void*)class_initializer, sizeof *new_class);
+  /* We create an instance of java::lang::Class and copy all of its
+     fields except the first word (the vtable pointer) from
+     CLASS_INITIALIZER.  This first word is pre-initialized by
+     _Jv_AllocObj, and we don't want to overwrite it.  */
+
+  jclass new_class
+    = (jclass)_Jv_AllocObj (sizeof (java::lang::Class),
+			    &java::lang::Class::class$);
+  const char *src = class_initializer + sizeof (void*);
+  char *dst = (char*)new_class + sizeof (void*);
+  size_t len = sizeof (*new_class) - sizeof (void*);
+  memcpy (dst, src, len);
 
   new_class->engine = &_Jv_soleIndirectCompiledEngine;
 
@@ -240,13 +249,13 @@ _Jv_NewClassFromInitializer (const jclass class_initializer)
 // heap) and we write the address of the new class into the address
 // pointed to by the second word.
 void
-_Jv_RegisterNewClasses (void **classes)
+_Jv_RegisterNewClasses (char **classes)
 {
   _Jv_InitGC ();
 
-  jclass initializer;
+  const char *initializer;
 
-  while ((initializer = (jclass)*classes++))
+  while ((initializer = *classes++))
     {
       jclass *class_ptr = (jclass *)*classes++;
       *class_ptr = _Jv_NewClassFromInitializer (initializer);