PR target/23552

[pf3gnuchains/gcc-fork.git] / gcc / tree.c

diff --git a/gcc/tree.c b/gcc/tree.c
index 770ed31..9c4b29c 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -488,7 +488,7 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
 
     case tcc_type:
       TYPE_UID (t) = next_type_uid++;
-      TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
+      TYPE_ALIGN (t) = BITS_PER_UNIT;
       TYPE_USER_ALIGN (t) = 0;
       TYPE_MAIN_VARIANT (t) = t;
 
@@ -883,7 +883,7 @@ cst_and_fits_in_hwi (tree x)
 }
 
 /* Return a new VECTOR_CST node whose type is TYPE and whose values
-   are in a list pointed by VALS.  */
+   are in a list pointed to by VALS.  */
 
 tree
 build_vector (tree type, tree vals)
@@ -926,7 +926,7 @@ build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
 }
 
 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
-   are in the VEC pointed by VALS.  */
+   are in the VEC pointed to by VALS.  */
 tree
 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
 {
@@ -1053,6 +1053,8 @@ build_string (int len, const char *str)
 
   memset (s, 0, sizeof (struct tree_common));
   TREE_SET_CODE (s, STRING_CST);
+  TREE_CONSTANT (s) = 1;
+  TREE_INVARIANT (s) = 1;
   TREE_STRING_LENGTH (s) = len;
   memcpy ((char *) TREE_STRING_POINTER (s), str, len);
   ((char *) TREE_STRING_POINTER (s))[len] = '\0';
@@ -2056,6 +2058,9 @@ contains_placeholder_p (tree exp)
                  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
                  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
 
+       case CALL_EXPR:
+         return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
+
        default:
          break;
        }
@@ -2175,7 +2180,7 @@ tree
 substitute_in_expr (tree exp, tree f, tree r)
 {
   enum tree_code code = TREE_CODE (exp);
-  tree op0, op1, op2;
+  tree op0, op1, op2, op3;
   tree new;
   tree inner;
 
@@ -2260,6 +2265,20 @@ substitute_in_expr (tree exp, tree f, tree r)
            new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
            break;
 
+         case 4:
+           op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
+           op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
+           op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
+           op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
+
+           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
+               && op2 == TREE_OPERAND (exp, 2)
+               && op3 == TREE_OPERAND (exp, 3))
+             return exp;
+
+           new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
+           break;
+
          default:
            gcc_unreachable ();
          }
@@ -3111,9 +3130,9 @@ annotate_with_file_line (tree node, const char *file, int line)
      a node with the same information already attached to that node!
      Just return instead of wasting memory.  */
   if (EXPR_LOCUS (node)
+      && EXPR_LINENO (node) == line
       && (EXPR_FILENAME (node) == file
-         || ! strcmp (EXPR_FILENAME (node), file))
-      && EXPR_LINENO (node) == line)
+         || !strcmp (EXPR_FILENAME (node), file)))
     {
       last_annotated_node = node;
       return;
@@ -3124,9 +3143,9 @@ annotate_with_file_line (tree node, const char *file, int line)
      than half.  */
   if (last_annotated_node
       && EXPR_LOCUS (last_annotated_node)
+      && EXPR_LINENO (last_annotated_node) == line
       && (EXPR_FILENAME (last_annotated_node) == file
-         || ! strcmp (EXPR_FILENAME (last_annotated_node), file))
-      && EXPR_LINENO (last_annotated_node) == line)
+         || !strcmp (EXPR_FILENAME (last_annotated_node), file)))
     {
       SET_EXPR_LOCUS (node, EXPR_LOCUS (last_annotated_node));
       return;
@@ -4242,7 +4261,7 @@ tree_int_cst_compare (tree t1, tree t2)
 
 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
    the host.  If POS is zero, the value can be represented in a single
-   HOST_WIDE_INT.  If POS is nonzero, the value must be positive and can
+   HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
    be represented in a single unsigned HOST_WIDE_INT.  */
 
 int
@@ -4260,7 +4279,7 @@ host_integerp (tree t, int pos)
 
 /* Return the HOST_WIDE_INT least significant bits of T if it is an
    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
-   be positive.  We must be able to satisfy the above conditions.  */
+   be non-negative.  We must be able to satisfy the above conditions.  */
 
 HOST_WIDE_INT
 tree_low_cst (tree t, int pos)
@@ -4684,6 +4703,9 @@ build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
 {
   tree t;
 
+  if (to_type == error_mark_node)
+    return error_mark_node;
+
   /* In some cases, languages will have things that aren't a POINTER_TYPE
      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
      In that case, return that type without regard to the rest of our