Re: Legit Warnings or not

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Thu, 28 Jul 2011 10:22:28 -0400, Robert A Duff wrote:
>
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>> 
>>> On Wed, 27 Jul 2011 19:37:55 -0500, Randy Brukardt wrote:
>> 
>>>> All of the other things are high-level concepts which work the same whether 
>>>> or not the objects are contiguous. ":=" and "=" are defined in terms of the 
>>>> subcomponents,
>>>
>>> which is ambiguous when components are referential. Does ":=" copy the
>>> reference or the target object?
>> 
>> There's no ambiguity.  "X := Y;" copies all components of Y.
>> If the compiler chooses to implement some of those components
>> via some sort of indirection, then ":=" will need to do a deep copy,
>> in general.
>
> So the compiler is not allowed to do reference counting with cloning upon
> update?

Sure it is.  The compiler can do anything it likes, so long as the
external behavior obeys the RM.

That's the "as if" rule.  Which isn't really a rule -- more of a "meta
rule" which applies to all higher-level programming language
definitions, whether the language definition says so or not.  That's the
difference between an assembly language and a higher-level language --
the "as if" meta-rule doesn't apply to assembly languages.

So yes, the compiler can do the deep copy in a lazy fashion, as you
suggest.  There are lots of other things the compiler can do.  For
example:

    X : constant String := Func(...);
    Y : constant String := X;

The compiler can allocate X and Y (or parts of them) at the same
memory location.  And X'Address could equal Y'Address.

Without the "constant"s, it could still do that optimization, if
it can prove there are no modifications to X or Y.  Or, as you say,
if it detects such modifications at run time.

(But if they were aliased, then X'Access cannot equal Y'Access.)

>> The indirection must be invisible (except, as you mentioned, for
>> low-level stuff like 'Size and Unchecked_Conversion).
>
> I.e. it leaks.

Right.  Somebody famous said "all abstractions leak".
And chapter 13 is where you'll find a lot of leaks.
But that's OK, because the semantics of 'Size and U_D aren't
really nailed down anyway.  (Well, 'Size is nailed down for
scalar subtypes, but we're talking about cases where the compiler
might want to introduce extra levels of indirection.)

- Bob