Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > sequence points and evaluation order

Reply
Thread Tools

sequence points and evaluation order

 
 
John Smith
Guest
Posts: n/a
 
      09-04-2006
I've been playing with splint, which returns the following
warning for the code below:

statlib.c: (in function log_norm_pdf)
statlib.c(1054,31): Expression has undefined behavior (left
operand uses errno,
modified by right operand): (log(x) - mu) * (log(x) - mu)
Code has unspecified behavior. Order of evaluation of function
parameters or
subexpressions is not defined, so if a value is used and
modified in
different places not separated by a sequence point
constraining evaluation
order, then the result of the expression is unspecified.

How can the offending expression be written so that the order of
evaluation is properly specified? Can t2num be assigned the value
of any single expression equivalent to ((log(x)-mu) ^ 2) * -1.0?


/* Return log normal probability density at x.
mu=a_mean(ln(X)); sigma=s_stdev(ln(X)) (output OK) */
double log_norm_pdf(double x, double mu, double sigma)
{
double t1, t2num, t2den;

if(x <= 0.0) return 0.0;

t1 = 1.0 / (sqrt(2.0 * PI) * sigma * x);
t2num = -((log(x) - mu) * (log(x) - mu)); /* problem here */
t2den = (2.0 * (sigma * sigma));

return t1 * exp(t2num / t2den);
}

BTW: this function has been rigorously tested.
 
Reply With Quote
 
 
 
 
Spiros Bousbouras
Guest
Posts: n/a
 
      09-04-2006
John Smith wrote:

> I've been playing with splint, which returns the following
> warning for the code below:
>
> statlib.c: (in function log_norm_pdf)
> statlib.c(1054,31): Expression has undefined behavior (left
> operand uses errno,
> modified by right operand): (log(x) - mu) * (log(x) - mu)
> Code has unspecified behavior. Order of evaluation of function
> parameters or
> subexpressions is not defined, so if a value is used and
> modified in
> different places not separated by a sequence point
> constraining evaluation
> order, then the result of the expression is unspecified.


I'm a bit puzzled by this.
Is it unspecified or undefined ? And why is it either ?
When it says "operand uses errno" does it mean reads
the value of errno or it means reads or writes the value
of errno ?

>
> How can the offending expression be written so that the order of
> evaluation is properly specified? Can t2num be assigned the value
> of any single expression equivalent to ((log(x)-mu) ^ 2) * -1.0?
>
>
> /* Return log normal probability density at x.
> mu=a_mean(ln(X)); sigma=s_stdev(ln(X)) (output OK) */
> double log_norm_pdf(double x, double mu, double sigma)
> {
> double t1, t2num, t2den;
>
> if(x <= 0.0) return 0.0;
>
> t1 = 1.0 / (sqrt(2.0 * PI) * sigma * x);
> t2num = -((log(x) - mu) * (log(x) - mu)); /* problem here */


You can write this as
t2num = -( a = log(x) - mu , a * a) ;
Obviously a needs to be defined.
You can even write
{ double a ;
t2num = -( a = log(x) - mu , a * a) ;
}
to let the compiler know that the value of a
won't be needed anymore. Perhaps it will
affect optimization.

> t2den = (2.0 * (sigma * sigma));
>
> return t1 * exp(t2num / t2den);
> }
>
> BTW: this function has been rigorously tested.


 
Reply With Quote
 
 
 
 
Robert Gamble
Guest
Posts: n/a
 
      09-04-2006
John Smith wrote:
> I've been playing with splint, which returns the following
> warning for the code below:
>
> statlib.c: (in function log_norm_pdf)
> statlib.c(1054,31): Expression has undefined behavior (left
> operand uses errno,
> modified by right operand): (log(x) - mu) * (log(x) - mu)
> Code has unspecified behavior. Order of evaluation of function
> parameters or
> subexpressions is not defined, so if a value is used and
> modified in
> different places not separated by a sequence point
> constraining evaluation
> order, then the result of the expression is unspecified.
>
> How can the offending expression be written so that the order of
> evaluation is properly specified? Can t2num be assigned the value
> of any single expression equivalent to ((log(x)-mu) ^ 2) * -1.0?
>
>
> /* Return log normal probability density at x.
> mu=a_mean(ln(X)); sigma=s_stdev(ln(X)) (output OK) */
> double log_norm_pdf(double x, double mu, double sigma)
> {
> double t1, t2num, t2den;
>
> if(x <= 0.0) return 0.0;
>
> t1 = 1.0 / (sqrt(2.0 * PI) * sigma * x);
> t2num = -((log(x) - mu) * (log(x) - mu)); /* problem here */


What splint is trying to tell you is that the value of errno is
dependent on the order of evaluation of the 2 function calls. There is
no undefined behavior here (there is a sequence point between any
possible modifications to errno) and since you are not using errno
there isn't anything to worry about. You could use the value of errno,
it's value is not indeterminate, but you just can't be sure which call
to log() is the one that set the current value of errno. If you want
to get rid of the splint message you could store the value of "log(x) -
mu" in a temporary variable and do the multiplication seperately
although you might incur a precision hit. Your best bet is probably to
disable the warning inline for this particular case:

/* @-evalorder@ */
t2num = -((log(x) - mu) * (log(x) - mu)); /* problem here */
/* @+evalorder@ */

Robert Gamble

 
Reply With Quote
 
Flash Gordon
Guest
Posts: n/a
 
      09-04-2006
Spiros Bousbouras wrote:
> John Smith wrote:
>
>> I've been playing with splint, which returns the following
>> warning for the code below:
>>
>> statlib.c: (in function log_norm_pdf)
>> statlib.c(1054,31): Expression has undefined behavior (left
>> operand uses errno,
>> modified by right operand): (log(x) - mu) * (log(x) - mu)
>> Code has unspecified behavior. Order of evaluation of function
>> parameters or
>> subexpressions is not defined, so if a value is used and
>> modified in
>> different places not separated by a sequence point
>> constraining evaluation
>> order, then the result of the expression is unspecified.

>
> I'm a bit puzzled by this.
> Is it unspecified or undefined ? And why is it either ?
> When it says "operand uses errno" does it mean reads
> the value of errno or it means reads or writes the value
> of errno ?


The order of the two function calls is unspecified, but IIRC there is a
sequence point on calling a function, and the two calls are not
permitted to be run in parallel, so I can't see any undefined behaviour.
If either call sets errno it is guaranteed that errno will be set to a
non-0 value (standard functions do not set it to 0) so the code can
still test errno to see if an error has occurred and what at least one
error was. So I really don't see a problem.

>> How can the offending expression be written so that the order of
>> evaluation is properly specified? Can t2num be assigned the value
>> of any single expression equivalent to ((log(x)-mu) ^ 2) * -1.0?
>>
>>
>> /* Return log normal probability density at x.
>> mu=a_mean(ln(X)); sigma=s_stdev(ln(X)) (output OK) */
>> double log_norm_pdf(double x, double mu, double sigma)
>> {
>> double t1, t2num, t2den;
>>
>> if(x <= 0.0) return 0.0;
>>
>> t1 = 1.0 / (sqrt(2.0 * PI) * sigma * x);
>> t2num = -((log(x) - mu) * (log(x) - mu)); /* problem here */

>
> You can write this as
> t2num = -( a = log(x) - mu , a * a) ;
> Obviously a needs to be defined.
> You can even write
> { double a ;
> t2num = -( a = log(x) - mu , a * a) ;
> }
> to let the compiler know that the value of a
> won't be needed anymore. Perhaps it will
> affect optimization.


Personally I would do something more like
{
double a = log(x) - mu;
t2num -= a * a;
}

In my opinion this is easier to read. I don't see any benefit in using
the comma operator for this. Alternatively, of course, have it defined
earlier. I would consider calling log with the same value twice to be a
needless introduction of inefficiency and one that is less likely to be
fixed by the compiler than many.

For similar reasons I would probably #define ROOT_2PI

>> t2den = (2.0 * (sigma * sigma));


Needless bracketing which, in my opinion, does not make it easier to read.

>> return t1 * exp(t2num / t2den);


When assigning t1 I would not have used 1.0/whatever, instead I would
divide by t1 here.

>> }
>>
>> BTW: this function has been rigorously tested.


It may test OK but it would not have got through a code review with me
without changes or *very* good technical explanations of why they should
not be made.
--
Flash Gordon
 
Reply With Quote
 
Keith Thompson
Guest
Posts: n/a
 
      09-04-2006
Flash Gordon <(E-Mail Removed)> writes:
> Spiros Bousbouras wrote:
>> John Smith wrote:
>>
>>> I've been playing with splint, which returns the following
>>> warning for the code below:
>>>
>>> statlib.c: (in function log_norm_pdf)
>>> statlib.c(1054,31): Expression has undefined behavior (left
>>> operand uses errno,
>>> modified by right operand): (log(x) - mu) * (log(x) - mu)
>>> Code has unspecified behavior. Order of evaluation of function
>>> parameters or
>>> subexpressions is not defined, so if a value is used and
>>> modified in
>>> different places not separated by a sequence point
>>> constraining evaluation
>>> order, then the result of the expression is unspecified.

>> I'm a bit puzzled by this.
>> Is it unspecified or undefined ? And why is it either ?
>> When it says "operand uses errno" does it mean reads
>> the value of errno or it means reads or writes the value
>> of errno ?

>
> The order of the two function calls is unspecified, but IIRC there is
> a sequence point on calling a function, and the two calls are not
> permitted to be run in parallel, so I can't see any undefined
> behaviour. If either call sets errno it is guaranteed that errno will
> be set to a non-0 value (standard functions do not set it to 0) so the
> code can still test errno to see if an error has occurred and what at
> least one error was. So I really don't see a problem.

[...]

If log() is implemented as a macro, there may not be a sequence point.

--
Keith Thompson (The_Other_Keith) http://www.velocityreviews.com/forums/(E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
 
Reply With Quote
 
Robert Gamble
Guest
Posts: n/a
 
      09-05-2006
Keith Thompson wrote:
> Flash Gordon <(E-Mail Removed)> writes:
> > Spiros Bousbouras wrote:
> >> John Smith wrote:
> >>
> >>> I've been playing with splint, which returns the following
> >>> warning for the code below:
> >>>
> >>> statlib.c: (in function log_norm_pdf)
> >>> statlib.c(1054,31): Expression has undefined behavior (left
> >>> operand uses errno,
> >>> modified by right operand): (log(x) - mu) * (log(x) - mu)
> >>> Code has unspecified behavior. Order of evaluation of function
> >>> parameters or
> >>> subexpressions is not defined, so if a value is used and
> >>> modified in
> >>> different places not separated by a sequence point
> >>> constraining evaluation
> >>> order, then the result of the expression is unspecified.
> >> I'm a bit puzzled by this.
> >> Is it unspecified or undefined ? And why is it either ?
> >> When it says "operand uses errno" does it mean reads
> >> the value of errno or it means reads or writes the value
> >> of errno ?

> >
> > The order of the two function calls is unspecified, but IIRC there is
> > a sequence point on calling a function, and the two calls are not
> > permitted to be run in parallel, so I can't see any undefined
> > behaviour. If either call sets errno it is guaranteed that errno will
> > be set to a non-0 value (standard functions do not set it to 0) so the
> > code can still test errno to see if an error has occurred and what at
> > least one error was. So I really don't see a problem.

> [...]
>
> If log() is implemented as a macro, there may not be a sequence point.


This is true, although it would be quite difficult to imagine a macro
version that calculates the log and sets errno all without introducing
a sequence point. In any case, it is definitely a QOI issue although I
find it somewhat disturbing that the Standard allows this. I wonder
why the Standard committee didn't stick in something that prohibits the
modification of an object with static duration from a macro version of
a library function without appropriate sequence points.

Robert Gamble

 
Reply With Quote
 
ena8t8si@yahoo.com
Guest
Posts: n/a
 
      09-06-2006

Robert Gamble wrote:
> Keith Thompson wrote:
> > Flash Gordon <(E-Mail Removed)> writes:
> > > Spiros Bousbouras wrote:
> > >> John Smith wrote:
> > >>
> > >>> I've been playing with splint, which returns the following
> > >>> warning for the code below:
> > >>>
> > >>> statlib.c: (in function log_norm_pdf)
> > >>> statlib.c(1054,31): Expression has undefined behavior (left
> > >>> operand uses errno,
> > >>> modified by right operand): (log(x) - mu) * (log(x) - mu)
> > >>> Code has unspecified behavior. Order of evaluation of function
> > >>> parameters or
> > >>> subexpressions is not defined, so if a value is used and
> > >>> modified in
> > >>> different places not separated by a sequence point
> > >>> constraining evaluation
> > >>> order, then the result of the expression is unspecified.
> > >> I'm a bit puzzled by this.
> > >> Is it unspecified or undefined ? And why is it either ?
> > >> When it says "operand uses errno" does it mean reads
> > >> the value of errno or it means reads or writes the value
> > >> of errno ?
> > >
> > > The order of the two function calls is unspecified, but IIRC there is
> > > a sequence point on calling a function, and the two calls are not
> > > permitted to be run in parallel, so I can't see any undefined
> > > behaviour. If either call sets errno it is guaranteed that errno will
> > > be set to a non-0 value (standard functions do not set it to 0) so the
> > > code can still test errno to see if an error has occurred and what at
> > > least one error was. So I really don't see a problem.

> > [...]
> >
> > If log() is implemented as a macro, there may not be a sequence point.

>
> This is true, although it would be quite difficult to imagine a macro
> version that calculates the log and sets errno all without introducing
> a sequence point.


Despite the evidence of the error message above? That
makes it pretty easy to imagine I would say.

> In any case, it is definitely a QOI issue although I
> find it somewhat disturbing that the Standard allows this. I wonder
> why the Standard committee didn't stick in something that prohibits the
> modification of an object with static duration from a macro version of
> a library function without appropriate sequence points.


Better still, a requirement that a macro version behave
as if the actual function would.

 
Reply With Quote
 
Spoon
Guest
Posts: n/a
 
      09-06-2006
Flash Gordon wrote:

> Personally I would do something more like
> {
> double a = log(x) - mu;
> t2num -= a * a;
> }


Is -= a typo?

The original code was:

t2num = -((log(x) - mu) * (log(x) - mu));

(with t2num uninitialized.)

Isn't
t2num -= a * a;
equivalent to
t2num = t2num - (a * a);
?
 
Reply With Quote
 
Flash Gordon
Guest
Posts: n/a
 
      09-06-2006
Spoon wrote:
> Flash Gordon wrote:
>
>> Personally I would do something more like
>> {
>> double a = log(x) - mu;
>> t2num -= a * a;
>> }

>
> Is -= a typo?


<snip>

No, it was a reado. I wasn't reading carefully enough.However, the
general point still stands.
--
Flash Gordon
 
Reply With Quote
 
Robert Gamble
Guest
Posts: n/a
 
      09-06-2006
(E-Mail Removed) wrote:
> Robert Gamble wrote:
> > Keith Thompson wrote:
> > > Flash Gordon <(E-Mail Removed)> writes:
> > > > Spiros Bousbouras wrote:
> > > >> John Smith wrote:
> > > >>
> > > >>> I've been playing with splint, which returns the following
> > > >>> warning for the code below:
> > > >>>
> > > >>> statlib.c: (in function log_norm_pdf)
> > > >>> statlib.c(1054,31): Expression has undefined behavior (left
> > > >>> operand uses errno,
> > > >>> modified by right operand): (log(x) - mu) * (log(x) - mu)
> > > >>> Code has unspecified behavior. Order of evaluation of function
> > > >>> parameters or
> > > >>> subexpressions is not defined, so if a value is used and
> > > >>> modified in
> > > >>> different places not separated by a sequence point
> > > >>> constraining evaluation
> > > >>> order, then the result of the expression is unspecified.
> > > >> I'm a bit puzzled by this.
> > > >> Is it unspecified or undefined ? And why is it either ?
> > > >> When it says "operand uses errno" does it mean reads
> > > >> the value of errno or it means reads or writes the value
> > > >> of errno ?
> > > >
> > > > The order of the two function calls is unspecified, but IIRC there is
> > > > a sequence point on calling a function, and the two calls are not
> > > > permitted to be run in parallel, so I can't see any undefined
> > > > behaviour. If either call sets errno it is guaranteed that errno will
> > > > be set to a non-0 value (standard functions do not set it to 0) so the
> > > > code can still test errno to see if an error has occurred and what at
> > > > least one error was. So I really don't see a problem.
> > > [...]
> > >
> > > If log() is implemented as a macro, there may not be a sequence point.

> >
> > This is true, although it would be quite difficult to imagine a macro
> > version that calculates the log and sets errno all without introducing
> > a sequence point.

>
> Despite the evidence of the error message above? That
> makes it pretty easy to imagine I would say.


It's not too difficult to imagine *a* function that would do this as
virtually any library function may set errno, but it would be difficult
to imagine a conforming implementation of the log function that does as
its implementation is non-trivial and it returns a non-int value.

> > In any case, it is definitely a QOI issue although I
> > find it somewhat disturbing that the Standard allows this. I wonder
> > why the Standard committee didn't stick in something that prohibits the
> > modification of an object with static duration from a macro version of
> > a library function without appropriate sequence points.

>
> Better still, a requirement that a macro version behave
> as if the actual function would.


There is a sequence point before any function in C returns. Requiring
that all macro versions of library functions have this sequence point
would unnecessarily complicate and invalidate many existing macros
such as those covering functions in ctype.h. As long as the macro does
not modify objects with static duration I don't see a need for forcing
the macro version to implement the sequence point.

Robert Gamble

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
sequence points and expression evaluation cmelliso C Programming 10 07-10-2010 07:16 PM
Evaluation sequence and precedence feeblez@gmail.com C++ 22 08-27-2007 11:32 PM
[EVALUATION] - E03 - jamLang Evaluation Case Applied to Python Ilias Lazaridis Python 2 04-24-2005 05:29 PM
[EVALUATION] - E04 - jamPersist Evaluation Case Applied to Ruby Ilias Lazaridis Ruby 18 04-09-2005 04:45 PM
[EVALUATION] - E03 - jamLang Evaluation Case Applied to Ruby Ilias Lazaridis Ruby 74 04-04-2005 05:29 PM



Advertisments