[SeaBIOS] Get rid of a compile time dprintf warning

[Laszlo Ersek]

On 01/10/13 00:54, Kevin O'Connor wrote:
> On Wed, Jan 09, 2013 at 08:34:18AM -0600, Dave Frodin wrote:
>> Here's a patch that's been lingering awhile. 
>> thanks, 
> 
> Thanks.  I don't receive a warning for this - what is the exact
> warning you receive?  I don't see why gcc would convert (datalow_end -
> datalow_start) to a long.

In the expression "datalow_end - datalow_start", both operands
- (have incomplete array type (size unknown), ISO C99 6.2.5p22),
- are converted ("decay") to type "pointer-to-u8" (ISO C99 6.3.2.1p3).

The expression "datalow_end - datalow_start" invokes undefined behavior,
because the (decayed) operands are not pointers into the same array (or
to the element one past the last element in the array).

Anyway, the result type of "datalow_end - datalow_start" would be
ptrdiff_t, whose size is implementation-defined.

>From ISO C99, 6.5.6 Additive operators (normative):

  9 When two pointers are subtracted, both shall point to elements of
    the same array object, or one past the last element of the array
    object; the result is the difference of the subscripts of the two
    array elements. The size of the result is implementation-defined,
    and its type (a signed integer type) is ptrdiff_t defined in the
    <stddef.h> header. If the result is not representable in an object
    of that type, the behavior is undefined. In other words, if the
    expressions P and Q point to, respectively, the i-th and j-th
    elements of an array object, the expression (P)-(Q) has the value
    i-j provided the value fits in an object of type ptrdiff_t.
    Moreover, if the expression P points either to an element of an
    array object or one past the last element of an array object, and
    the expression Q points to the last element of the same array
    object, the expression ((Q)+1)-(P) has the same value as ((Q)-(P))+1
    and as -((P)-((Q)+1)), and has the value zero if the expression P
    points one past the last element of the array object, even though
    the expression (Q)+1 does not point to an element of the array
    object.88)

Footnote 88 (informative)

    Another way to approach pointer arithmetic is first to convert the
    pointer(s) to character pointer(s): In this scheme the integer
    expression added to or subtracted from the converted pointer is
    first multiplied by the size of the object originally pointed to,
    and the resulting pointer is converted back to the original type.
    For pointer subtraction, the result of the difference between the
    character pointers is similarly divided by the size of the object
    originally pointed to.

    When viewed in this way, an implementation need only provide one
    extra byte (which may overlap another object in the program) just
    after the end of the object in order to satisfy the "one past the
    last element" requirements.

I can see two ways to solve this "problem" (many are possible probably):

(1) print the difference (of type ptrdiff_t) with the "%td" printf()
conversion specification. It was first defined in SUSv3
<http://pubs.opengroup.org/onlinepubs/000095399/functions/fprintf.html>,
ie. not standard C. However this leaves the undefined behavior (the
subtraction) in place.

(2) Convert the operands first to pointer-to-void (safe), then to
uintptr_t ((a) an optional type that is required on XSI conformant
systems, (b) the conversion is safe from void*), then take their
difference, convert it to uintmax_t, and print it with "%"PRIuMAX:

    dprintf(1, "Relocating low data from %p to %p (size %"PRIuMAX")\n"
            , (void *)datalow_start, (void *)final_datalow_start,
            , (uintmax_t)(  (uintptr_t)(void *)datalow_end
                          - (uintptr_t)(void *)datalow_start));

(I'm of course aware that you won't do this, bit I think it explains the
"problem" and you could simplify from here, perhaps exploiting
characteristics that are guaranteed for any platform that runs SeaBIOS.)

Laszlo