* varasm.c (decode_addr_const): Handle special case of INDIRECT_REF.

	(const_hash_1) <VECTOR_CST>: New case.
	(compare_constant) <VECTOR_CST>: Likewise.
	<ADDR_EXPR>: Deal with LABEL_REFs.
	(copy_constant) <VECTOR_CST>: New case.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158776 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 65c8fea..e254eec 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2010-04-27  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * varasm.c (decode_addr_const): Handle special case of INDIRECT_REF.
+       (const_hash_1) <VECTOR_CST>: New case.
+       (compare_constant) <VECTOR_CST>: Likewise.
+       <ADDR_EXPR>: Deal with LABEL_REFs.
+       (copy_constant) <VECTOR_CST>: New case.
+
 2010-04-27  Jan Hubicka  <jh@suse.cz>
 
        * cgraph.c (cgraph_propagate_frequency): New function.

diff --git a/gcc/varasm.c b/gcc/varasm.c
index fc0eb8a..35b65a9 100644 (file)
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -2802,6 +2802,11 @@ decode_addr_const (tree exp, struct addr_const *value)
                     * tree_low_cst (TREE_OPERAND (target, 1), 0));
          target = TREE_OPERAND (target, 0);
        }
+      else if (TREE_CODE (target) == INDIRECT_REF
+              && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR
+              && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0))
+                 == ADDR_EXPR)
+       target = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target, 0), 0), 0);
       else
        break;
     }
@@ -2894,6 +2899,18 @@ const_hash_1 (const tree exp)
       return (const_hash_1 (TREE_REALPART (exp)) * 5
              + const_hash_1 (TREE_IMAGPART (exp)));
 
+    case VECTOR_CST:
+      {
+       tree link;
+
+       hi = 7 + TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp));
+
+       for (link = TREE_VECTOR_CST_ELTS (exp); link; link = TREE_CHAIN (link))
+           hi = hi * 563 + const_hash_1 (TREE_VALUE (link));
+
+       return hi;
+      }
+
     case CONSTRUCTOR:
       {
        unsigned HOST_WIDE_INT idx;
@@ -3022,6 +3039,27 @@ compare_constant (const tree t1, const tree t2)
       return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
              && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
 
+    case VECTOR_CST:
+      {
+        tree link1, link2;
+
+        if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (t1))
+           != TYPE_VECTOR_SUBPARTS (TREE_TYPE (t2)))
+         return 0;
+
+       link2 = TREE_VECTOR_CST_ELTS (t2);
+       for (link1 = TREE_VECTOR_CST_ELTS (t1);
+            link1;
+            link1 = TREE_CHAIN (link1))
+         {
+           if (!compare_constant (TREE_VALUE (link1), TREE_VALUE (link2)))
+             return 0;
+           link2 = TREE_CHAIN (link2);
+         }
+       
+       return 1;
+      }
+
     case CONSTRUCTOR:
       {
        VEC(constructor_elt, gc) *v1, *v2;
@@ -3082,11 +3120,34 @@ compare_constant (const tree t1, const tree t2)
     case FDESC_EXPR:
       {
        struct addr_const value1, value2;
+       enum rtx_code code;
+       int ret;
 
        decode_addr_const (t1, &value1);
        decode_addr_const (t2, &value2);
-       return (value1.offset == value2.offset
-               && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
+
+       if (value1.offset != value2.offset)
+         return 0;
+
+       code = GET_CODE (value1.base);
+       if (code != GET_CODE (value2.base))
+         return 0;
+
+       switch (code)
+         {
+         case SYMBOL_REF:
+           ret = (strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
+           break;
+
+         case LABEL_REF:
+           ret = (CODE_LABEL_NUMBER (XEXP (value1.base, 0))
+                  == CODE_LABEL_NUMBER (XEXP (value2.base, 0)));
+           break;
+
+         default:
+           gcc_unreachable ();
+         }
+       return ret;
       }
 
     case PLUS_EXPR:
@@ -3147,6 +3208,10 @@ copy_constant (tree exp)
       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
                     copy_constant (TREE_OPERAND (exp, 0)));
 
+    case VECTOR_CST:
+      return build_vector (TREE_TYPE (exp),
+                          copy_list (TREE_VECTOR_CST_ELTS (exp)));
+
     case CONSTRUCTOR:
       {
        tree copy = copy_node (exp);