The last time Hackerfall tried to access this page, it returned a not found error. A cached version of the page is below, or click here to continue anyway

A perspective on friendly C – Reasonably Logical

I was talking about John Regehr’s Friendly C proposal and recent follow-on post tonight with a friend, and decide to jot down some thoughts in a sharable format.

I believe the idea of a friendly C variant is entirely feasible, but it posses an incredibly challenging design problem. Every change considered needs to be validated against a deep knowledge of the implementation of the associated compiler, runtime environment, and the underlying hardware.

As a simple example, let’s consider trying to establish semantics for stray (i.e. out of bounds) read and writes. We can start by trying to define what happens for a stray read. That’s fairly easy, we can simply return an undefined value. We could even be a bit more restrictive and say that the value must be one which is written to that address by some part of the program.

(The vagueness in that last bit is to allow concurrent execution reordering. However, we accidentally required atomic reads and writes since we disallowed wording tearing. Is that a good thing or not? There’s a cost to that, but maybe it’s a cost we’re willing to pay. Or maybe not…)

Now let’s consider how to handle stray writes. We could simply define them to be erroneous, but that simply gets us back to undefined behavior in C/C++. We’re trying to avoid that. We either need to detect them, or provide a reasonable semantics. Detecting arbitrary stray writes is a very hard problem. We can easily handle specific categories of stray writes through techniques like implicit null checking, but detecting an arbitrary stray write requires something like a full address-sanitizer (or possibly even more expensive checks). I doubt anyone is willing to pay 2x performance for their C code to be more friendly. If they were, why are they writing in C?

The challenge with having defined stray writes is what does a particular read return? Does it return the last written value to a particular address? Or the last value written to the particular field of the given object? With out of bounds writes, these are not necessarily the same.

It’s very tempting to have the read return the last value written to the underlying address, but that introduces a huge problem. In particular, it breaks essentially all load-load forwarding.

int foo(int* p_int, float p_float) {
 int a = *p_int;
 *p_float = 0.0;
 return a - *p_int;

In the example above, your normal C compiler could return “0” because it assumes the intervening write can’t change the value at p_int. An implementation of a friendly C variant with the semantics we’ve proposed could not. In practice, this is probably unacceptable from a performance perspective; memory optimization (load-load forwarding and associated optimizations) is a huge part of what a normal C/C++ compiler does. (see: BasicAA, MDA. GVN, DSE, EarlyCSE in LLVM)

If we want to avoid that problem, we could try to be more subtle in our definition. Let’s say we instead defined a read as returning either the last value written to that field (i.e. in bounds write) or underlying memory address (i.e. stray write). We still have the problem of requiring atomic memory access, but we seem to have allowed the compiler optimization we intended.

The problem with this definition is that we’ve introduced a huge amount of complexity to our language specification and compiler. We now have to have separate definitions of both our objects, their underlying addresses, and all the associated implementation machinery.

Another approach would be to define a read as returning either the last value written to the field (if no stray write has occurred to that address) or an undefined value (if a stray write to that address has occurred). Is that friendly enough?

Moreover, what happens if we improve our ability to detect stray writes? Are we allowed to make that write suddenly fail? Is a program which functions only because of a stray write correct?

(Before you dismiss this as ridiculous, I personally know of an emergency software release that did nothing but reintroduce a particular stray memory write in a C++ program because it happened to restore behavior that a client had been relying on for many many years.)

Hopefully, I’ve given you a hint of the complexities inherent in any friendly C proposal. These are the same complexities involved in designing any new language. If anything designing a workable friendly-C proposal is harder than designing a new language. At least with a new language you’d have the freedom to change other aspects of the language to avoid having to deal with garbage pointers entirely; in practice, that’s often the much easier approach.


Continue reading on