char* pointer comparisons and clang12

char* pointer comparisons and clang12

[Alan Modra]

Is it true that char* pointers cannot be compared using the relational 
operators <, >, <=, or >= except when they point into the same object
or array (or one past)?  Reading the C standard section 6.5.8 seems to
say that.  "In all other cases, the behavior is undefined."  (I know
enough computer architecture to know why the standard is written that
way, so the question is rhetorical.  The real question is below.)

Are there compilers that optimize making use of that UB on flat memory
architectures?  Specifically, clang12.  See pr27836.

We use pointer comparisons like the one at binutils/dwarf.c:8802 in
many places in binutils to test a value derived from user imput
against an array bound.  If this UB is a concern it seems like all of
those tests will need rewriting.

-- 
Alan Modra
Australia Development Lab, IBM

Re: char* pointer comparisons and clang12

[Jacob Lifshay]

On Tue, May 18, 2021, 00:21 Alan Modra via Binutils <binutils@sourceware.org>
wrote:

> Is it true that char* pointers cannot be compared using the relational
> operators <, >, <=, or >= except when they point into the same object
> or array (or one past)?  Reading the C standard section 6.5.8 seems to
> say that.  "In all other cases, the behavior is undefined."  (I know
> enough computer architecture to know why the standard is written that
> way, so the question is rhetorical.  The real question is below.)
>
> Are there compilers that optimize making use of that UB on flat memory
> architectures?  Specifically, clang12.  See pr27836.
>

Idk about when clang is in C mode, but at least for C++ mode clang gives
defined semantics to the < operator, since that's used to implement
std::less<T *>, which is required by the C++ standard to give a strict
total order on all pointers.

https://en.cppreference.com/w/cpp/utility/functional/less

libc++ 12 implementation of std::less:
https://github.com/llvm/llvm-project/blob/llvmorg-12.0.0/libcxx/include/__functional_base#L54

Jacob Lifshay

Re: char* pointer comparisons and clang12

[Joseph Myers]

On Tue, 11 May 2021, Alan Modra via Binutils wrote:

> Is it true that char* pointers cannot be compared using the relational 
> operators <, >, <=, or >= except when they point into the same object
> or array (or one past)?  Reading the C standard section 6.5.8 seems to
> say that.  "In all other cases, the behavior is undefined."  (I know
> enough computer architecture to know why the standard is written that
> way, so the question is rhetorical.  The real question is below.)
> 
> Are there compilers that optimize making use of that UB on flat memory
> architectures?  Specifically, clang12.  See pr27836.
> 
> We use pointer comparisons like the one at binutils/dwarf.c:8802 in
> many places in binutils to test a value derived from user imput
> against an array bound.  If this UB is a concern it seems like all of
> those tests will need rewriting.

There is some discussion at 
<https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91227> concerning possible 
optimizations in the case where the compiler can see (possibly after 
inlining / LTO) that one pointer is to a local variable, and suggesting 
converting to uintptr_t before comparison to avoid such optimizations.

-- 
Joseph S. Myers
joseph@codesourcery.com