Re: Compare field offsets in fold_const when checking addresses

[Jan Hubicka]

Hi,
this is updated patch I am re-testing and plan to commit if it suceeds.

        * fold-const.c (operand_compare::operand_equal_p): Compare
        offsets of fields in component_refs when comparing addresses.
        (operand_compare::hash_operand): Likewise.
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index c47557daeba..273ee25ceda 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -3312,11 +3312,36 @@ operand_compare::operand_equal_p (const_tree arg0, 
const_tree arg1,
        case COMPONENT_REF:
          /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
             may be NULL when we're called to compare MEM_EXPRs.  */
-         if (!OP_SAME_WITH_NULL (0)
-             || !OP_SAME (1))
+         if (!OP_SAME_WITH_NULL (0))
            return false;
-         flags &= ~OEP_ADDRESS_OF;
-         return OP_SAME_WITH_NULL (2);
+         /* Most of time we only need to compare FIELD_DECLs for equality.
+            However when determining address look into actual offsets.
+            These may match for unions and unshared record types.  */
+         if (!OP_SAME (1))
+           {
+             if (flags & OEP_ADDRESS_OF)
+               {
+                 if (TREE_OPERAND (arg0, 2)
+                     || TREE_OPERAND (arg1, 2))
+                   {
+                     flags &= ~OEP_ADDRESS_OF;
+                     return OP_SAME_WITH_NULL (2);
+                   }
+                 tree field0 = TREE_OPERAND (arg0, 1);
+                 tree field1 = TREE_OPERAND (arg1, 1);
+
+                 if (!operand_equal_p (DECL_FIELD_OFFSET (field0),
+                                       DECL_FIELD_OFFSET (field1),
+                                       flags & ~OEP_ADDRESS_OF)
+                     || !operand_equal_p (DECL_FIELD_BIT_OFFSET (field0),
+                                          DECL_FIELD_BIT_OFFSET (field1),
+                                          flags & ~OEP_ADDRESS_OF))
+                   return false;
+               }
+             else
+               return false;
+           }
+         return true;
 
        case BIT_FIELD_REF:
          if (!OP_SAME (0))
@@ -3787,9 +3812,26 @@ operand_compare::hash_operand (const_tree t, 
inchash::hash &hstate,
              sflags = flags;
              break;
 
+           case COMPONENT_REF:
+             if (sflags & OEP_ADDRESS_OF)
+               {
+                 hash_operand (TREE_OPERAND (t, 0), hstate, flags);
+                 if (TREE_OPERAND (t, 2))
+                   hash_operand (TREE_OPERAND (t, 2), hstate,
+                                 flags & ~OEP_ADDRESS_OF);
+                 else
+                   {
+                     tree field = TREE_OPERAND (t, 1);
+                     hash_operand (DECL_FIELD_OFFSET (field),
+                                   hstate, flags & ~OEP_ADDRESS_OF);
+                     hash_operand (DECL_FIELD_BIT_OFFSET (field),
+                                   hstate, flags & ~OEP_ADDRESS_OF);
+                   }
+                 return;
+               }
+             break;
            case ARRAY_REF:
            case ARRAY_RANGE_REF:
-           case COMPONENT_REF:
            case BIT_FIELD_REF:
              sflags &= ~OEP_ADDRESS_OF;
              break;