[gcc r15-9244] Ada: Fix wrong 'Access to aliased constrained array of controlled type

[Eric Botcazou via Gcc-cvs]

https://gcc.gnu.org/g:f085dbf97ed4445830127c955909ff2b887ded69

commit r15-9244-gf085dbf97ed4445830127c955909ff2b887ded69
Author: Eric Botcazou <ebotca...@adacore.com>
Date:   Mon Apr 7 10:33:52 2025 +0200

    Ada: Fix wrong 'Access to aliased constrained array of controlled type
    
    For technical reasons, the recently reimplemented finalization machinery
    for controlled types requires arrays of controlled types to be allocated
    with their bounds, including in the case where their nominal subtype is
    constrained.  However, in this case, the type of 'Access for the arrays
    is pointer-to-constrained-array and, therefore, its value must designate
    the array itself and not the bounds.
    
    gcc/ada/
            * gcc-interface/utils.cc (convert) <POINTER_TYPE>: Use fold_convert
            to convert between thin pointers.  If the source is a thin pointer
            with zero offset from the base and the target is a pointer to its
            array, displace the pointer after converting it.
            * gcc-interface/utils2.cc (build_unary_op) <ATTR_ADDR_EXPR>: Use
            fold_convert to convert the address before displacing it.

Diff:
---
 gcc/ada/gcc-interface/utils.cc  | 17 ++++++++++++++++-
 gcc/ada/gcc-interface/utils2.cc | 11 ++++++-----
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/gcc/ada/gcc-interface/utils.cc b/gcc/ada/gcc-interface/utils.cc
index 1448716acc5a..9212827aecfe 100644
--- a/gcc/ada/gcc-interface/utils.cc
+++ b/gcc/ada/gcc-interface/utils.cc
@@ -5259,7 +5259,7 @@ convert (tree type, tree expr)
              : size_zero_node;
          tree byte_diff = size_diffop (type_pos, etype_pos);
 
-         expr = build1 (NOP_EXPR, type, expr);
+         expr = fold_convert (type, expr);
          if (integer_zerop (byte_diff))
            return expr;
 
@@ -5267,6 +5267,21 @@ convert (tree type, tree expr)
                                  fold_convert (sizetype, byte_diff));
        }
 
+      /* If converting from a thin pointer with zero offset from the base to
+        a pointer to the array, add the offset of the array field.  */
+      if (TYPE_IS_THIN_POINTER_P (etype)
+         && !TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (etype)))
+       {
+         tree arr_field = DECL_CHAIN (TYPE_FIELDS (TREE_TYPE (etype)));
+
+         if (TREE_TYPE (type) == TREE_TYPE (arr_field))
+           {
+             expr = fold_convert (type, expr);
+             return build_binary_op (POINTER_PLUS_EXPR, type, expr,
+                                     byte_position (arr_field));
+           }
+       }
+
       /* If converting fat pointer to normal or thin pointer, get the pointer
         to the array and then convert it.  */
       if (TYPE_IS_FAT_POINTER_P (etype))
diff --git a/gcc/ada/gcc-interface/utils2.cc b/gcc/ada/gcc-interface/utils2.cc
index 99e592781f5e..58418ea7236b 100644
--- a/gcc/ada/gcc-interface/utils2.cc
+++ b/gcc/ada/gcc-interface/utils2.cc
@@ -1628,11 +1628,12 @@ build_unary_op (enum tree_code op_code, tree 
result_type, tree operand)
                = size_binop (PLUS_EXPR, offset,
                              size_int (bits_to_bytes_round_down (bitpos)));
 
-             /* Take the address of INNER, convert it to a pointer to our type
-                and add the offset.  */
-             inner = build_unary_op (ADDR_EXPR,
-                                     build_pointer_type (TREE_TYPE (operand)),
-                                     inner);
+             /* Take the address of INNER, formally convert it to a pointer
+                to the operand type, and finally add the offset.  */
+             inner = build_unary_op (ADDR_EXPR, NULL_TREE, inner);
+             inner
+               = fold_convert (build_pointer_type (TREE_TYPE (operand)),
+                               inner);
              result = build_binary_op (POINTER_PLUS_EXPR, TREE_TYPE (inner),
                                        inner, offset);
              break;