a-clrefi.adb, [...]: New files

[gcc.git] / gcc / gimplify.c

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 805c3020272323babd0b1086afb6b1553fef28e2..e73e00ae9ae959eafd11ee571b0b256600dc83dd 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -5308,7 +5308,8 @@ gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
      floating point.  This allows the atomic operation to properly 
      succeed even with NaNs and -0.0.  */
   x = build3 (COND_EXPR, void_type_node,
-             build2 (NE_EXPR, boolean_type_node, oldival, oldival2),
+             build2 (NE_EXPR, boolean_type_node,
+                     fold_convert (itype, oldival), oldival2),
              build1 (GOTO_EXPR, void_type_node, label), NULL);
   gimplify_and_add (x, pre_p);
 
@@ -5881,7 +5882,24 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
             {
                *expr_p = build_fold_addr_expr_with_type (tmp,
                                                         TREE_TYPE (*expr_p));
-               break;
+              break;
+            }
+         /* Convert (void *)&a + 4 into (void *)&a[1].  */
+         if (POINTER_TYPE_P (TREE_TYPE (*expr_p))
+             && TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
+             && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
+             && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
+                                                                       0),0)))
+             && (tmp = maybe_fold_offset_to_reference
+                        (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
+                         TREE_OPERAND (*expr_p, 1),
+                         TREE_TYPE (TREE_TYPE
+                                 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
+                                                0))))))
+            {
+               tmp = build_fold_addr_expr (tmp);
+               *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
+              break;
             }
           /* FALLTHRU */
        default: