Patch: FYI: PR 26861

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in.

This fixes PR 26861 by removing an old (and erroneous) check of a
constant pool index.  This then reveals the PR 26868 problem again
for the interpreter, which is fixed in the patch by making NULLCHECK
unconditional.  This patch also deletes some related dead code in the
runtime linker.

FWIW -- David Daney is not crazy.  The PR 26868 really did occur on
my machine, verified by looking in /proc/.../maps.

Tom

Index: ChangeLog
from  Tom Tromey  <tromey@redhat.com>
	PR libgcj/26861:
	* interpret.cc (run) <insn_getfield>: Removed 0xffff check.
	<insn_putfield>: Likewise.
	(NULLCHECK): Define unconditionally.
	* link.cc (ensure_class_linked): Removed dead code.

Index: link.cc
===================================================================
--- link.cc	(revision 113527)
+++ link.cc	(working copy)
@@ -1629,21 +1629,6 @@
 	    }
 	}
 
-#if 0  // Should be redundant now
-      // If superclass looks like a constant pool entry,
-      // resolve it now.
-      if ((uaddr) klass->superclass < (uaddr) pool->size)
-	klass->superclass = pool->data[(uaddr) klass->superclass].clazz;
-
-      // Likewise for interfaces.
-      for (int i = 0; i < klass->interface_count; i++)
-	{
-	  if ((uaddr) klass->interfaces[i] < (uaddr) pool->size)
-	    klass->interfaces[i]
-	      = pool->data[(uaddr) klass->interfaces[i]].clazz;
-	}
-#endif
-
       // Resolve the remaining constant pool entries.
       for (int index = 1; index < pool->size; ++index)
 	{
Index: interpret.cc
===================================================================
--- interpret.cc	(revision 113527)
+++ interpret.cc	(working copy)
@@ -25,7 +25,6 @@
 #include <java/lang/StringBuffer.h>
 #include <java/lang/Class.h>
 #include <java/lang/reflect/Modifier.h>
-#include <java/lang/VirtualMachineError.h>
 #include <java/lang/InternalError.h>
 #include <java/lang/NullPointerException.h>
 #include <java/lang/ArithmeticException.h>
@@ -222,12 +221,20 @@
 
 #define SAVE_PC() frame_desc.pc = pc
 
+// We used to define this conditionally, depending on HANDLE_SEGV.
+// However, that runs into a problem if a chunk in low memory is
+// mapped and we try to look at a field near the end of a large
+// object.  See PR 26858 for details.  It is, most likely, relatively
+// inexpensive to simply do this check always.
+#define NULLCHECK(X) \
+  do { SAVE_PC(); if ((X)==NULL) throw_null_pointer_exception (); } while (0)
+
+// Note that we can still conditionally define NULLARRAYCHECK, since
+// we know that all uses of an array will first reference the length
+// field, which is first -- and thus will trigger a SEGV.
 #ifdef HANDLE_SEGV
-#define NULLCHECK(X) SAVE_PC()
 #define NULLARRAYCHECK(X) SAVE_PC()
 #else
-#define NULLCHECK(X) \
-  do { SAVE_PC(); if ((X)==NULL) throw_null_pointer_exception (); } while (0)
 #define NULLARRAYCHECK(X) \
   do { SAVE_PC(); if ((X)==NULL) { throw_null_pointer_exception (); } } while (0)
 #endif
@@ -2542,8 +2549,6 @@
 
 	jclass type = field->type;
 	jint field_offset = field->u.boffset;
-	if (field_offset > 0xffff)
-	  throw new java::lang::VirtualMachineError;
 
 	jobject obj   = POPA();
 	NULLCHECK(obj);
@@ -2746,8 +2751,6 @@
 	    (JvNewStringLatin1 ("field is static"));
 
 	jint field_offset = field->u.boffset;
-	if (field_offset > 0xffff)
-	  throw new java::lang::VirtualMachineError;
 
 	void *newinsn = NULL;
 	if (type->isPrimitive ())