array-notation-common.c (find_rank): Use INDIRECT_REF_P.

	* array-notation-common.c (find_rank): Use INDIRECT_REF_P.
	* c-common.c (c_fully_fold_internal): Likewise.
	(c_alignof_expr): Likewise.
	* c-pretty-print.c (c_pretty_printer::postfix_expression): Likewise.
	* c-ubsan.c (ubsan_instrument_bounds): Likewise.
	* cilk.c (create_parm_list): Likewise.

	* c-array-notation.c (fix_builtin_array_notation_fn): Use
	INDIRECT_REF_P.
	* c-typeck.c (array_to_pointer_conversion): Likewise.
	(build_unary_op): Likewise.
	(c_finish_return): Likewise.

From-SVN: r225080

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index fc88354937dcc283e02b64a68c722caf404aca47..512af7c9673d52ca8b053561d286dc72d5010649 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,12 @@
+2015-06-26  Marek Polacek  <polacek@redhat.com>
+
+       * array-notation-common.c (find_rank): Use INDIRECT_REF_P.
+       * c-common.c (c_fully_fold_internal): Likewise.
+       (c_alignof_expr): Likewise.
+       * c-pretty-print.c (c_pretty_printer::postfix_expression): Likewise.
+       * c-ubsan.c (ubsan_instrument_bounds): Likewise.
+       * cilk.c (create_parm_list): Likewise. 
+
 2015-06-26  Marek Polacek  <polacek@redhat.com>
 
        * c-common.c (handle_unused_attribute): Use VAR_OR_FUNCTION_DECL_P.

diff --git a/gcc/c-family/array-notation-common.c b/gcc/c-family/array-notation-common.c
index f517424f59c1b24123d55036452788e2a610cb77..f75936ad8527731c9b61035066d248219d560935 100644 (file)
--- a/gcc/c-family/array-notation-common.c
+++ b/gcc/c-family/array-notation-common.c
@@ -228,7 +228,7 @@ find_rank (location_t loc, tree orig_expr, tree expr, bool ignore_builtin_fn,
              ii_tree = ARRAY_NOTATION_ARRAY (ii_tree);
            }
          else if (handled_component_p (ii_tree)
-                  || TREE_CODE (ii_tree) == INDIRECT_REF)
+                  || INDIRECT_REF_P (ii_tree))
            ii_tree = TREE_OPERAND (ii_tree, 0);
          else if (TREE_CODE (ii_tree) == PARM_DECL
                   || VAR_P (ii_tree))

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index b11a7563dc1e9473f42e9972e4591a4d1d335f86..5cc65ec84d82bf016c086904db0e0d9bc06f567b 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -1436,7 +1436,7 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
       if (op0 != orig_op0
          && code == ADDR_EXPR
          && (op1 = get_base_address (op0)) != NULL_TREE
-         && TREE_CODE (op1) == INDIRECT_REF
+         && INDIRECT_REF_P (op1)
          && TREE_CONSTANT (TREE_OPERAND (op1, 0)))
        ret = fold_convert_loc (loc, TREE_TYPE (expr), fold_offsetof_1 (op0));
       else if (op0 != orig_op0 || in_init)
@@ -1447,7 +1447,7 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
        ret = fold (expr);
       if (code == INDIRECT_REF
          && ret != expr
-         && TREE_CODE (ret) == INDIRECT_REF)
+         && INDIRECT_REF_P (ret))
        {
          TREE_READONLY (ret) = TREE_READONLY (expr);
          TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
@@ -5377,7 +5377,7 @@ c_alignof_expr (location_t loc, tree expr)
           && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
 
-  else if (TREE_CODE (expr) == INDIRECT_REF)
+  else if (INDIRECT_REF_P (expr))
     {
       tree t = TREE_OPERAND (expr, 0);
       tree best = t;

diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c
index a65ff3356a6d9bf4a80cfb0bd03aeab056dcf989..4be1d4f332f6944357a31bacd6858f44a0ef56bd 100644 (file)
--- a/gcc/c-family/c-pretty-print.c
+++ b/gcc/c-family/c-pretty-print.c
@@ -1607,7 +1607,7 @@ c_pretty_printer::postfix_expression (tree e)
     case COMPONENT_REF:
       {
        tree object = TREE_OPERAND (e, 0);
-       if (TREE_CODE (object) == INDIRECT_REF)
+       if (INDIRECT_REF_P (object))
          {
            postfix_expression (TREE_OPERAND (object, 0));
            pp_c_arrow (this);

diff --git a/gcc/c-family/c-ubsan.c b/gcc/c-family/c-ubsan.c
index 10524d2acd156a0a0c258cf27a8751a4ad22a650..5a95236f003db699e46101f7656997ab26b0fe22 100644 (file)
--- a/gcc/c-family/c-ubsan.c
+++ b/gcc/c-family/c-ubsan.c
@@ -290,8 +290,7 @@ ubsan_instrument_bounds (location_t loc, tree array, tree *index,
   tree base = get_base_address (array);
   if ((flag_sanitize & SANITIZE_BOUNDS_STRICT) == 0
       && TREE_CODE (array) == COMPONENT_REF
-      && base && (TREE_CODE (base) == INDIRECT_REF
-                 || TREE_CODE (base) == MEM_REF))
+      && base && (INDIRECT_REF_P (base) || TREE_CODE (base) == MEM_REF))
     {
       tree next = NULL_TREE;
       tree cref = array;

diff --git a/gcc/c-family/cilk.c b/gcc/c-family/cilk.c
index c6ca288cc73e854539b7fcd9d5a97000c73a24e8..4f8026fdb443917f6920d0292bfbdd3870000318 100644 (file)
--- a/gcc/c-family/cilk.c
+++ b/gcc/c-family/cilk.c
@@ -392,7 +392,7 @@ create_parm_list (struct wrapper_data *wd, tree *val0, tree arg)
 
       val = TREE_OPERAND (val, 0);
       *val0 = val;
-      gcc_assert (TREE_CODE (val) == INDIRECT_REF);
+      gcc_assert (INDIRECT_REF_P (val));
       parm = TREE_OPERAND (val, 0);
       STRIP_NOPS (parm);
     }

diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 4f89f8f030fa97e27215725fb0ad596bad47e206..f6829024f38b1071a3c496537c622a628f3cdec8 100644 (file)
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,11 @@
+2015-06-26  Marek Polacek  <polacek@redhat.com>
+
+       * c-array-notation.c (fix_builtin_array_notation_fn): Use
+       INDIRECT_REF_P.
+       * c-typeck.c (array_to_pointer_conversion): Likewise.
+       (build_unary_op): Likewise.
+       (c_finish_return): Likewise.
+
 2015-06-25  Andrew MacLeod  <amacleod@redhat.com>
 
        * c-decl.c: Remove ipa-ref.h and plugin-api.h from include list.

diff --git a/gcc/c/c-array-notation.c b/gcc/c/c-array-notation.c
index 029246883361832085a02e15a03411ddf84b5e16..e6a1539cda951c8c3e6f30371437dc9af5ac1235 100644 (file)
--- a/gcc/c/c-array-notation.c
+++ b/gcc/c/c-array-notation.c
@@ -324,7 +324,7 @@ fix_builtin_array_notation_fn (tree an_builtin_fn, tree *new_var)
     array_ind_value = build_decl (location, VAR_DECL, NULL_TREE, 
                                  TREE_TYPE (func_parm));
   array_op0 = (*array_operand)[0];
-  if (TREE_CODE (array_op0) == INDIRECT_REF)
+  if (INDIRECT_REF_P (array_op0))
     array_op0 = TREE_OPERAND (array_op0, 0);
   switch (an_type)
     {

diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 9caf028b0b1490b6dd9b7997eb3158d2e9de3f06..60d6ed85ba3c30554094140e2d88d4a359c9b7c6 100644 (file)
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -1826,7 +1826,7 @@ array_to_pointer_conversion (location_t loc, tree exp)
 
   ptrtype = build_pointer_type (restype);
 
-  if (TREE_CODE (exp) == INDIRECT_REF)
+  if (INDIRECT_REF_P (exp))
     return convert (ptrtype, TREE_OPERAND (exp, 0));
 
   /* In C++ array compound literals are temporary objects unless they are
@@ -4146,12 +4146,11 @@ build_unary_op (location_t location,
         unary '*' operator.  */
       if (VOID_TYPE_P (TREE_TYPE (arg))
          && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
-         && (TREE_CODE (arg) != INDIRECT_REF
-             || !flag_isoc99))
+         && (!INDIRECT_REF_P (arg) || !flag_isoc99))
        pedwarn (location, 0, "taking address of expression of type %<void%>");
 
       /* Let &* cancel out to simplify resulting code.  */
-      if (TREE_CODE (arg) == INDIRECT_REF)
+      if (INDIRECT_REF_P (arg))
        {
          /* Don't let this be an lvalue.  */
          if (lvalue_p (TREE_OPERAND (arg, 0)))
@@ -4220,7 +4219,7 @@ build_unary_op (location_t location,
       /* ??? Cope with user tricks that amount to offsetof.  Delete this
         when we have proper support for integer constant expressions.  */
       val = get_base_address (arg);
-      if (val && TREE_CODE (val) == INDIRECT_REF
+      if (val && INDIRECT_REF_P (val)
           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
        {
          ret = fold_convert_loc (location, argtype, fold_offsetof_1 (arg));
@@ -9465,7 +9464,7 @@ c_finish_return (location_t loc, tree retval, tree origtype)
              inner = TREE_OPERAND (inner, 0);
 
              while (REFERENCE_CLASS_P (inner)
-                    && TREE_CODE (inner) != INDIRECT_REF)
+                    && !INDIRECT_REF_P (inner))
                inner = TREE_OPERAND (inner, 0);
 
              if (DECL_P (inner)