llvm dev - Jul 2015 - [LLVMdev] C as used/implemented in practice: analysis of responses

On 07/02/2015 05:43 PM, David Keaton wrote:
> On 07/02/2015 05:30 PM, Philip Reames wrote:
>>
>>
>> On 07/02/2015 04:44 PM, David Keaton wrote:
>>> On 07/02/2015 03:17 AM, Kuperstein, Michael M wrote:
>>>> You want to redefine ["won't break the program"],
by specifying a new
>>>> abstract machine, which is
>>>> more conservative than standard C/C++. The proper way to do
that
>>>> would,
>>>> I believe, be to work towards setting up a working group within
the
>>>> relevant committees, and come up with a uniformly accepted
definition
>>>> for this abstract machine, which could then be implemented
(assuming
>>>> there is, indeed, wide enough agreement in the implementer
community –
>>>> something that does not look at all likely) by next-generation
>>>> compilers.
>>>
>>>      This work has already been done in Annex L of the C standard,
>>> which provides an optional stricter abstract machine.  As far as I
>>> know, no implementations have attempted to support Annex L yet.
>> Do you have a link to the relevant text?  I've never heard of this,
and
>> a quick google search doesn't turn up anything relevant. Wikipedia
knows
>> about a set of "analyzability features", but that doesn't
sounds like
>> what you're talking about?
>
>      The relevant text is inside the standard, which is for sale. The 
> cheapest source I know about is this.
>
>
http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS%2fISO%2fIEC+9899%3a2011%5b2012%5d
>
I found a draft version which appears to have been
complete.
>
>      The title of Annex L is Analyzability, because that was the 
> purpose, but the effect was to define a stricter abstract machine in 
> which there were no unbounded undefined behaviors except what was 
> absolutely necessary.  That does not address every question in the 
> questionnaire, but it is a good start, and it has already been 
> standardized so there is something concrete to implement.
IMHO, the Annex completely fails to be useful for the purpose you 
intend.  The definition of "bounded undefined behavior" is phrased in 
terms of "may", not "must".  The wording doesn't appear
to require a
choice from the list; it merely states some possible implementations.  
Unless I'm reading it wrong, the only real restriction is against out of 
bounds stores.  On the surface, it doesn't even seem to prevent out of 
bounds stores in the program being exposed by a transformation.  It only 
prevents an out of bounds store in the undefined operation itself.  That 
really doesn't get you much of anything.

Consider:
y is positive
a = x + y (signed overflow, wrapping "expected")
if (a >= x)
   store out of bounds
===>
store out of bounds

Philip



Philip

On 07/02/2015 08:51 PM, Philip Reames wrote:
>>      The title of Annex L is Analyzability, because that was the
>> purpose, but the effect was to define a stricter abstract machine in
>> which there were no unbounded undefined behaviors except what was
>> absolutely necessary.  That does not address every question in the
>> questionnaire, but it is a good start, and it has already been
>> standardized so there is something concrete to implement.
> IMHO, the Annex completely fails to be useful for the purpose you
> intend.  The definition of "bounded undefined behavior" is
phrased in
> terms of "may", not "must".  The wording doesn't
appear to require a
> choice from the list; it merely states some possible implementations.
> Unless I'm reading it wrong, the only real restriction is against out
of
> bounds stores.  On the surface, it doesn't even seem to prevent out of
> bounds stores in the program being exposed by a transformation.  It only
> prevents an out of bounds store in the undefined operation itself.  That
> really doesn't get you much of anything.
      The word "may" does not appear in Annex L.  There are some 
nonnormative notes that indicate some things that might happen if the 
normative text is followed.  The annex specifies that most undefined 
behavior "shall" be limited to bounded undefined behavior.

      The implications are nuanced.  An implementation that conforms to 
Annex L is prevented from performing some optimizations because it must 
ensure that no out-of-bounds store would be created out of bounded 
undefined behavior.  In other words, in the general case, it can no 
longer make the assumption that bounded undefined behavior does not occur.
> Consider:
> y is positive
> a = x + y (signed overflow, wrapping "expected")
> if (a >= x)
>    store out of bounds
> ===>
> store out of bounds
      Right.  This is not prevented because the programmer has specified 
an out-of-bounds store.  However, if the programmer had not done so, the 
implementation would be prevented from making a transformation that 
results in an out-of-bounds store.

					David

On 3 July 2015 at 05:17, David Keaton <dmk at dmk.com>
wrote:
>> Consider:
>> y is positive
>> a = x + y (signed overflow, wrapping "expected")
>> if (a >= x)
>>    store out of bounds
>> ===>
>> store out of bounds
>
>
>      Right.  This is not prevented because the programmer has specified an
> out-of-bounds store.  However, if the programmer had not done so, the
> implementation would be prevented from making a transformation that results
> in an out-of-bounds store.
As is most of the original questions that had any traction. All
related to odd pointer handling (position, arithmetic, representation,
lifetime, etc), which all (?) end up as critical undefined behaviour.

cheers,
--renato