Changeset 1391 for branches/GNU/src/gcc/libjava/verify.cc

Timestamp:

Apr 27, 2004, 8:39:34 PM (22 years ago)

Author:

bird

Message:

GCC v3.3.3 sources.

Location:

branches/GNU/src/gcc

Files:

• . (modified) (1 prop)
• libjava/verify.cc (modified) (38 diffs, 1 prop)

branches/GNU/src/gcc

@@ -26 +26 @@
 configure.vr
 configure.vrs
+
 Makefile
-dir.info
 lost+found
 update.out

@@ -26 +26 @@
 configure.vr
 configure.vrs
+
 Makefile
-dir.info
 lost+found
 update.out

branches/GNU/src/gcc/libjava/verify.cc

@@ -1 +1 @@
 // defineclass.cc - defining a class from .class format.
 
-/* Copyright (C) 2001, 2002  Free Software Foundation
+/* Copyright (C) 2001, 2002  Free Software Foundation
 
    This file is part of libgcj.
@@ -127 +127 @@
 
     return r;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   }
 
@@ -406 +434 @@
       using namespace java::lang;
       java::lang::ClassLoader *loader
-        = verifier->current_class->getClassLoader();
+        = verifier->current_class->getClassLoader();
       // We might see either kind of name.  Sigh.
       if (data.name->data[0] == 'L'
@@ -459 +487 @@
         return key == k.key;
 
-      // The `null' type is convertible to any reference type.
-      // FIXME: is this correct for THIS?
+      // The `null' type is convertible to any 
+      // 
       if (key == null_type || k.key == null_type)
         return true;
@@ -572 +600 @@
       if (key == reference_type)
         return type (_Jv_GetArrayClass (data.klass,
-                                        data.klass->getClassLoader ()));
+                                        data.klass->getClassLoader()));
       else
         verifier->verify_fail ("internal error in type::to_array()");
@@ -696 +724 @@
                         {
                           java::lang::ClassLoader *loader
-                            = verifier->current_class->getClassLoader();
+                            = verifier->current_class->getClassLoader();
                           k = _Jv_GetArrayClass (k, loader);
                           --arraycount;
@@ -794 +822 @@
     // without really initializing.
     type this_type;
+
+
+
+
+
+
 
     // INVALID marks a state which is not on the linked list of states
@@ -812 +846 @@
       locals = NULL;
       local_changed = NULL;
+
     }
 
@@ -824 +859 @@
       locals = new type[max_locals];
       local_changed = (bool *) _Jv_Malloc (sizeof (bool) * max_locals);
+
       for (int i = 0; i < max_locals; ++i)
         {
@@ -839 +875 @@
       locals = new type[max_locals];
       local_changed = (bool *) _Jv_Malloc (sizeof (bool) * max_locals);
+
       copy (orig, max_stack, max_locals, ret_semantics);
       next = INVALID;
@@ -851 +888 @@
       if (local_changed)
         _Jv_Free (local_changed);
+
     }
 
@@ -871 +909 @@
     {
       _Jv_Free (mem);
+
+
+
+
+
+
+
+
+
+
+
     }
 
@@ -892 +941 @@
           local_changed[i] = copy->local_changed[i];
         }
+
+
+
+
+
+
+
+
+
+
       this_type = copy->this_type;
       // Don't modify `next'.
@@ -916 +975 @@
       for (int i = 0; i < max_locals; ++i)
         local_changed[i] = false;
+
+
+
+
+
+
+
+
+
     }
 
@@ -945 +1013 @@
       else
         {
-          // If the subroutines differ, indicate that the state
-          // changed.  This is needed to detect when subroutines have
-          // merged.
-          changed = true;
+          // If the subroutines differ, and we haven't seen this
+          // subroutine before, indicate that the state changed.  This
+          // is needed to detect when subroutines have merged.
+          bool found = false;
+          for (subr_info *info = seen_subrs; info != NULL; info = info->next)
+            {
+              if (info->pc == state_old->subroutine)
+                {
+                  found = true;
+                  break;
+                }
+            }
+          if (! found)
+            {
+              add_subr (state_old->subroutine);
+              changed = true;
+            }
         }
 
@@ -1122 +1203 @@
   }
 
-  type pop64 ()
-  {
-    type r = pop_raw ();
-    if (! r.iswide ())
-      verify_fail ("wide pop of narrow type");
-    return r;
-  }
-
   type pop_type (type match)
   {
@@ -1135 +1208 @@
     type t = pop_raw ();
     if (! match.compatible (t, this))
+
+
+
+
+
+
+
+
+
+
+
+
+
       verify_fail ("incompatible type on stack");
     return t;
@@ -1339 +1425 @@
     int *prev_loc = &next_verify_pc;
     int npc = next_verify_pc;
-    bool skipped = false;
 
     while (npc != state::NO_NEXT)
@@ -1356 +1441 @@
           }
 
-        skipped = true;
         prev_loc = &states[npc]->next;
         npc = states[npc]->next;
@@ -1435 +1519 @@
     for (subr_info *subr = jsr_ptrs[csub]; subr != NULL; subr = subr->next)
       {
+
+
+
+
+
+
         // Temporarily modify the current state so it looks like we're
         // in the enclosing context.
@@ -1484 +1574 @@
     // might change the stack depth, so we can't make any assumptions
     // about it.  So we have yet another special case.  We know that
-    // at this point PC points to the instruction after the jsr.
-
-    // FIXME: what if we have a jsr at the end of the code, but that
-    // jsr has no corresponding ret?  Is this verifiable, or is it
-    // not?  If it is then we need a special case here.
-    if (PC >= current_method->code_length)
-      verify_fail ("fell off end");
-
-    current_state->stacktop = state::NO_STACK;
-    push_jump_merge (PC, current_state);
+    // at this point PC points to the instruction after the jsr.  Note
+    // that it is ok to have a `jsr' at the end of the bytecode,
+    // provided that the called subroutine never returns.  So, we have
+    // a special case here and another one when we handle the ret.
+    if (PC < current_method->code_length)
+      {
+        current_state->stacktop = state::NO_STACK;
+        push_jump_merge (PC, current_state);
+      }
     invalidate_pc ();
   }
@@ -1526 +1615 @@
         k = JvPrimClass (long);
         break;
+
+
+
+
+
+
+
+
+
+
+
+
+
       default:
         verify_fail ("unknown type in construct_primitive_array_type");
@@ -1829 +1931 @@
             break;
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
           default:
             verify_fail ("unrecognized instruction in branch_prepass",
@@ -1846 +1972 @@
     for (int i = 0; i < current_method->exc_count; ++i)
       {
-        if (! (flags[exception[i].handler_pc] & FLAG_INSN_START))
+        if (! (flags[exception[i].handler_pc] & FLAG_INSN_START))
           verify_fail ("exception handler not at instruction start",
-                       exception[i].handler_pc);
-        if (! (flags[exception[i].start_pc] & FLAG_INSN_START))
+                       exception[i].handler_pc);
+        if (! (flags[exception[i].start_pc] & FLAG_INSN_START))
           verify_fail ("exception start not at instruction start",
-                       exception[i].start_pc);
-        if (exception[i].end_pc != current_method->code_length
-            && ! (flags[exception[i].end_pc] & FLAG_INSN_START))
+                       exception[i].start_pc);
+        if (exception[i].end_pc != current_method->code_length
+            && ! (flags[exception[i].end_pc] & FLAG_INSN_START))
           verify_fail ("exception end not at instruction start",
-                       exception[i].end_pc);
-
-        flags[exception[i].handler_pc] |= FLAG_BRANCH_TARGET;
+                       exception[i].end_pc);
+
+        flags[exception[i].handler_pc] |= FLAG_BRANCH_TARGET;
       }
   }
@@ -2027 +2153 @@
   {
     int var = 0;
-    bool is_init = false;
+    bool is_init = _Jv_equalUtf8Consts (current_method->self->name,
+                                        gcj::init_name);
+    bool is_clinit = _Jv_equalUtf8Consts (current_method->self->name,
+                                          gcj::clinit_name);
 
     using namespace java::lang::reflect;
@@ -2033 +2162 @@
       {
         type kurr (current_class);
-        if (_Jv_equalUtf8Consts (current_method->self->name, gcj::init_name))
+        if ()
           {
             kurr.set_uninitialized (type::SELF, this);
             is_init = true;
           }
+
+
         set_variable (0, kurr);
         current_state->set_this_type (kurr);
         ++var;
+
+
+
+
+
       }
 
@@ -2150 +2286 @@
         for (int i = 0; i < current_method->exc_count; ++i)
           {
-            if (PC >= exception[i].start_pc && PC < exception[i].end_pc)
+            if (PC >= exception[i].start_pc)
               {
                 type handler (&java::lang::Throwable::class$);
-                if (exception[i].handler_type != 0)
-                  handler = check_class_constant (exception[i].handler_type);
-                push_exception_jump (handler, exception[i].handler_pc);
+                if (exception[i].handler_type != 0)
+                  handler = check_class_constant (exception[i].handler_type);
+                push_exception_jump (handler, exception[i].handler_pc);
               }
           }
@@ -2265 +2401 @@
           case op_iaload:
             pop_type (int_type);
-            push_type (require_array_type (pop_type (reference_type),
+            push_type (require_array_type (pop_ (reference_type),
                                            int_type));
             break;
           case op_laload:
             pop_type (int_type);
-            push_type (require_array_type (pop_type (reference_type),
+            push_type (require_array_type (pop_ (reference_type),
                                            long_type));
             break;
           case op_faload:
             pop_type (int_type);
-            push_type (require_array_type (pop_type (reference_type),
+            push_type (require_array_type (pop_ (reference_type),
                                            float_type));
             break;
           case op_daload:
             pop_type (int_type);
-            push_type (require_array_type (pop_type (reference_type),
+            push_type (require_array_type (pop_ (reference_type),
                                            double_type));
             break;
           case op_aaload:
             pop_type (int_type);
-            push_type (require_array_type (pop_type (reference_type),
+            push_type (require_array_type (pop_ (reference_type),
                                            reference_type));
             break;
           case op_baload:
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), byte_type);
+            require_array_type (pop_ (reference_type), byte_type);
             push_type (int_type);
             break;
           case op_caload:
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), char_type);
+            require_array_type (pop_ (reference_type), char_type);
             push_type (int_type);
             break;
           case op_saload:
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), short_type);
+            require_array_type (pop_ (reference_type), short_type);
             push_type (int_type);
             break;
@@ -2351 +2487 @@
             pop_type (int_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), int_type);
+            require_array_type (pop_ (reference_type), int_type);
             break;
           case op_lastore:
             pop_type (long_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), long_type);
+            require_array_type (pop_ (reference_type), long_type);
             break;
           case op_fastore:
             pop_type (float_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), float_type);
+            require_array_type (pop_ (reference_type), float_type);
             break;
           case op_dastore:
             pop_type (double_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), double_type);
+            require_array_type (pop_ (reference_type), double_type);
             break;
           case op_aastore:
             pop_type (reference_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), reference_type);
+            require_array_type (pop_ (reference_type), reference_type);
             break;
           case op_bastore:
             pop_type (int_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), byte_type);
+            require_array_type (pop_ (reference_type), byte_type);
             break;
           case op_castore:
             pop_type (int_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), char_type);
+            require_array_type (pop_ (reference_type), char_type);
             break;
           case op_sastore:
             pop_type (int_type);
             pop_type (int_type);
-            require_array_type (pop_type (reference_type), short_type);
+            require_array_type (pop_ (reference_type), short_type);
             break;
           case op_pop:
@@ -2392 +2528 @@
             break;
           case op_pop2:
-            pop64 ();
+            {
+              type t = pop_raw ();
+              if (! t.iswide ())
+                pop32 ();
+            }
             break;
           case op_dup:
@@ -2724 +2864 @@
             break;
           case op_areturn:
-            check_return_type (pop_type (reference_type));
+            check_return_type (pop_ (reference_type));
             invalidate_pc ();
             break;
@@ -2806 +2946 @@
                   // invokeinterface.
                   nargs -= arg_types[i].depth ();
-                  pop_type (arg_types[i]);
+                  pop_ (arg_types[i]);
                 }
 
@@ -2823 +2963 @@
                   type raw = pop_raw ();
                   bool ok = false;
-                  if (t.compatible (raw, this))
+                  if (! is_init && ! raw.isinitialized ())
+                    {
+                      // This is a failure.
+                    }
+                  else if (is_init && raw.isnull ())
+                    {
+                      // Another failure.
+                    }
+                  else if (t.compatible (raw, this))
                     {
                       ok = true;
@@ -2879 +3027 @@
           case op_arraylength:
             {
-              type t = pop_type (reference_type);
+              type t = pop_ (reference_type);
               if (! t.isarray () && ! t.isnull ())
                 verify_fail ("array type expected");
@@ -2890 +3038 @@
             break;
           case op_checkcast:
-            pop_type (reference_type);
+            pop_ (reference_type);
             push_type (check_class_constant (get_ushort ()));
             break;
           case op_instanceof:
-            pop_type (reference_type);
+            pop_ (reference_type);
             check_class_constant (get_ushort ());
             push_type (int_type);
             break;
           case op_monitorenter:
-            pop_type (reference_type);
+            pop_ (reference_type);
             break;
           case op_monitorexit:
-            pop_type (reference_type);
+            pop_ (reference_type);
             break;
           case op_wide:
@@ -2936 +3084 @@
                   break;
                 case op_astore:
-                  set_variable (get_ushort (), pop_type (reference_type));
+                  set_variable (get_ushort (), pop_ (reference_type));
                   break;
                 case op_ret:
@@ -2975 +3123 @@
             break;
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
           default:
             // Unrecognized opcode.
@@ -2981 +3153 @@
           }
       }
-  }
-
-  __attribute__ ((__noreturn__)) void verify_fail (char *s, jint pc = -1)
-  {
-    using namespace java::lang;
-    StringBuffer *buf = new StringBuffer ();
-
-    buf->append (JvNewStringLatin1 ("verification failed"));
-    if (pc == -1)
-      pc = start_PC;
-    if (pc != -1)
-      {
-        buf->append (JvNewStringLatin1 (" at PC "));
-        buf->append (pc);
-      }
-
-    _Jv_InterpMethod *method = current_method;
-    buf->append (JvNewStringLatin1 (" in "));
-    buf->append (current_class->getName());
-    buf->append ((jchar) ':');
-    buf->append (JvNewStringUTF (method->get_method()->name->data));
-    buf->append ((jchar) '(');
-    buf->append (JvNewStringUTF (method->get_method()->signature->data));
-    buf->append ((jchar) ')');
-
-    buf->append (JvNewStringLatin1 (": "));
-    buf->append (JvNewStringLatin1 (s));
-    throw new java::lang::VerifyError (buf->toString ());
   }
 

@@ -26 +26 @@
 configure.vr
 configure.vrs
+
 Makefile
-dir.info
 lost+found
 update.out