stabilize .gcc_except_table with or without -g

[Alexandre Oliva <aoliva@redhat.com>]

[-- Attachment #1: Type: text/plain, Size: 1255 bytes --]

In Java, on x86_64-linux-gnu (both -m32 and -m64 IIRC)
.gcc_except_table action record tables are sometimes output using
dw2_asm_output_encoded_addr_rtx(), which, with indirect addressing,
forces expressions into memory using a splay tree that uses string
*pointers* as keys.  These pointers are not stable, so the order in
which the splay tree entries are output by
dw2_output_indirect_constants() varies depending on where the symbol
names are located in memory.  Their locations often change when -g is
given, so we end up generating code that wouldn't pass compare-debug.

I haven't completed bootstrap-testing of this patch yet, but it has
shaved off more than half of the remaining compare-debug differences
between libjava compiled with -fvar-tracking-assignments enabled or
disabled on x86_64-linux-gnu.

Ok to install if it passes bootstrap?  Should new the compare function
be moved into libiberty proper?  Does the assertion check seem safe in
the context of this use, that when pointers differ then the strings
they point to must differ as well?  It's not necessary, but I thought
it would be nice to make sure we weren't goofing with identical symbol
names at different locations before.  I could be easily convinced to
take it out, though.


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: gcc-stabilize-dw2-force-const-mem.patch --]
[-- Type: text/x-patch, Size: 1548 bytes --]

for  gcc/ChangeLog .vta?
from  Alexandre Oliva  <aoliva@redhat.com>

	* dwarf2asm.c (splay_tree_compare_strings): New function.
	(dw2_force_const_mem): Use it.

Index: gcc/dwarf2asm.c
===================================================================
--- gcc/dwarf2asm.c.orig	2007-11-05 04:51:08.000000000 -0200
+++ gcc/dwarf2asm.c	2007-11-05 02:20:11.000000000 -0200
@@ -701,6 +701,28 @@ static GTY(()) int dw2_const_labelno;
 # define USE_LINKONCE_INDIRECT 0
 #endif
 
+/* Compare C strings used as keys in a splay tree, optimizing the case
+   in which the pointers are identical.  We need to use string rather
+   than pointer comparison in order to make Java exception action
+   records stable in the presence of different debug info options.  */
+
+static int
+splay_tree_compare_strings (splay_tree_key k1, splay_tree_key k2)
+{
+  const char *s1 = (const char *)k1;
+  const char *s2 = (const char *)k2;
+  int ret;
+
+  if (s1 == s2)
+    return 0;
+
+  ret = strcmp (s1, s2);
+
+  gcc_assert (ret);
+
+  return ret;
+}
+
 /* Put X, a SYMBOL_REF, in memory.  Return a SYMBOL_REF to the allocated
    memory.  Differs from force_const_mem in that a single pool is used for
    the entire unit of translation, and the memory is not guaranteed to be
@@ -715,7 +737,7 @@ dw2_force_const_mem (rtx x, bool public)
   tree decl;
 
   if (! indirect_pool)
-    indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
+    indirect_pool = splay_tree_new_ggc (splay_tree_compare_strings);
 
   gcc_assert (GET_CODE (x) == SYMBOL_REF);
 

[-- Attachment #3: Type: text/plain, Size: 249 bytes --]


-- 
Alexandre Oliva         http://www.lsd.ic.unicamp.br/~oliva/
FSF Latin America Board Member         http://www.fsfla.org/
Red Hat Compiler Engineer   aoliva@{redhat.com, gcc.gnu.org}
Free Software Evangelist  oliva@{lsd.ic.unicamp.br, gnu.org}