Re: Is this a bug in my code or the compiler?

[Georg Bauhaus <bauhaus@futureapps.invalid>]

On 12.06.15 20:00, Dmitry A. Kazakov wrote:
> On Fri, 12 Jun 2015 19:25:00 +0200, G.B. wrote:
>
>> On 12.06.15 18:15, Dmitry A. Kazakov wrote:
>>> Foo (A) and Foo (A) -- Illegal
>>> Foo (A) and then Foo (A) -- Legal
>>
>> C has similar features...
>
> So?
>
>>> P.P.S. It would become even worse with fine-grained parallelism, as Georg
>>> keep on suggesting.
>>
>> Not sure to what this is referring
>
> Parallel evaluation of arguments.

Yes, but where is the difference, exactly, between incorrect due
to order dependence, and incorrect due to sharing issues? If
nothing is lost by forcing an order on evaluation of arguments
on all programs, then I don't know any more why that's not enforced
by languages, and why instead we saw Haskell.

>> So, in Ada 83, when A is of an access type,
>
> That does not change anything because:
>
>>      Foo (A) and Foo (A)  -- Legal
>
> Only if A is a constant access. Illegal otherwise.

Is there chapter and verse in the 83 LRM for this? I found this in 1.6:

"Whenever the reference manual specifies that different parts of a given
  construct are to be executed in some order that is not defined by the language,
  this means that the implementation is allowed to execute these parts
  in any given order, following the rules that result from that given order,
  but not in parallel. Furthermore, the construct is incorrect if execution
  of these parts in a different order would have a different effect.
  Compilers are not required to provide either compilation-time or run-time
  detection of incorrect order dependences."

(No mention of legality here.)

So, is GNAT buggy if it accepts this Ada 83 program (you claim that
it is *easy* to detect aliasing of A and B):

WITH Text_IO;
PROCEDURE Par IS
    TYPE I IS RANGE 1 .. 3;
    TYPE Ptr IS ACCESS I;
    A, B: Ptr;
    V, Legal : Boolean;
    
    FUNCTION Foo (X : Ptr) RETURN Boolean IS SEPARATE;
    
    PACKAGE Boolean_Io IS NEW Text_IO.Enumeration_IO (Boolean);
BEGIN
    A := NEW I'(1);
    
    Boolean_Io.Get (V);

    IF V THEN
       B := A;
    ELSE
       B := NEW I'(3);
    END IF;
    
    Legal := Foo (A) AND Foo (B);  -- legal?

END Par;

>  parallelism is a can of worms.

... if designed without regard to parallel evaluation/execution.
That's a matter of course, isn't it?