AMD opteron 64

[Lionel Valero]

Hello,

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
*************** ********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
}
}
*************** ********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Regards,
Lionel.
--
-=O=------------------------------------------=O=-
Lionel Valéro
Analyste Informatique Département Génie Chimique
École Polytechnique de Montréal
C.P. 6079, succ. centre-ville
Montréal (Québec) H3C 3A7
Tel: (514) 340 - 4711 # 4805 / C552
Fax: (514) 340 - 4159
-=O=------------------------------------------=O=-

[Dan Pop]

In <87************ @pfaff.stanford .edu> Ben Pfaff <bl*@cs.stanfor d.edu> writes:

Instead, write it this way:

int *x = malloc (sizeof *x * 128);

Or, more readably:

int *x = malloc(128 * sizeof *x);

which tells to the human reader: I want to allocate space for 128 items
of that size.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Paul Hsieh]

Lionel Valero <li***********@ polymtl.ca> wrote:

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
*************** ********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
}
}
*************** ********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Well, the #include <...> headers that others have posted about will
fix the problem (the compiler thinks that malloc returns a 32bit int
because you didn't include a header file that says otherwise.)

But of course you have an additional problem that you did not define
the value of nka. Which is going to be another serious problem for
you to get the code working.

--
Paul Hsieh
http://www.pobox.com/~qed/
http://bstring.sf.net/

[Lionel Valero]

Sorry,

this code is a peace of code taken from a bigger one, i should have instancied
nka value to make it clearer.

Paul Hsieh wrote:

Lionel Valero <li***********@ polymtl.ca> wrote:

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
************* **********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
}
}
************* **********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Well, the #include <...> headers that others have posted about will
fix the problem (the compiler thinks that malloc returns a 32bit int
because you didn't include a header file that says otherwise.)

But of course you have an additional problem that you did not define
the value of nka. Which is going to be another serious problem for
you to get the code working.

--
Paul Hsieh
http://www.pobox.com/~qed/
http://bstring.sf.net/

--
-=O=------------------------------------------=O=-
Lionel Valéro
Analyste Informatique Département Génie Chimique
École Polytechnique de Montréal
C.P. 6079, succ. centre-ville
Montréal (Québec) H3C 3A7
Tel: (514) 340 - 4711 # 4805 / C552
Fax: (514) 340 - 4159
-=O=------------------------------------------=O=-

[E. Robert Tisdale]

Barry Schwarz wrote:

On a machine where the method of returning a pointer
differs from the method of returning an int
(such as using a different register),
Please tell us which machine does this.
the behavior is indeed undefined.
malloc will return the pointer using the correct procedure.
The compiler will generate code to convert the assumed returned int.
Since malloc did not return an int,
this code will operate on residual data.

Could you please code up an example
and run it on the machine that you reference above
so that we can see how it fails?

[Keith Thompson]

rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:

Joona I Palaste <pa*****@cc.hel sinki.fi> wrote:

Eric Sosman <Er*********@su n.com> scribbled the following:

"E. Robert Tisdale" wrote:
> Ben Pfaff wrote:
> > I don't recommend casting the return value of malloc():
> >
> > * The cast is not required in ANSI C.
>
> But an ANSI/ISO C++ compiler will complain.

Which proves once again that C++ is broken, since the cast is useless
and useless casts should be anathema.

<OT>
C++ is a different language than C, and there are valid reasons that
C++ disallows implicit conversions from void* to other pointer types.
These reasons don't apply to C. For details, see elsewhere.
</OT>

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"
(Note new e-mail address)

[Dan Pop]

In <79************ **************@ posting.google. com> qe*@pobox.com (Paul Hsieh) writes:

Lionel Valero <li***********@ polymtl.ca> wrote:

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
*************** ********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
}
}
*************** ********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Well, the #include <...> headers that others have posted about will
fix the problem (the compiler thinks that malloc returns a 32bit int
because you didn't include a header file that says otherwise.)

But of course you have an additional problem that you did not define
the value of nka. Which is going to be another serious problem for
you to get the code working.

I don't think that initialising nka is such a serious problem. Most
likely, this is the trimmed down version of his real program and he
trimmed too much.

What I find surprising is that, in this day and age, people still use
old style function definitions. Have they been asleep for the last 15
years or what?

And, while I can easily understand the usage of exit(1) to signal
failure (common convention under Unix and MSDOS), the usage of exit(-1)
keeps baffling me: I have yet to see a single implementation where the
value -1 is passed as such to the entity that launched the execution
of the program in question.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Dan Pop]

In <3F************ **@jpl.nasa.gov > "E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Barry Schwarz wrote:

On a machine where the method of returning a pointer
differs from the method of returning an int
(such as using a different register),

Please tell us which machine does this.

The x86 in certain memory models, where an int is 16 bits and a pointer
is 32 bits.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[E. Robert Tisdale]

Dan Pop wrote:

E. Robert Tisdale writes:

Barry Schwarz wrote:

On a machine where the method of returning a pointer
differs from the method of returning an int
(such as using a different register),

Please tell us which machine does this.

The x86 in certain memory models
where an int is 16 bits and a pointer is 32 bits.

Could you please code up an example
and run it on the machine that you reference above
so that we can see how it fails?

[Keith Thompson]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Barry Schwarz wrote:

On a machine where the method of returning a pointer
differs from the method of returning an int
(such as using a different register),

Please tell us which machine does this.

One example is gcc on IA-64 Linux, which has 64-bit pointers and
32-bit ints. (It doesn't use a different register, but the size
mismatch causes similar problems.)

the behavior is indeed undefined.
malloc will return the pointer using the correct procedure.
The compiler will generate code to convert the assumed returned int.
Since malloc did not return an int,
this code will operate on residual data.

Could you please code up an example
and run it on the machine that you reference above
so that we can see how it fails?

I did this some time ago; search the archives.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"
(Note new e-mail address)

[glen herrmannsfeldt]

E. Robert Tisdale wrote:

Barry Schwarz wrote:

On a machine where the method of returning a pointer
differs from the method of returning an int
(such as using a different register),

Please tell us which machine does this.

Any machine where sizeof(int) is different than sizeof(char*) will do.

Though this is more OS or function calling convention dependent than
machine dependent.

-- glen