[Pointer integer different size] 64 bits ?

Version imprimable

Bonjour,

la machine : ia64 SuseLinux

J'ai compilé un code avec gcc sous environnement 64 bits.

Citation:

gcc -v :Configured with: ../configure --enable-threads=posix --prefix=/usr --with-local-prefix=/usr/local --infodir=/usr/share/info --mandir=/usr/share/man --enable-languages=c,c++,f77,objc,java,ada --disable-checking --libdir=/usr/lib --enable-libgcj --with-gxx-include-dir=/usr/include/g++ --with-slibdir=/lib --with-system-zlib --enable-shared --enable-__cxa_atexit ia64-suse-linuxThread model: posix
gcc version 3.3.3 (SuSE Linux)

Lors de l'execution j'ai le plantage suivant

Citation:

forrtl: severe (174): SIGSEGV, segmentation fault occurred
Image PC Routine Line Source
libc.so.6.1 2000000000C201F0 Unknown Unknown Unknown

Après passage dans gdb, je vois que le plantage vient de la libraire : xvertex.5.0 routine rotate.c au niveau de l'utilisation de strcpy.

Si dessous le bout de code de rotate.c qui plante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 /**************************************************************************/ /* Routine to mimic `strdup()' (some machines don't have it) */ /**************************************************************************/ static char *my_strdup(str) char *str; { char *s; if(str==NULL) return NULL; s=(char *)malloc((unsigned)(sizeof(str)+1)); if(s!=NULL) strcpy(s, str); return s; }
Lors de la compilation de rotate.c j'ai le message suivant :

Citation:

rotated.c:168: warning: cast to pointer from integer of different size

correspondant à la ligne en bleu dans le bout de code au-dessus.

Après un peu de recherche sur internet, ça pourrait provenir de la compilation en 64 bits qui laisse le entier en 32 bits et le pointeur en 64 bits. Mais bon, j'ai très peu de connaissance en C, malloc, pointeur.

Si quelqu'un aurait une idée de comment s'en sortir, ça serait très sympa.

Merci

05/09/2008, 11h47
Médinoc
Je parie que tu as oublié de déclarer malloc() en incluant <stdlib.h>.

Et ce code est excécrable:
- En 32 bits, l'erreur serait passée inaperçu. C'est justement pour ça qu'on ne caste pas le retour de malloc() en C.
- sizeof(str) retourne la taille du pointeur. Il faut utiliser la fonction strlen().
- Les déclarations de fonction style K&R, c'est obsolète.
- str devrait être un pointeur const, puisque la fonction ne modifie pas la chaîne.
- malloc() prend déjà un size_t en paramètre: Il faut donc retirer le cast du sizeof en unsigned int.
05/09/2008, 11h49
Jean-Marc.Bourguet

Cela vient que tu n'inclus pas stdlib.h qui fourni le prototype correct de malloc.
En passant ajoute -Wmissing-prototypes a tes options et fixe tous les warnings qui en resultent.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
(tout en haut)
#include <stdlib.h>
#include <string.h>
 
/**************************************************************************/
/* Routine to mimic `strdup()' (some machines don't have it) */
/**************************************************************************/
 
static char *my_strdup(char const *str)
{
	char *s;
 
	if(str==NULL)
		return NULL;
 
	s = malloc(strlen(str)+1);
	if(s!=NULL)
		strcpy(s, str);
 
	return s;
}

05/09/2008, 11h58
earl29

Merci pour ces réponses.
Si je rajoute les bonnes déclarations des librairies en entête ça semble marcher.
05/09/2008, 12h19
Médinoc

Un conseil, profites-en pour corriger aussi le reste de la fonction...

Citation:

Envoyé par earl29

Si dessous le bout de code de rotate.c qui plante :

Ce style de codage est déprécié depuis 1989, date de la publication de la version ANSI de la spec du C, reprise en 1990 par l'ISO (C90).

Il y a un bug dans ton code. La taille allouée est fausse. C'est pas sizeof (taille du pointeur), mais strlen() (longueur de la chaine).

Faut pas aller chercher des choses compliquées (32-bit/64-bit, rien à voir...). Il faut commencer par écrire du code correct.

Ce code fonctionne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdlib.h> ... static char *my_strdup (char const *str) { char *s; if (str == NULL) return NULL; s = malloc (strlen (str) + 1); if (s != NULL) strcpy (s, str); return s; }
Mais je préfère éviter les return multiples :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <stdlib.h> ... /* Routine to mimic `strdup()' (some machines don't have it) */ static char *my_strdup (char const *str) { char *s = NULL; if (str != NULL) { size_t size = strlen (str) + 1; s = malloc (size); if (s != NULL) { memcpy (s, str, size); } } return s; }

05/09/2008, 14h10
Emmanuel Delahaye

Citation:

Envoyé par earl29

Merci pour ces réponses.
Si je rajoute les bonnes déclarations des librairies en entête ça semble marcher.

Ca ne suffit pas. Il fait corriger ce qui a été signalé. 'semble marcher' ça ne veut rien dire.
05/09/2008, 16h23
earl29

1/ Le sizeof est un test de ma part mais le code contient strlen. J'ai malencontreusement posté le code avec mon test => ok pour l'erreur mais j'y connais rien C;

2/ la librairie date des années 80 d'où le codage qui n'est pas à la "norme" !!!

3/ le prog complet a toujours été utilisé sur des machines 32 bits. C'est seulement depuis les tests en compilation 64 bits que le problème de segmentation apparait.
05/09/2008, 18h15
nicolas.sitbon

Citation:

Envoyé par earl29

3/ le prog complet a toujours été utilisé sur des machines 32 bits. C'est seulement depuis les tests en compilation 64 bits que le problème de segmentation apparait.

La plupart des architectures 64bits sont au format LP64, la ligne incriminé dans ton programme est celle ci:

Code:

s=(char *)malloc((unsigned)(sizeof(str)+1));

Elle fonctionnait en 32 bits car la taille d'un unsigned était égale à la taille d'un size_t, hors dans une archi 64bits LP64, un size_t fait 64bits et un unsigned n'en fait que 32. Il est probable qu'il y est eu perte d'information (ici ou ailleurs car je ne connais pas le reste du code).
06/09/2008, 11h22
Médinoc

Windows est en LLP64, qui présente les mêmes problèmes que ceux décrits par Nicolas.