[Ada] Get rid of useless temporary for slice in overaligned record type
authorEric Botcazou <ebotcazou@adacore.com>
Thu, 19 Sep 2019 08:14:47 +0000 (08:14 +0000)
committerPierre-Marie de Rodat <pmderodat@gcc.gnu.org>
Thu, 19 Sep 2019 08:14:47 +0000 (08:14 +0000)
This fixes a recent code quality regression for targets that do not
require the strict alignment of memory accesses: the compiler would
generate a useless temporary for a slice of an array component in an
overaligned record type.

Running these commands:

  gcc -c p.adb -gnatws -gnatD
  grep loop p.adb.dg

On the following sources:

procedure P (N : Positive) is

  type Rec1 is record
    I : Integer;
  end record;

  type Arr is array (Positive range <>) of Rec1;

  type Rec2 is record
    A : Arr (1 .. 128);
  end record;
  for Rec2'Alignment use 8;

  procedure Proc (A : Arr) is
  begin
    null;
  end;

  R : Rec2;

begin
  Proc (R.A (1 .. N));
end;

Should execute silently.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_util.adb (Is_Possibly_Unaligned_Slice): Do not return true
on pure alignment considerations if the target does not require
the strict alignment of memory accesses.

From-SVN: r275956

gcc/ada/ChangeLog
gcc/ada/exp_util.adb

index 8a872741945c4ddd926273745364b2a0bc870c6e..58080084938180880c30c0f13957bcb5d6b070fc 100644 (file)
@@ -1,3 +1,9 @@
+2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * exp_util.adb (Is_Possibly_Unaligned_Slice): Do not return true
+       on pure alignment considerations if the target does not require
+       the strict alignment of memory accesses.
+
 2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>
 
        * sem_ch12.adb (Check_Private_View): Add a comment to indicate
index 905e3f4ddea5c22b202bcb56a81e09c67a2f2c4b..6306320c0cd86885fd17d3d697f9ef5e7158a068 100644 (file)
@@ -8692,9 +8692,11 @@ package body Exp_Util is
                --  We are definitely in trouble if the record in question
                --  has an alignment, and either we know this alignment is
                --  inconsistent with the alignment of the slice, or we don't
-               --  know what the alignment of the slice should be.
+               --  know what the alignment of the slice should be. But this
+               --  really matters only if the target has strict alignment.
 
-               if Known_Alignment (Ptyp)
+               if Target_Strict_Alignment
+                 and then Known_Alignment (Ptyp)
                  and then (Unknown_Alignment (Styp)
                             or else Alignment (Styp) > Alignment (Ptyp))
                then