RE: Avoiding "assignment from incompatible pointer type" warning

RE: Avoiding "assignment from incompatible pointer type" warning

[Moore, Mathew L]

> 
> 6.3.2.3(7) only ensures that conforming implementations may not issue
> a diagnostic for such programming errors.
> 

To help expand my (very) limited knowledge, does this mean that 

	float f;
	int *p = (int*)&f;

may not work even if sizeof(float) == sizeof(int)?

Thanks,
--Matt

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

"Moore, Mathew L" <MooreML@BATTELLE.ORG> writes:

> To help expand my (very) limited knowledge, does this mean that 
>
> 	float f;
> 	int *p = (int*)&f;
>
> may not work even if sizeof(float) == sizeof(int)?

I think so.

Alignment is defined informally as:

       3.2
       [#1] alignment
       requirement that objects of a particular type be located  on
       storage   boundaries  with  addresses  that  are  particular
       multiples of a byte address

This definition is independent of the size of the type.  Furthermore,
there's no way to determine the required alignment of a type.

Re: Avoiding "assignment from incompatible pointer type" warning

[John Love-Jensen]

>  Furthermore, there's no way to determine the required alignment of a type.

The GCC compiler has an extension to C and C++, which does allow the
programmer to determine the required alignment of a type.

But that facility is a GCC specific language extension, and not part of C or
C++.  (Take this as a HUGE RED WARNING FLAG.  If you use GCC's compiler
specific extensions, you have committed to programmig in GCC-C or GCC-C++,
not in C or C++.)

--Eljay

RE: Avoiding "assignment from incompatible pointer type" warning

[Moore, Mathew L]

Certainly it is legal as far as the standard is concerned,

"A pointer to an object or incomplete type may be converted to a pointer to
a different object or incomplete type."

However, it may not be safe,

"If the resulting pointer is not correctly aligned for the pointed-to type,
the behavior is undefined."

--Matt


> -----Original Message-----
> From: Claudio Bley [mailto:bley@cs.uni-magdeburg.de]
> Sent: Monday, October 21, 2002 07:22
> To: Florian Weimer
> Cc: Joshua Nye; Steve Dondley; gcc-help@gcc.gnu.org
> Subject: Re: Avoiding "assignment from incompatible pointer type"
> warning
> 
> 
> >>>>> "Florian" == Florian Weimer <fw@deneb.enyo.de> writes:
> 
>     Florian> "Joshua Nye" <josh@boxcarmedia.com> writes:
>     >>> > int *p; 
>     >>> > float g = 3.141592653589793238;
>     >>> > p = (int *)&g;
>     >>> 
>     >>> Is this code legal?  I doubt it.
>     >>> 
>     >>  What do you consider legal and why wouldn't it be?
> 
>     Florian> Casting a pointer from float to int can result in
>     Florian> undefined behavior on some implementations.
> 
> I can't see why. Can you elaborate on that? I mean, casting on the
> machine code level does just nothing - it's just "syntactic sugar" to
> convince the compiler to be quiet. I think casting from one pointer
> type to another does no harm at all. Am I wrong?
> 
> -- 
> Claudio Bley                                 ASCII ribbon campaign (")
> Debian GNU/Linux advocate                     - against HTML email  X 
> http://www.cs.uni-magdeburg.de/~bley/                     & vCards / \
> 

RE: Avoiding "assignment from incompatible pointer type" warning

[Moore, Mathew L]

You can always use a void pointer,

  const float x = 2.0625;
  const void *p = &x;
  const int *lp = p;

but explicit casting works just as well.

While we are on this topic, is there a portable way to perform the bit-wise
examination of a floating point variable?  What about for an implementation
where sizeof(float) != sizeof(int) (or sizeof(long), etc.).  Is there
something significantly wrong about doing the following?  Will gcc even
allow this?

  union {
    float x;
    char b[sizeof(float)];
  } u;
  u.x = 2.0625;
  /* Access bytes/bits through u.b[0], u.b[1], ..., u.b[sizeof(float)-1] */


Thanks,
--Matt



> -----Original Message-----
> From: Steve Dondley [mailto:s@dondley.com]
> Sent: Sunday, October 13, 2002 12:13
> To: gcc-help@gcc.gnu.org
> Subject: Avoiding "assignment from incompatible pointer type" warning
> 
> 
> Hi,
> 
> I've written a simple program that print out each bit of a 
> floating point
> variable so I can learn how floating point numbers are represented in
> memory.  The program contains the following statements:
> 
> int *p;
> float g = 2.0625;
> p = &g;
> 
> The third statement above generates an "assignment from 
> incompatible pointer
> type" warning for obvious reasons.  Other than this, the 
> program compiles
> fine and works.
> 
> My question is:  Is there a way to properly assign a pointer 
> of one type to
> a variable of different type so that the warning is suppressed?
> 
> Thanks again.
> 
> 

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

"Moore, Mathew L" <MooreML@BATTELLE.ORG> writes:

> While we are on this topic, is there a portable way to perform the
> bit-wise examination of a floating point variable?

You can read and write every object as a sequence of chars.  So you
don't even need a union, pointer fiddling would be sufficient.

Avoiding "assignment from incompatible pointer type" warning

[Steve Dondley]

Hi,

I've written a simple program that print out each bit of a floating point
variable so I can learn how floating point numbers are represented in
memory.  The program contains the following statements:

int *p;
float g = 2.0625;
p = &g;

The third statement above generates an "assignment from incompatible pointer
type" warning for obvious reasons.  Other than this, the program compiles
fine and works.

My question is:  Is there a way to properly assign a pointer of one type to
a variable of different type so that the warning is suppressed?

Thanks again.

Re: Avoiding "assignment from incompatible pointer type" warning

[Joshua Nye]

Hi Steve,

What you're looking for is a cast. i.e.:

int *p;
float g = 3.141592653589793238;
p = (int *)&g;

--josh

----- Original Message -----
From: "Steve Dondley" <s@dondley.com>
To: <gcc-help@gcc.gnu.org>
Sent: Sunday, October 13, 2002 12:13 PM
Subject: Avoiding "assignment from incompatible pointer type" warning


> Hi,
>
> I've written a simple program that print out each bit of a floating point
> variable so I can learn how floating point numbers are represented in
> memory.  The program contains the following statements:
>
> int *p;
> float g = 2.0625;
> p = &g;
>
> The third statement above generates an "assignment from incompatible
pointer
> type" warning for obvious reasons.  Other than this, the program compiles
> fine and works.
>
> My question is:  Is there a way to properly assign a pointer of one type
to
> a variable of different type so that the warning is suppressed?
>
> Thanks again.
>
>

RE: Avoiding "assignment from incompatible pointer type" warning

[Steve Dondley]

Ah, OK.  When I tried casting earlier, I was putting the cast on the lvalue.
I don't have the world's sharpest tech mind but with persistence I'll get it
eventually.

> -----Original Message-----
> From: gcc-help-owner@gcc.gnu.org [mailto:gcc-help-owner@gcc.gnu.org]On
> Behalf Of Joshua Nye
> Sent: Sunday, October 13, 2002 12:28 PM
> To: Steve Dondley; gcc-help@gcc.gnu.org
> Subject: Re: Avoiding "assignment from incompatible pointer type"
> warning
>
>
> Hi Steve,
>
> What you're looking for is a cast. i.e.:
>
> int *p;
> float g = 3.141592653589793238;
> p = (int *)&g;
>
> --josh
>
> ----- Original Message -----
> From: "Steve Dondley" <s@dondley.com>
> To: <gcc-help@gcc.gnu.org>
> Sent: Sunday, October 13, 2002 12:13 PM
> Subject: Avoiding "assignment from incompatible pointer type" warning
>
>
> > Hi,
> >
> > I've written a simple program that print out each bit of a
> floating point
> > variable so I can learn how floating point numbers are represented in
> > memory.  The program contains the following statements:
> >
> > int *p;
> > float g = 2.0625;
> > p = &g;
> >
> > The third statement above generates an "assignment from incompatible
> pointer
> > type" warning for obvious reasons.  Other than this, the
> program compiles
> > fine and works.
> >
> > My question is:  Is there a way to properly assign a pointer of one type
> to
> > a variable of different type so that the warning is suppressed?
> >
> > Thanks again.
> >
> >
>
>
>

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

"Joshua Nye" <josh@boxcarmedia.com> writes:

> What you're looking for is a cast. i.e.:
>
> int *p;
> float g = 3.141592653589793238;
> p = (int *)&g;

Is this code legal?  I doubt it.

Re: Avoiding "assignment from incompatible pointer type" warning

[Joshua Nye]

If what you mean about being 'illegal' is that it will not compile, it will
compile. Good programming practice is another thing altogether.

--josh

----- Original Message -----
From: "Florian Weimer" <fw@deneb.enyo.de>
To: "Joshua Nye" <josh@boxcarmedia.com>
Cc: "Steve Dondley" <s@dondley.com>; <gcc-help@gcc.gnu.org>
Sent: Sunday, October 13, 2002 6:09 PM
Subject: Re: Avoiding "assignment from incompatible pointer type" warning


> "Joshua Nye" <josh@boxcarmedia.com> writes:
>
> > What you're looking for is a cast. i.e.:
> >
> > int *p;
> > float g = 3.141592653589793238;
> > p = (int *)&g;
>
> Is this code legal?  I doubt it.
>

Re: Avoiding "assignment from incompatible pointer type" warning

[Joshua Nye]

> > int *p;
> > float g = 3.141592653589793238;
> > p = (int *)&g;
> 
> Is this code legal?  I doubt it.
> 

What do you consider legal and why wouldn't it be?

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

"Joshua Nye" <josh@boxcarmedia.com> writes:

>> > int *p;
>> > float g = 3.141592653589793238;
>> > p = (int *)&g;
>> 
>> Is this code legal?  I doubt it.
>> 
>
> What do you consider legal and why wouldn't it be?

Casting a pointer from float to int can result in undefined behavior
on some implementations.

Re: Avoiding "assignment from incompatible pointer type" warning

[Claudio Bley]

>>>>> "Florian" == Florian Weimer <fw@deneb.enyo.de> writes:

    Florian> "Joshua Nye" <josh@boxcarmedia.com> writes:
    >>> > int *p; 
    >>> > float g = 3.141592653589793238;
    >>> > p = (int *)&g;
    >>> 
    >>> Is this code legal?  I doubt it.
    >>> 
    >>  What do you consider legal and why wouldn't it be?

    Florian> Casting a pointer from float to int can result in
    Florian> undefined behavior on some implementations.

I can't see why. Can you elaborate on that? I mean, casting on the
machine code level does just nothing - it's just "syntactic sugar" to
convince the compiler to be quiet. I think casting from one pointer
type to another does no harm at all. Am I wrong?

-- 
Claudio Bley                                 ASCII ribbon campaign (")
Debian GNU/Linux advocate                     - against HTML email  X 
http://www.cs.uni-magdeburg.de/~bley/                     & vCards / \

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

"Claudio Bley" <bley@cs.uni-magdeburg.de> writes:

>     >>  What do you consider legal and why wouldn't it be?
>
>     Florian> Casting a pointer from float to int can result in
>     Florian> undefined behavior on some implementations.
>
> I can't see why. Can you elaborate on that?

Well, it's all in the standard, although it's a bit scattered.

> I mean, casting on the machine code level does just nothing - it's
> just "syntactic sugar" to convince the compiler to be quiet.

It's not.  In C, pointers are NOT machine addresses.  Pointers are an
abstract concept, and often, something which would work if they were
machine addresses, fails miserably.  For example, even if two pointers
compare equal (because they point to the same object), it's possible
that an operation on one of the two is undefined, while it is defined
for the other one.

> I think casting from one pointer type to another does no harm at
> all. Am I wrong?

Yes, you are, I'm afraid.

Re: Avoiding "assignment from incompatible pointer type" warning

[Claudio Bley]

>>>>> "Florian" == Florian Weimer <fw@deneb.enyo.de> writes:

    Florian> "Claudio Bley" <bley@cs.uni-magdeburg.de> writes:
    >> >> What do you consider legal and why wouldn't it be?
    >> 
    Florian> Casting a pointer from float to int can result in
    Florian> undefined behavior on some implementations.
    >>  I can't see why. Can you elaborate on that?

    Florian> Well, it's all in the standard, although it's a bit
    Florian> scattered.

    >> I mean, casting on the machine code level does just nothing -
    >> it's just "syntactic sugar" to convince the compiler to be
    >> quiet.

    Florian> It's not.  In C, pointers are NOT machine addresses.
    Florian> Pointers are an abstract concept, and often, something
    Florian> which would work if they were machine addresses, fails
    Florian> miserably.  For example, even if two pointers compare
    Florian> equal (because they point to the same object), it's
    Florian> possible that an operation on one of the two is
    Florian> undefined, while it is defined for the other one.

    >> I think casting from one pointer type to another does no harm
    >> at all. Am I wrong?

    Florian> Yes, you are, I'm afraid.

I'm afraid too! ;-) Really. I'm using C for quite a while now, read a
few books but I never realized that. I was thinking that a cast just
meant "pretend these bits have a different type, and treat them
accordingly". Also, as Mathew Moore mentioned, I was not thinking
about alignment issues. 

Regards.
-- 
Claudio Bley                                 ASCII ribbon campaign (")
Debian GNU/Linux advocate                     - against HTML email  X 
http://www.cs.uni-magdeburg.de/~bley/                     & vCards / \

Re: Avoiding "assignment from incompatible pointer type" warning

[Sebastian Huber]

On Monday 21 October 2002 04:22, Claudio Bley wrote:
> >>>>> "Florian" == Florian Weimer <fw@deneb.enyo.de> writes:
>
>     Florian> "Joshua Nye" <josh@boxcarmedia.com> writes:
>     >>> > int *p;
>     >>> > float g = 3.141592653589793238;
>     >>> > p = (int *)&g;
>     >>>
>     >>> Is this code legal?  I doubt it.
>     >>
>     >>  What do you consider legal and why wouldn't it be?
>
>     Florian> Casting a pointer from float to int can result in
>     Florian> undefined behavior on some implementations.
>
> I can't see why. Can you elaborate on that? I mean, casting on the
> machine code level does just nothing - it's just "syntactic sugar" to
> convince the compiler to be quiet. I think casting from one pointer
> type to another does no harm at all. Am I wrong?

Hello,
I guess that today it doesn't matter. But what is, if the size of the pointers 
differ? You should use 'void*' which can store any pointer.

Bye

Re: Avoiding "assignment from incompatible pointer type" warning

[John Love-Jensen]

Hi Claudio,
 
> I can't see why. Can you elaborate on that? I mean, casting on the
> machine code level does just nothing - it's just "syntactic sugar" to
> convince the compiler to be quiet. I think casting from one pointer
> type to another does no harm at all. Am I wrong?

You are correct, the casting is fine, insofar as the given code snippet
goes.

I assume the complaint/concern was regarding the (presumed) dereferencing of
the int* p at some later point in the code.

Note: cavalier casting is highly suspect, and prone to be very platform
specific (when it does work as intended).  For instance, on Solaris a
misaligned value can cause a bus error.  Often the injudicious, cavalier
casting is the culprit.

To do the hex dump as intended, I'd do something like this...

void HexDump(void* ptr, size_t len)
{
  unsigned char* p = (unsigned char*)ptr;
  while(len--)
  {
    printf("%02x%c", *p++, len ? ' ' : '\n');
  }
}

int main()
{
  float g = 3.141592653589793238;
  HexDump(&g, sizeof g);
}

...but that's just me.  :-)

--Eljay

Re: Avoiding "assignment from incompatible pointer type" warning

[Florian Weimer]

John Love-Jensen <eljay@adobe.com> writes:

>> I can't see why. Can you elaborate on that? I mean, casting on the
>> machine code level does just nothing - it's just "syntactic sugar" to
>> convince the compiler to be quiet. I think casting from one pointer
>> type to another does no harm at all. Am I wrong?
>
> You are correct, the casting is fine, insofar as the given code snippet
> goes.
>
> I assume the complaint/concern was regarding the (presumed)
> dereferencing of the int* p at some later point in the code.

Oh, please.  An implementation is free to consider such pointer
conversions to be undefined (of course, an implementation may do
something useful nevertheless), so it's essentially undefined.  And
the undefined behavior is triggered upon the cast, not when the
pointer is dereferenced.

6.3.2.3(7) only ensures that conforming implementations may not issue
a diagnostic for such programming errors.