Patch: FYI: another verifier fix

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in.

This fixes a few bugs:

* Any utf8const we created could be collected.
  This patch is ugly.  We should find something better here.

* type::merge now notices when a local variable merge didn't actually
  change the state.  This fixed an infinite loop problem when
  verifying Mauve (earlier bug fixes have caused "regressions" -- in
  the past we "verified" Mauve but weren't actually verifying all the
  code)

Tom

Index: ChangeLog
from  Tom Tromey  <tromey@redhat.com>
	* verify.cc (_Jv_BytecodeVerifier::linked_utf8): New structure.
	(_Jv_BytecodeVerifier::utf8_list): New field.
	(_Jv_BytecodeVerifier::_Jv_BytecodeVerifier): Initialize it.
	(_Jv_BytecodeVerifier::~_Jv_BytecodeVerifier): Free it.
	(_Jv_BytecodeVerifier::make_utf8_const): New method.
	(_Jv_BytecodeVerifier::get_one_type): Use it.
	(_Jv_BytecodeVerifier::type::merge): When using local semantics,
	if the destination type is already unsuitable then we didn't
	change.

Index: verify.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/verify.cc,v
retrieving revision 1.19
diff -u -r1.19 verify.cc
--- verify.cc 2001/12/04 20:18:35 1.19
+++ verify.cc 2001/12/04 23:49:34
@@ -50,6 +50,7 @@
   struct state;
   struct type;
   struct subr_info;
+  struct linked_utf8;
 
   // The current PC.
   int PC;
@@ -93,6 +94,34 @@
   // This method.
   _Jv_InterpMethod *current_method;
 
+  // A linked list of utf8 objects we allocate.  This is really ugly,
+  // but without this our utf8 objects would be collected.
+  linked_utf8 *utf8_list;
+
+  struct linked_utf8
+  {
+    _Jv_Utf8Const *val;
+    linked_utf8 *next;
+  };
+
+  _Jv_Utf8Const *make_utf8_const (char *s, int len)
+  {
+    _Jv_Utf8Const *val = _Jv_makeUtf8Const (s, len);
+    _Jv_Utf8Const *r = (_Jv_Utf8Const *) _Jv_Malloc (sizeof (_Jv_Utf8Const)
+						     + val->length
+						     + 1);
+    r->length = val->length;
+    r->hash = val->hash;
+    memcpy (r->data, val->data, val->length + 1);
+
+    linked_utf8 *lu = (linked_utf8 *) _Jv_Malloc (sizeof (linked_utf8));
+    lu->val = r;
+    lu->next = utf8_list;
+    utf8_list = lu;
+
+    return r;
+  }
+
   // This enum holds a list of tags for all the different types we
   // need to handle.  Reference types are treated specially by the
   // type class.
@@ -632,8 +661,13 @@
 	{
 	  if (local_semantics)
 	    {
-	      key = unsuitable_type;
-	      changed = true;
+	      // If we already have an `unsuitable' type, then we
+	      // don't need to change again.
+	      if (key != unsuitable_type)
+		{
+		  key = unsuitable_type;
+		  changed = true;
+		}
 	    }
 	  else
 	    verify_fail ("unmergeable type");
@@ -1640,8 +1674,7 @@
 	while (*p != ';')
 	  ++p;
 	++p;
-	// FIXME!  This will get collected!
-	_Jv_Utf8Const *name = _Jv_makeUtf8Const (start, p - start);
+	_Jv_Utf8Const *name = make_utf8_const (start, p - start);
 	return type (name);
       }
 
@@ -2604,6 +2637,7 @@
     states = NULL;
     flags = NULL;
     jsr_ptrs = NULL;
+    utf8_list = NULL;
   }
 
   ~_Jv_BytecodeVerifier ()
@@ -2614,6 +2648,13 @@
       _Jv_Free (flags);
     if (jsr_ptrs)
       _Jv_Free (jsr_ptrs);
+    while (utf8_list != NULL)
+      {
+	linked_utf8 *n = utf8_list->next;
+	_Jv_Free (utf8_list->val);
+	_Jv_Free (utf8_list);
+	utf8_list = n;
+      }
   }
 };