Re: Large arrays passed to arithmetic operators overflows GNAT stack

[Jeffrey Creem <jeff@thecreems.com>]

On 12/4/2010 1:32 AM, Jerry wrote:
> For what it's worth, passing large numerical arrays to the arithmetic
> operators in GNAT can cause the stack to overflow (segfault) even when
> the arrays are allocated from the heap. I suppose that indicates that
> they are being copied rather than being passed by reference.
>

In general, GNAT (and most other compilers) don't copy arguments like 
large arrays on the parameters to subprograms. The problem here is 
almost certainly in the return value associated with the subtraction. I 
am not sure I'd say it is impossible but I don't think I have seen any 
Ada implementation that can avoid the creation of the temporary based on 
the internally defined local variable that is generally required to 
construct code the returns an array.

Even if certain cases could be found by the optimizer and made to work, 
there are all sorts of cases where users would end up being surprised 
when temporaries had to be created.

In cases where array slices, assignment and the math involved 'destroy' 
the future values as the current values are being read, the compiler 
would have no choice (given the semantics of the operator) but to 
introduce some temporaries and it would be quite a feat for a compiler 
to figure out how much of a mini-slice temp it would need.

I really think it is a shame that Generic_Real_Arrays was defined the 
way that it was as the pretty code one gets when being able to use infix 
notation is nice but the overhead involved in the resulting copies 
renders the operators useless for all but the smallest of array vectors.