Problem - Kevin Tafuro

ANSI/ISO 9899-1990 standard, which includes any modern C compiler. The key is
the use of the volatile keyword, which essentially instructs the compiler not to optimize
out expressions that involve the variable because there may be side effects
unknown to the compiler. A commonly cited example of this is a variable that may
be modified by hardware, such as a real-time clock.
It’s proper to declare any variable containing sensitive information as volatile.
Unfortunately, many programmers are unaware of what this keyword means, so it is
frequently omitted. In addition, simply declaring a variable as volatile may not be
enough. Whether or not it is enough often depends on how aggressive a particular
compiler is in performing dead-code elimination. Early implementations of deadcode
elimination optimizations were probably far less aggressive than current ones,
and logically you can safely assume that they will perhaps get more aggressive in the
future. It is best to protect code from any current optimizing compiler, as well as any
that may be used in the future.
If simply declaring a variable as volatile may not be enough, what more must be
done? The answer is to replace calls to functions like memcpy( ), memmove( ), and
memset( ) with handwritten versions. These versions may perform less well, but they
will ensure their expected behavior. The solution we have provided above does just
that. Notice the use of the volatile keyword on each function’s argument list. An
important difference between these functions and typical implementations is the use
of that keyword. When memset( ) is called, the volatile qualifier on the buffer passed
into it is lost. Further, many compilers have built-in implementations of these functions
so that the compiler may perform heavier optimizing because it knows exactly
what the functions do.
Here is code that implements three different methods of writing data to a buffer that
a compiler may try to optimize away. The first is spc_memset( ), which acts just like
the standard memset( ) function, except that it guarantees the write will not be optimized
away if the destination is never used. Then we implement spc_memcpy( ) and
spc_memmove( ), which are also analogs of the appropriate standard library functions.
#include
volatile void *spc_memset(volatile void *dst, int c, size_t len) {
volatile char *buf;
for (buf = (volatile char *)dst; len; buf[--len] = c);
return dst;
}
volatile void *spc_memcpy(volatile void *dst, volatile void *src, size_t len) {
volatile char *cdst, *csrc;
cdst = (volatile char *)dst;
csrc = (volatile char *)src;
while (len--) cdst[len] = csrc[len];
706 | Chapter 13: Other Topics
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.