From: Eric Botcazou <ebotcazou@adacore.com>
Date: Thu, 19 Sep 2019 08:14:47 +0000 (+0000)
Subject: [Ada] Get rid of useless temporary for slice in overaligned record type
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=c3a75a09b8424c192b32a39fa273d27db5b9c039;p=gcc.git

[Ada] Get rid of useless temporary for slice in overaligned record type

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
---

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 8a872741945..58080084938 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -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
diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb
index 905e3f4ddea..6306320c0cd 100644
--- a/gcc/ada/exp_util.adb
+++ b/gcc/ada/exp_util.adb
@@ -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