[Ada] Ada2012: detecting dangerous order dependences

This patch implements AI05-144-2: detecting order dependences among actuals
in calls that appear in the same construct. The potentially dangerous cases
described in the AI are flagged as warnings for now, not as errors. The
detection of overlapping actuals in a simple call remains under control of
the debugging switch -gnatw.i, to minimize disruption to legacy code.
This AI complements AI05-143, on in-out parameters for functions, because it
is in the presence of such functions that dangerous order dependences arise.

Below is an example of the warnings generated by

     gcc -c -gnat12 -gnatw.i order.adb

---
Compiling: order.adb (source file time stamp: 2010-10-07 20:43:39)

     1. procedure Order is
     2.    function Change (X, Y : in out Integer) return integer;
     3.
     4.    function Change (X, Y : in out Integer) return integer is
     5.    begin
     6.       X := X * 2;
     7.       Y := Y * 4;
     8.       return X + Y;
     9.    end;
    10.
    11.    One : Integer := 10;
    12.    Two : Integer := 25;
    13.    Res : Integer;
    14.    Uno : Integer renames One;
    15.
    16.    Table : array (1..3) of integer := (10, 20, 30);
    17.    T1 : Integer renames Table (1);
    18.
    19.    procedure ND (X, Y : integer) is
    20.    begin
    21.       null;
    22.    end;
    23.
    24.    Var : Natural := 2;
    25. begin
    26.     Two := Change (One, Two);
    27.     Two := Change (One, One);
                           |
        >>> warning: writable actual overlaps with actual for "Y"

    28.     Two := Change (X => One, Y => Two);
    29.     Res := Change (One, Two) + Change (One, Two);
                           1    2
        >>> warning: result may differ if evaluated  after other actual in expression
        >>> warning: result may differ if evaluated  after other actual in expression

    30.     Two := Change (One, Order.Two);
    31.     One := Change (Table (1), Table (2));
    32.     One := Change (Table (1), Table (1));
                           |
        >>> warning: writable actual overlaps with actual for "Y"

    33.     ND (Change (One, Two), Change (Two, Res));
                             |
        >>> warning: result may differ if evaluated  after other actual in expression

    34.     Two := Change (Uno, One);
                           |
        >>> warning: writable actual overlaps with actual for "Y"

    35.     Res := Change (T1, Table (1));
                           |
        >>> warning: writable actual overlaps with actual for "Y"

    36.     if Change (T1, T1) > 10 then null; end if;
                       |
        >>> warning: writable actual overlaps with actual for "Y"

    37.
    38.    Table (Change (One, Two)) := Table (Change (One, Res));
                          |
        >>> warning: result may differ if evaluated  after other actual in expression

    39.    if Change (One, Two) + Change (Two, Res) > 10 then null; end if;
                           |
        >>> warning: result may differ if evaluated  after other actual in expression

    40.    if Change (One, Two) + Change (Two, Res) > 10
                           1                   2
        >>> warning: result may differ if evaluated  after other actual in expression
        >>> warning: result may differ if evaluated  after other actual in expression

    41.      or else Change (Res, Res) = -1  then null; end if;
                             |
        >>> warning: writable actual overlaps with actual for "Y"

    42. end;

 42 lines: No errors, 13 warnings

Tested on x86_64-pc-linux-gnu, committed on trunk

2010-10-25  Ed Schonberg  <schonberg@adacore.com>

	* sem_ch5.adb (Analyze_Assignment_Statement): Check dangerous order
	dependence.
	* sem_ch6.adb (Analyze_Procedure_Call_Statement): Ditto.
	* sem_res.adb (Analyze_Actuals): Add actual to list of actuals for
	current construct, for subsequent order dependence checking.
	(Resolve): Check order dependence on expressions that are not
	subexpressions.
	* sem_util.adb (Check_Order_Dependence): Code cleanup, to correspond
	to latest version of AI05-144-2.
	* sem_warn.adb (Warn_On_Overlapping_Actuals): Code cleanup.

[Ada] Ada2012: detecting dangerous order dependences

Commit Message

Comments

Patch