Merged gcj-eclipse branch to trunk.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@120621 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 395 insertions, 98 deletions

diff --git a/libjava/defineclass.cc b/libjava/defineclass.cc
index 03d73a2c266..12c6032862d 100644
--- a/libjava/defineclass.cc
+++ b/libjava/defineclass.cc
@@ -39,7 +39,11 @@ details.  */
 #include <java/lang/ClassCircularityError.h>
 #include <java/lang/IncompatibleClassChangeError.h>
 #include <java/lang/reflect/Modifier.h>
+#include <java/lang/reflect/Field.h>
+#include <java/lang/reflect/Method.h>
 #include <java/security/ProtectionDomain.h>
+#include <java/io/DataOutputStream.h>
+#include <java/io/ByteArrayOutputStream.h>
 
 using namespace gcj;
 
@@ -87,6 +91,10 @@ struct _Jv_ClassReader
 
   bool verify;
 
+  // original input data.
+  jbyteArray input_data;
+  jint input_offset;
+
   // input data.
   unsigned char     *bytes;
   int                len;
@@ -111,6 +119,10 @@ struct _Jv_ClassReader
   // True if this is a 1.5 class file.
   bool             is_15;
 
+  // Buffer holding extra reflection data.
+  ::java::io::ByteArrayOutputStream *reflection_data;
+  ::java::io::DataOutputStream *data_stream;
+
 
   /* check that the given number of input bytes are available */
   inline void check (int num)
@@ -126,7 +138,7 @@ struct _Jv_ClassReader
     pos += num;
   }
   
-  /* read an unsignend 1-byte unit */
+  /* read an unsigned 1-byte unit */
   inline static jint get1u (unsigned char* bytes)
   {
     return bytes[0];
@@ -226,6 +238,16 @@ struct _Jv_ClassReader
       throw_class_format_error ("erroneous type descriptor");
   }
 
+  ::java::io::DataOutputStream *get_reflection_stream ()
+  {
+    if (reflection_data == NULL)
+      {
+	reflection_data = new ::java::io::ByteArrayOutputStream();
+	data_stream = new ::java::io::DataOutputStream(reflection_data);
+      }
+    return data_stream;
+  }
+
   _Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length,
 		   java::security::ProtectionDomain *pd,
 		   _Jv_Utf8Const **name_result)
@@ -234,6 +256,8 @@ struct _Jv_ClassReader
       throw_internal_error ("arguments to _Jv_DefineClass");
 
     verify = true;
+    input_data = data;
+    input_offset = offset;
     bytes  = (unsigned char*) (elements (data)+offset);
     len    = length;
     pos    = 0;
@@ -241,6 +265,8 @@ struct _Jv_ClassReader
 
     def    = klass;
     found_name = name_result;
+    reflection_data = NULL;
+    data_stream = NULL;
 
     def->size_in_bytes = -1;
     def->vtable_method_count = -1;
@@ -251,15 +277,26 @@ struct _Jv_ClassReader
   /** and here goes the parser members defined out-of-line */
   void parse ();
   void read_constpool ();
-  void prepare_pool_entry (int index, unsigned char tag);
+  void prepare_pool_entry (int index, unsigned char tag,
+			   bool rewrite = true);
   void read_fields ();
   void read_methods ();
   void read_one_class_attribute ();
   void read_one_method_attribute (int method);
   void read_one_code_attribute (int method);
-  void read_one_field_attribute (int field);
+  void read_one_field_attribute (int field, bool *);
   void throw_class_format_error (const char *msg);
 
+  void handleEnclosingMethod(int);
+  void handleGenericSignature(jv_attr_type, unsigned short, int);
+  void handleAnnotationElement();
+  void handleAnnotation();
+  void handleAnnotations();
+  void handleMemberAnnotations(jv_attr_type, int, int);
+  void handleAnnotationDefault(int, int);
+  void handleParameterAnnotations(int, int);
+  void finish_reflection_data ();
+
   /** check an utf8 entry, without creating a Utf8Const object */
   bool is_attribute_name (int index, const char *name);
 
@@ -269,9 +306,8 @@ struct _Jv_ClassReader
   void handleInterfacesBegin (int);
   void handleInterface (int, int);
   void handleFieldsBegin (int);
-  void handleField (int, int, int, int);
-  void handleFieldsEnd ();
-  void handleConstantValueAttribute (int,int);
+  void handleField (int, int, int, int, int *);
+  void handleConstantValueAttribute (int, int, bool *);
   void handleMethodsBegin (int);
   void handleMethod (int, int, int, int);
   void handleMethodsEnd ();
@@ -377,13 +413,242 @@ _Jv_ClassReader::parse ()
   if (pos != len)
     throw_class_format_error ("unused data before end of file");
 
+  finish_reflection_data ();
+
   // Tell everyone we're done.
   def->state = JV_STATE_READ;
   if (gcj::verbose_class_flag)
     _Jv_Linker::print_class_loaded (def);
+  ++gcj::loadedClasses;
   def->notifyAll ();
 }
 
+void
+_Jv_ClassReader::finish_reflection_data ()
+{
+  if (data_stream == NULL)
+    return;
+  data_stream->writeByte(JV_DONE_ATTR);
+  data_stream->flush();
+  int nbytes = reflection_data->count;
+  unsigned char *new_bytes = (unsigned char *) _Jv_AllocBytes (nbytes);
+  memcpy (new_bytes, elements (reflection_data->buf), nbytes);
+  def->reflection_data = new_bytes;
+}
+
+void
+_Jv_ClassReader::handleEnclosingMethod (int len)
+{
+  if (len != 4)
+    throw_class_format_error ("invalid EnclosingMethod attribute");
+  // FIXME: only allow one...
+
+  int class_index = read2u();
+  check_tag (class_index, JV_CONSTANT_Class);
+  prepare_pool_entry (class_index, JV_CONSTANT_Class);
+
+  int method_index = read2u();
+  // Zero is ok and means no enclosing method.
+  if (method_index != 0)
+    {
+      check_tag (method_index, JV_CONSTANT_NameAndType);
+      prepare_pool_entry (method_index, JV_CONSTANT_NameAndType);
+    }
+
+  ::java::io::DataOutputStream *stream = get_reflection_stream ();
+  stream->writeByte(JV_CLASS_ATTR);
+  stream->writeInt(5);
+  stream->writeByte(JV_ENCLOSING_METHOD_KIND);
+  stream->writeShort(class_index);
+  stream->writeShort(method_index);
+}
+
+void
+_Jv_ClassReader::handleGenericSignature (jv_attr_type type,
+					 unsigned short index,
+					 int len)
+{
+  if (len != 2)
+    throw_class_format_error ("invalid Signature attribute");
+
+  int cpool_idx = read2u();
+  check_tag (cpool_idx, JV_CONSTANT_Utf8);
+  prepare_pool_entry (cpool_idx, JV_CONSTANT_Utf8, false);
+
+  ::java::io::DataOutputStream *stream = get_reflection_stream ();
+  stream->writeByte(type);
+  int attrlen = 3;
+  if (type != JV_CLASS_ATTR)
+    attrlen += 2;
+  stream->writeInt(attrlen);
+  if (type != JV_CLASS_ATTR)
+    stream->writeShort(index);
+  stream->writeByte(JV_SIGNATURE_KIND);
+  stream->writeShort(cpool_idx);
+}
+
+void
+_Jv_ClassReader::handleAnnotationElement()
+{
+  int tag = read1u();
+  switch (tag)
+    {
+    case 'B':
+    case 'C':
+    case 'S':
+    case 'Z':
+    case 'I':
+      {
+	int index = read2u();
+	check_tag (index, JV_CONSTANT_Integer);
+	prepare_pool_entry (index, JV_CONSTANT_Integer);
+      }
+      break;
+    case 'D':
+      {
+	int index = read2u();
+	check_tag (index, JV_CONSTANT_Double);
+	prepare_pool_entry (index, JV_CONSTANT_Double);
+      }
+      break;
+    case 'F':
+      {
+	int index = read2u();
+	check_tag (index, JV_CONSTANT_Float);
+	prepare_pool_entry (index, JV_CONSTANT_Float);
+      }
+      break;
+    case 'J':
+      {
+	int index = read2u();
+	check_tag (index, JV_CONSTANT_Long);
+	prepare_pool_entry (index, JV_CONSTANT_Long);
+      }
+      break;
+    case 's':
+      {
+	int index = read2u();
+	// Despite what the JVM spec says, compilers generate a Utf8
+	// constant here, not a String.
+	check_tag (index, JV_CONSTANT_Utf8);
+	prepare_pool_entry (index, JV_CONSTANT_Utf8, false);
+      }
+      break;
+
+    case 'e':
+      {
+	int type_name_index = read2u();
+	int const_name_index = read2u ();
+	check_tag (type_name_index, JV_CONSTANT_Utf8);
+	prepare_pool_entry (type_name_index, JV_CONSTANT_Utf8);
+	check_tag (const_name_index, JV_CONSTANT_Utf8);
+	prepare_pool_entry (const_name_index, JV_CONSTANT_Utf8, false);
+      }
+      break;
+    case 'c':
+      {
+	int index = read2u();
+	check_tag (index, JV_CONSTANT_Utf8);
+	prepare_pool_entry (index, JV_CONSTANT_Utf8);
+      }
+      break;
+    case '@':
+      handleAnnotation();
+      break;
+    case '[':
+      {
+	int n_array_elts = read2u ();
+	for (int i = 0; i < n_array_elts; ++i)
+	  handleAnnotationElement();
+      }
+      break;
+    default:
+      throw_class_format_error ("invalid annotation element");
+    }
+}
+
+void
+_Jv_ClassReader::handleAnnotation()
+{
+  int type_index = read2u();
+  check_tag (type_index, JV_CONSTANT_Utf8);
+  prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
+
+  int npairs = read2u();
+  for (int i = 0; i < npairs; ++i)
+    {
+      int name_index = read2u();
+      check_tag (name_index, JV_CONSTANT_Utf8);
+      prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
+      handleAnnotationElement();
+    }
+}
+
+void
+_Jv_ClassReader::handleAnnotations()
+{
+  int num = read2u();
+  while (num--)
+    handleAnnotation();
+}
+
+void
+_Jv_ClassReader::handleMemberAnnotations(jv_attr_type member_type,
+					 int member_index,
+					 int len)
+{
+  // We're going to copy the bytes in verbatim.  But first we want to
+  // make sure the attribute is well-formed, and we want to prepare
+  // the constant pool.  So, we save our starting point.
+  int orig_pos = pos;
+
+  handleAnnotations();
+  // FIXME: check that we read all LEN bytes?
+
+  ::java::io::DataOutputStream *stream = get_reflection_stream ();
+  stream->writeByte(member_type);
+  int newLen = len + 1;
+  if (member_type != JV_CLASS_ATTR)
+    newLen += 2;
+  stream->writeInt(newLen);
+  stream->writeByte(JV_ANNOTATIONS_KIND);
+  if (member_type != JV_CLASS_ATTR)
+    stream->writeShort(member_index);
+  // Write the data as-is.
+  stream->write(input_data, input_offset + orig_pos, len);
+}
+
+void
+_Jv_ClassReader::handleAnnotationDefault(int member_index, int len)
+{
+  int orig_pos = pos;
+  handleAnnotationElement();
+
+  ::java::io::DataOutputStream *stream = get_reflection_stream ();
+  stream->writeByte(JV_METHOD_ATTR);
+  stream->writeInt(len + 3);
+  stream->writeByte(JV_ANNOTATION_DEFAULT_KIND);
+  stream->writeShort(member_index);
+  stream->write(input_data, input_offset + orig_pos, len);
+}
+
+void
+_Jv_ClassReader::handleParameterAnnotations(int member_index, int len)
+{
+  int orig_pos = pos;
+
+  int n_params = read1u();
+  for (int i = 0; i < n_params; ++i)
+    handleAnnotations();
+
+  ::java::io::DataOutputStream *stream = get_reflection_stream ();
+  stream->writeByte(JV_METHOD_ATTR);
+  stream->writeInt(len + 3);
+  stream->writeByte(JV_PARAMETER_ANNOTATIONS_KIND);
+  stream->writeShort(member_index);
+  stream->write(input_data, input_offset + orig_pos, len);
+}
+
 void _Jv_ClassReader::read_constpool ()
 {
   tags    = (unsigned char*) _Jv_AllocBytes (pool_count);
@@ -444,6 +709,47 @@ void _Jv_ClassReader::read_fields ()
   int fields_count = read2u ();
   handleFieldsBegin (fields_count);
 
+  // We want to sort the fields so that static fields come first,
+  // followed by instance fields.  We do this before parsing the
+  // fields so that we can have the new indices available when
+  // creating the annotation data structures.
+
+  // Allocate this on the heap in case there are a large number of
+  // fields.
+  int *fieldmap = (int *) _Jv_AllocBytes (fields_count * sizeof (int));
+  int save_pos = pos;
+  int static_count = 0, instance_count = -1;
+  for (int i = 0; i < fields_count; ++i)
+    {
+      using namespace java::lang::reflect;
+
+      int access_flags = read2u ();
+      skip (4);
+      int attributes_count = read2u ();
+
+      if ((access_flags & Modifier::STATIC) != 0) 
+	fieldmap[i] = static_count++;
+      else
+	fieldmap[i] = instance_count--;
+
+      for (int j = 0; j < attributes_count; ++j)
+	{
+	  skip (2);
+	  int length = read4 ();
+	  skip (length);
+	}
+    }
+  pos = save_pos;
+
+  // In the loop above, instance fields are represented by negative
+  // numbers.  Here we rewrite these to be proper offsets.
+  for (int i = 0; i < fields_count; ++i)
+    {
+      if (fieldmap[i] < 0)
+	fieldmap[i] = static_count - 1 - fieldmap[i];
+    }
+  def->static_field_count = static_count;
+
   for (int i = 0; i < fields_count; i++)
     {
       int access_flags     = read2u ();
@@ -457,15 +763,14 @@ void _Jv_ClassReader::read_fields ()
       check_tag (descriptor_index, JV_CONSTANT_Utf8);
       prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
 
-      handleField (i, access_flags, name_index, descriptor_index);
+      handleField (i, access_flags, name_index, descriptor_index, fieldmap);
 
+      bool found_value = false;
       for (int j = 0; j < attributes_count; j++)
 	{
-	  read_one_field_attribute (i);
+	  read_one_field_attribute (fieldmap[i], &found_value);
 	}
     }
-
-  handleFieldsEnd ();
 }
 
 bool
@@ -479,7 +784,8 @@ _Jv_ClassReader::is_attribute_name (int index, const char *name)
     return !memcmp (bytes+offsets[index]+2, name, len);
 }
 
-void _Jv_ClassReader::read_one_field_attribute (int field_index)
+void _Jv_ClassReader::read_one_field_attribute (int field_index,
+						bool *found_value)
 {
   int name = read2u ();
   int length = read4 ();
@@ -495,22 +801,23 @@ void _Jv_ClassReader::read_one_field_attribute (int field_index)
 	      || tags[cv] == JV_CONSTANT_Long
 	      || tags[cv] == JV_CONSTANT_Double
 	      || tags[cv] == JV_CONSTANT_String))
-	  {
-	    handleConstantValueAttribute (field_index, cv);
-	  }
-	else
-	  {
-	    throw_class_format_error ("erroneous ConstantValue attribute");
-	  }
-
-	if (length != 2) 
+	{
+	  handleConstantValueAttribute (field_index, cv, found_value);
+	}
+      else
+	{
 	  throw_class_format_error ("erroneous ConstantValue attribute");
-      }
+	}
 
-    else
-      {
-	skip (length);
-      }
+      if (length != 2) 
+	throw_class_format_error ("erroneous ConstantValue attribute");
+    }
+  else if (is_attribute_name (name, "Signature"))
+    handleGenericSignature(JV_FIELD_ATTR, field_index, length);
+  else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
+    handleMemberAnnotations(JV_FIELD_ATTR, field_index, length);
+  else
+    skip (length);
 }
 
 void _Jv_ClassReader::read_methods ()
@@ -634,7 +941,14 @@ void _Jv_ClassReader::read_one_method_attribute (int method_index)
       if ((pos - start_off) != length)
 	throw_class_format_error ("code attribute too short");
     }
-
+  else if (is_attribute_name (name, "Signature"))
+    handleGenericSignature(JV_METHOD_ATTR, method_index, length);
+  else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
+    handleMemberAnnotations(JV_METHOD_ATTR, method_index, length);
+  else if (is_attribute_name (name, "RuntimeVisibleParameterAnnotations"))
+    handleParameterAnnotations(method_index, length);
+  else if (is_attribute_name (name, "AnnotationDefault"))
+    handleAnnotationDefault(method_index, length);
   else
     {
       /* ignore unknown attributes */
@@ -680,14 +994,28 @@ void _Jv_ClassReader::read_one_class_attribute ()
     {
       int source_index = read2u ();
       check_tag (source_index, JV_CONSTANT_Utf8);
-      prepare_pool_entry (source_index, JV_CONSTANT_Utf8);
+      prepare_pool_entry (source_index, JV_CONSTANT_Utf8, false);
       def_interp->source_file_name = _Jv_NewStringUtf8Const
 	(def->constants.data[source_index].utf8);
     }
+  else if (is_attribute_name (name, "Signature"))
+    handleGenericSignature(JV_CLASS_ATTR, 0, length);
+  else if (is_attribute_name (name, "EnclosingMethod"))
+    handleEnclosingMethod(length);
+  else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
+    handleMemberAnnotations(JV_CLASS_ATTR, 0, length);
+  else if (is_attribute_name (name, "InnerClasses"))
+    {
+      ::java::io::DataOutputStream *stream = get_reflection_stream ();
+      stream->writeByte(JV_CLASS_ATTR);
+      stream->writeInt(length + 1);
+      stream->writeByte(JV_INNER_CLASSES_KIND);
+      stream->write(input_data, input_offset + pos, length);
+      skip (length);
+    }
   else
     {
-      /* Currently, we ignore most class attributes.
-         FIXME: Add inner-classes attributes support. */
+      /* Currently, we ignore most class attributes. */
      skip (length);
     }
 }
@@ -752,9 +1080,15 @@ void _Jv_ClassReader::handleConstantPool ()
 }
 
 /* this is a recursive procedure, which will prepare pool entries as needed.
-   Which is how we avoid initializing those entries which go unused. */
+   Which is how we avoid initializing those entries which go unused. 
+   
+   REWRITE is true iff this pool entry is the Utf8 representation of a
+   class name or a signature.
+*/
+
 void
-_Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag)
+_Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag,
+				     bool rewrite)
 {
   /* these two, pool_data and pool_tags, point into the class
      structure we are currently defining */
@@ -775,25 +1109,29 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag)
     {
     case JV_CONSTANT_Utf8: 
       {
-	// If we came here, it is because some other tag needs this
-	// utf8-entry for type information!  Thus, we translate /'s to .'s in
-	// order to accomondate gcj's internal representation.
-
 	int len = get2u (this_data);
-	char *buffer = (char*) __builtin_alloca (len);
 	char *s = ((char*) this_data)+2;
+	pool_tags[index] = JV_CONSTANT_Utf8;
+
+	if (! rewrite)
+	  {
+	    pool_data[index].utf8 = _Jv_makeUtf8Const (s, len);
+	    break;
+	  }
 
-	/* FIXME: avoid using a buffer here */
+	// If REWRITE is set, it is because some other tag needs this
+	// utf8-entry for type information: it is a class or a
+	// signature.  Thus, we translate /'s to .'s in order to
+	// accomondate gcj's internal representation.
+	char *buffer = (char*) __builtin_alloca (len);
 	for (int i = 0; i < len; i++)
 	  {
 	    if (s[i] == '/')
 	      buffer[i] = '.';
 	    else
-	      buffer[i] = (char) s[i];
+	      buffer[i] = s[i];
 	  }
-	
 	pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len);
-	pool_tags[index] = JV_CONSTANT_Utf8;
       }
       break;
 	    
@@ -861,8 +1199,7 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag)
 	_Jv_ushort type_index = get2u (this_data+2);
 
 	check_tag (name_index, JV_CONSTANT_Utf8);
-	prepare_pool_entry (name_index, JV_CONSTANT_Utf8);	    
-
+	prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
 	check_tag (type_index, JV_CONSTANT_Utf8);
 	prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
 
@@ -1121,19 +1458,22 @@ void _Jv_ClassReader::handleFieldsBegin (int count)
 void _Jv_ClassReader::handleField (int field_no,
 				   int flags,
 				   int name,
-				   int desc)
+				   int desc,
+				   int *fieldmap)
 {
   using namespace java::lang::reflect;
 
   _Jv_word *pool_data = def->constants.data;
 
-  _Jv_Field *field = &def->fields[field_no];
+  _Jv_Field *field = &def->fields[fieldmap[field_no]];
   _Jv_Utf8Const *field_name = pool_data[name].utf8;
 
   field->name      = field_name;
 
   // Ignore flags we don't know about.  
-  field->flags = flags & Modifier::ALL_FLAGS;
+  field->flags = flags & (Field::FIELD_MODIFIERS
+			  | Modifier::SYNTHETIC
+			  | Modifier::ENUM);
 
   _Jv_Utf8Const* sig = pool_data[desc].utf8;
 
@@ -1143,7 +1483,7 @@ void _Jv_ClassReader::handleField (int field_no,
 
       for (int i = 0; i < field_no; ++i)
 	{
-	  if (_Jv_equalUtf8Consts (field_name, def->fields[i].name)
+	  if (_Jv_equalUtf8Consts (field_name, def->fields[fieldmap[i]].name)
 	      && _Jv_equalUtf8Consts (sig,
 				      // We know the other fields are
 				      // unresolved.
@@ -1174,7 +1514,8 @@ void _Jv_ClassReader::handleField (int field_no,
 
 
 void _Jv_ClassReader::handleConstantValueAttribute (int field_index, 
-						    int value)
+						    int value,
+						    bool *found_value)
 {
   using namespace java::lang::reflect;
 
@@ -1189,10 +1530,10 @@ void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
     }
 
   // do not allow multiple constant fields!
-  if (field->flags & _Jv_FIELD_CONSTANT_VALUE)
+  if (*found_value)
     throw_class_format_error ("field has multiple ConstantValue attributes");
 
-  field->flags |= _Jv_FIELD_CONSTANT_VALUE;
+  *found_value = true;
   def_interp->field_initializers[field_index] = value;
 
   /* type check the initializer */
@@ -1203,53 +1544,6 @@ void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
   /* FIXME: do the rest */
 }
 
-void _Jv_ClassReader::handleFieldsEnd ()
-{
-  using namespace java::lang::reflect;
-
-  // We need to reorganize the fields so that the static ones are first,
-  // to conform to GCJ class layout.
-
-  int low            = 0;
-  int high           = def->field_count-1;
-  _Jv_Field  *fields = def->fields;
-  _Jv_ushort *inits  = def_interp->field_initializers;
-
-  // this is kind of a raw version of quicksort.
-  while (low < high)
-    {
-      // go forward on low, while it's a static
-      while (low < high && (fields[low].flags & Modifier::STATIC) != 0)
-	low++;
-      
-      // go backwards on high, while it's a non-static
-      while (low < high && (fields[high].flags & Modifier::STATIC) == 0)
-	high--;
-
-      if (low==high)
-	break;
-
-      _Jv_Field  tmp  = fields[low];
-      _Jv_ushort itmp = inits[low];
-	  
-      fields[low] = fields[high];
-      inits[low]  = inits[high];
-	  
-      fields[high] = tmp;
-      inits[high]  = itmp;
-	  
-      high -= 1;
-      low  += 1;
-    }
-  
-  if ((fields[low].flags & Modifier::STATIC) != 0) 
-    low += 1;
-
-  def->static_field_count = low;
-}
-
-
-
 void
 _Jv_ClassReader::handleMethodsBegin (int count)
 {
@@ -1278,7 +1572,7 @@ void _Jv_ClassReader::handleMethod
   _Jv_Method *method = &def->methods[mth_index];
 
   check_tag (name, JV_CONSTANT_Utf8);
-  prepare_pool_entry (name, JV_CONSTANT_Utf8);
+  prepare_pool_entry (name, JV_CONSTANT_Utf8, false);
   method->name = pool_data[name].utf8;
 
   check_tag (desc, JV_CONSTANT_Utf8);
@@ -1286,7 +1580,10 @@ void _Jv_ClassReader::handleMethod
   method->signature = pool_data[desc].utf8;
 
   // ignore unknown flags
-  method->accflags = accflags & Modifier::ALL_FLAGS;
+  method->accflags = accflags & (Method::METHOD_MODIFIERS
+				 | Modifier::BRIDGE
+				 | Modifier::SYNTHETIC
+				 | Modifier::VARARGS);
 
   // Initialize...
   method->ncode = 0;