Comparison of pointers cast to void *

[Alan McKenney]

A while back I asked on comp.lang.c++.moderated the question:

if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?

Many people seemed to think it was not, but none of their
explanations seemed all that convincing to me.

The situation I envisioned where this could come up is
a word-addressed machine where one word contains
multiple characters (let's say 8.)

In that case, a sensible way of representing pointers to char
types would be to have the index within the word in the bottom three
bits and the pointer to the word in the higher-order bits.

Pointers to other built-in types and to objects would be word
pointers.

Next, it would make sense to have cast to "void *" just copy the
bits in the pointer -- why do extra work?

But if you do it this way, then you could have a pointer to char
and a pointer to a double be the same, if the double's word address
was 8 times the char's word address.

If the Standard required that the void * representation of pointers
to different objects always compared unequal, it would essentially
mean that the implementation would have to use the char *
representation for the void * representation of any pointer -- meaning
conversion between void * and normal pointer would involve shifts.

So, what does the Standard require here?

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Alberto Ganesh Barbati]

Post by Alan McKenney
if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?
<snip>
If the Standard required that the void * representation of pointers
to different objects always compared unequal, it would essentially
mean that the implementation would have to use the char *
representation for the void * representation of any pointer -- meaning
conversion between void * and normal pointer would involve shifts.
So, what does the Standard require here?

4.10/2 says that "The result of converting a “pointer to cv T” to a
“pointer to cv void” points to the start of the storage location where
the object of type T resides, as if the object is a most derived object
(1.8) of type T (that is, not a base class subobject)."

You can't store two most derived objects at the same location, so the
conversion to void* must produce different values for every two distinct
objects, regardless of their respective types. This may (or may not)
require the conversion from T* to void* to be something different from a
bit-wise copy. Actually, that can be said for every pointer conversion.

HTH,

Ganesh

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Alan McKenney]

Post by Alan McKenney
if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?

<snip>

4.10/2 says that "The result of converting a "pointer to cv T" to a
"pointer to cv void" points to the start of the storage location where
the object of type T resides, as if the object is a most derived object
(1.8) of type T (that is, not a base class subobject)."

But what exactly does "points to" mean?

Perhaps I'm dense, but I can only understand
"points to" to mean: what you get when you
dereference the pointer.

And since you can't dereference a void *, this
means casting it back to a pointer to a type.
In particular, as far as I know from postings
on c.l.c++.m and c.s.c++, this means casting it
back to the type that it was cast from, since
that's the only legal cast for a void *.

So, you should be able to have the same void *
bit pattern "point to" two different objects,
depending upon what type you consider it to
be. In the implementation I describe, that's
what actually happens with the non-void pointers:
the same bit pattern can address two different
parts of memory, depending upon what type
it is assumed to have.

(This is not as wierd as it sounds -- after
all, the same bit pattern on more "normal"
machines can have completely different
"values", depending upon whether the word
is regarded as a long or a float.)

I'm not sure that the paragraph that Ganesh
quotes forbids this for void * pointers:
it doesn't say anything about casting a
pointer from one type to another through
void *, nor anything about comparisons
of void * pointers arising from pointers
to different types.



---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[James Kanze]

Post by Alan McKenney

Post by Alan McKenney
if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?

<snip>

4.10/2 says that "The result of converting a "pointer to cv T" to a
"pointer to cv void" points to the start of the storage location where
the object of type T resides, as if the object is a most derived object
(1.8) of type T (that is, not a base class subobject)."

But what exactly does "points to" mean?
Perhaps I'm dense, but I can only understand
"points to" to mean: what you get when you
dereference the pointer.
And since you can't dereference a void *, this
means casting it back to a pointer to a type.
In particular, as far as I know from postings
on c.l.c++.m and c.s.c++, this means casting it
back to the type that it was cast from, since
that's the only legal cast for a void *.

You can also cast it to unsigned char*, and look at the raw
memory.

Post by Alan McKenney
So, you should be able to have the same void *
bit pattern "point to" two different objects,
depending upon what type you consider it to
be. In the implementation I describe, that's
the same bit pattern can address two different
parts of memory, depending upon what type
it is assumed to have.

The implementation you described isn't legal, since it causes
void* to loose information. You must be able to cast any
pointer to void*, and back again, without loss of information;
the pointer from the round trip must compare equal to the
original pointer, and designate the same object.

If two void* actually point to two different objects, then it is
guaranteed that they compare inequal. If a void* points to one
beyond the last element of an array, however, it may compare
equal to a void* which points to some other object (not the
array, nor any element in the array).

--
James Kanze (GABI Software) email:***@gmail.com
Conseils en informatique orient�e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S�mard, 78210 St.-Cyr-l'�cole, France, [phone]


---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Alan McKenney]

Post by James Kanze

Post by Alan McKenney

Post by Alan McKenney
if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?

<snip>

4.10/2 says that "The result of converting a "pointer to cv T" to a
"pointer to cv void" points to the start of the storage location where
the object of type T resides, as if the object is a most derived object
(1.8) of type T (that is, not a base class subobject)."

But what exactly does "points to" mean?
Perhaps I'm dense, but I can only understand
"points to" to mean: what you get when you
dereference the pointer.
And since you can't dereference a void *, this
means casting it back to a pointer to a type.
In particular, as far as I know from postings
on c.l.c++.m and c.s.c++, this means casting it
back to the type that it was cast from, since
that's the only legal cast for a void *.

You can also cast it to unsigned char*, and look at the raw
memory.

In other words, the standard specifically requires that
void * be equivalent ("isomorphic") to unsigned char *

Furthermore, since you speak of "looking at the raw memory"
through this pointer, it sounds like even if the hardware is not
byte-addressable (or is even more exotic), the implementation
must make it look like everything is stored in byte-addressable
untyped memory, at least when you use void *.

For example, on a Burroughs 5000-series, where
each 48-bit word has additional "hidden" bits that specify the
type of the data in the word, the implementation
would have to have a way to ignore the type bits, and allow
access to a representation of the data as a string of
individually readable and writable bytes.

Post by James Kanze

Post by Alan McKenney
So, you should be able to have the same void *
bit pattern "point to" two different objects,
depending upon what type you consider it to
be. In the implementation I describe, that's
the same bit pattern can address two different
parts of memory, depending upon what type
it is assumed to have.

The implementation you described isn't legal, since it causes
void* to loose information. You must be able to cast any
pointer to void*, and back again, without loss of information;
the pointer from the round trip must compare equal to the
original pointer, and designate the same object.

In the implementation I was proposing, there would be
no loss of information, since conversion to void *
involved using the same string of bits as the typed
pointer.

However, the requirement that void * be equivalent to
unsigned char * means that my proposed implementation
would not be standard-conformant.

Post by James Kanze
If two void* actually point to two different objects, then it is
guaranteed that they compare inequal.

Not that I doubt that you are correct, but:
Is this explicitly required in the standard?
Or is it a consequence of other requirements, e.g.,
Alberto Barbati's paragraph plus the convertability to
unsigned char *?

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Greg Herlihy]

Post by Alan McKenney
if you have pointers to two different objects and you cast them
to void *, is it legal for them to compare equal?

4.10/2 says that "The result of converting a ³pointer to cv T² to a
³pointer to cv void² points to the start of the storage location where
the object of type T resides, as if the object is a most derived object
(1.8) of type T (that is, not a base class subobject)."
You can't store two most derived objects at the same location, so the
conversion to void* must produce different values for every two distinct
objects, regardless of their respective types. This may (or may not)
require the conversion from T* to void* to be something different from a
bit-wise copy. Actually, that can be said for every pointer conversion.

No, two pointers to two different objects may point to the same address -
provided that the two objects do not have the same type:

struct A {};

struct B
{
A a;
};

int main()
{
B b;
void * pA = &b.a;
void * pB = &b;

assert( pB == pA); // OK
}

Otherwise, every object is guaranteed to have an address that differs from
the address of any other object - of the same type. So, the answer to the
original question is "No." C++ does not require that void* pointers to two
different objects must always compare unequal. The void* pointers are
certain to compare as unequal - only if the types of the two objects being
pointed to - are the same.

Greg



---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Tjark Weber]

Post by Alan McKenney
If the Standard required that the void * representation of pointers
to different objects always compared unequal, it would essentially
mean that the implementation would have to use the char *
representation for the void * representation of any pointer -- meaning
conversion between void * and normal pointer would involve shifts.
So, what does the Standard require here?

�3.9.2(4): "A void* shall be able to hold any object pointer. A [...]
void* shall have the same representation and alignment requirements as
a [...] char*."

Tjark


---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]

[Yechezkel Mett]

Post by Alan McKenney
The situation I envisioned where this could come up is
a word-addressed machine where one word contains
multiple characters (let's say 8.)
In that case, a sensible way of representing pointers to char
types would be to have the index within the word in the bottom three
bits and the pointer to the word in the higher-order bits.
Pointers to other built-in types and to objects would be word
pointers.
Next, it would make sense to have cast to "void *" just copy the
bits in the pointer -- why do extra work?
But if you do it this way, then you could have a pointer to char
and a pointer to a double be the same, if the double's word address
was 8 times the char's word address.

Isn't it legal to cast the void* to an unsigned char* and memcpy the
bytes (assuming the type is memcpy-able) ? I don't see how that could
be made to work under your scenario. Maybe if the implementation
retained extra pointer type information which didn't participate in
comparisons.

Yechezkel Mett

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:[e-mail] ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]