Hi,
this patch makes symtab_node::equal_address_to to understand transparent
aliases and always return true for symbol and its transparent alias. In
addition I introduced new parameter MEMORY_ACCESSED which makes the function
useful for base/ofset alias oracle implementation.
We are bit schisofrenic about assumptions when aliases can happen. i.e.
&global_var == &globa_var2
will not fold to false, because we think that the variables may be aliases,
but
global_var = 1;
global_var2 = 2;
return global_var
will return 1 becuase the alias oracle assumes aliases to not exist.
I think we could have optimization flag controling this and switch
to the assumption that there are no invisible aliases next stage1. For
now I am preserving current schisofreny - see the end of the patch
so we won't lose too many of alias oracle hits.
Bootstrapped/regtested x86_64-linux, comitted.
* symtab.c (symtab_node::equal_address_to): New parameter
MEMORY_ACCESSED.
* cgraph.h (symtab_node::equal_address_to): Update prototype.
Index: symtab.c
===================================================================
--- symtab.c (revision 231439)
+++ symtab.c (working copy)
@@ -1878,9 +1878,14 @@ symtab_node::nonzero_address ()
/* Return 0 if symbol is known to have different address than S2,
Return 1 if symbol is known to have same address as S2,
- return 2 otherwise. */
+ return 2 otherwise.
+
+ If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
+ and S2 is going to be accessed. This eliminates the situations when
+ either THIS or S2 is NULL and is seful for comparing bases when deciding
+ about memory aliasing. */
int
-symtab_node::equal_address_to (symtab_node *s2)
+symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
{
enum availability avail1, avail2;
@@ -1888,6 +1893,16 @@ symtab_node::equal_address_to (symtab_no
if (this == s2)
return 1;
+ /* Unwind transparent aliases first; those are always equal to their
+ target. */
+ if (this->transparent_alias && this->analyzed)
+ return this->get_alias_target ()->equal_address_to (s2);
+ while (s2->transparent_alias && s2->analyzed)
+ s2 = s2->get_alias_target();
+
+ if (this == s2)
+ return 1;
+
/* For non-interposable aliases, lookup and compare their actual definitions.
Also check if the symbol needs to bind to given definition. */
symtab_node *rs1 = ultimate_alias_target (&avail1);
@@ -1924,8 +1939,9 @@ symtab_node::equal_address_to (symtab_no
return 1;
}
- /* If both symbols may resolve to NULL, we can not really prove them
different. */
- if (!nonzero_address () && !s2->nonzero_address ())
+ /* If both symbols may resolve to NULL, we can not really prove them
+ different. */
+ if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
return 2;
/* Except for NULL, functions and variables never overlap. */
@@ -1956,11 +1972,12 @@ symtab_node::equal_address_to (symtab_no
}
/* TODO: Alias oracle basically assume that addresses of global variables
- are different unless they are declared as alias of one to another.
- We probably should be consistent and use this fact here, too, and update
- alias oracle to use this predicate. */
+ are different unless they are declared as alias of one to another while
+ the code folding comparsions doesn't.
+ We probably should be consistent and use this fact here, too, but for
+ the moment return false only when we are called from the alias oracle. */
- return 2;
+ return memory_accessed && rs1 != rs2 ? 0 : 2;
}
/* Worker for call_for_symbol_and_aliases. */
Index: cgraph.h
===================================================================
--- cgraph.h (revision 231439)
+++ cgraph.h (working copy)
@@ -355,8 +355,13 @@ public:
/* Return 0 if symbol is known to have different address than S2,
Return 1 if symbol is known to have same address as S2,
- return 2 otherwise. */
- int equal_address_to (symtab_node *s2);
+ return 2 otherwise.
+
+ If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
+ and S2 is going to be accessed. This eliminates the situations when
+ either THIS or S2 is NULL and is seful for comparing bases when deciding
+ about memory aliasing. */
+ int equal_address_to (symtab_node *s2, bool memory_accessed = false);
/* Return true if symbol's address may possibly be compared to other
symbol's address. */
