pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
convertir un pointeur void* en pointeur de fonction void (*)(void).
Dans la documentation de dlym (Linux et Open Posix), il est
recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide.
convertir un pointeur void* en pointeur de fonction void (*)(void).
Dans la documentation de dlym (Linux et Open Posix), il est
recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide.
convertir un pointeur void* en pointeur de fonction void (*)(void).
Dans la documentation de dlym (Linux et Open Posix), il est
recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide.
Le 12/06/2009 20:30, Laurent Deniau écrivit :
> convertir un pointeur void* en pointeur de fonction void (*)(void).
Et tu espères que cela soit portable ? :^)
Sur un OS que je pratique ces jours-ci, savoir Minix sur i386, qui est
pourtant dûment estampillé Posix, le code (.text) est dans un espace
d'adressage différent des données (.data/.bss) : on ré-utilise le t ruc
des espaces séparés, qui servait sur les PDP11 et autres 8086 d'avoir
64K+64K... soit +100% d'espace !
Inutile de dire qu'avec ce genre d'architecture, les pointeurs vers
fonctions et les pointeurs vers données sont parfaitement incommen-
surables...
Maintenant histoire d'enfoncer le clou, considères un instant le modè le
"medium" des compilos 8086, où les pointeurs vers fonctions étaient s ur
32 bits et les pointeurs vers données étaient sur 16 bits...
Comment ton truc peut-il bien fonctionner sans invoquer des
comportements indéfinis (par la norme) ?
> Dans la documentation de dlym (Linux et Open Posix), il est
> recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide.
Mouais... sachant que dlsym doit servir 95% du temps à récupérer de s
fonctions, on pourrait le définir avec comme prototype
intptr_t dlsym(void*, const char*);
ce serait tout autant valable... et un poil moins sale.
Comment disaient-ils ? Tous les ordinateurs sont des Vax ? :^)
Enfin bon, c'est mon avis, hein.
Le 12/06/2009 20:30, Laurent Deniau écrivit :
> convertir un pointeur void* en pointeur de fonction void (*)(void).
Et tu espères que cela soit portable ? :^)
Sur un OS que je pratique ces jours-ci, savoir Minix sur i386, qui est
pourtant dûment estampillé Posix, le code (.text) est dans un espace
d'adressage différent des données (.data/.bss) : on ré-utilise le t ruc
des espaces séparés, qui servait sur les PDP11 et autres 8086 d'avoir
64K+64K... soit +100% d'espace !
Inutile de dire qu'avec ce genre d'architecture, les pointeurs vers
fonctions et les pointeurs vers données sont parfaitement incommen-
surables...
Maintenant histoire d'enfoncer le clou, considères un instant le modè le
"medium" des compilos 8086, où les pointeurs vers fonctions étaient s ur
32 bits et les pointeurs vers données étaient sur 16 bits...
Comment ton truc peut-il bien fonctionner sans invoquer des
comportements indéfinis (par la norme) ?
> Dans la documentation de dlym (Linux et Open Posix), il est
> recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide.
Mouais... sachant que dlsym doit servir 95% du temps à récupérer de s
fonctions, on pourrait le définir avec comme prototype
intptr_t dlsym(void*, const char*);
ce serait tout autant valable... et un poil moins sale.
Comment disaient-ils ? Tous les ordinateurs sont des Vax ? :^)
Enfin bon, c'est mon avis, hein.
Le 12/06/2009 20:30, Laurent Deniau écrivit :
> convertir un pointeur void* en pointeur de fonction void (*)(void).
Et tu espères que cela soit portable ? :^)
Sur un OS que je pratique ces jours-ci, savoir Minix sur i386, qui est
pourtant dûment estampillé Posix, le code (.text) est dans un espace
d'adressage différent des données (.data/.bss) : on ré-utilise le t ruc
des espaces séparés, qui servait sur les PDP11 et autres 8086 d'avoir
64K+64K... soit +100% d'espace !
Inutile de dire qu'avec ce genre d'architecture, les pointeurs vers
fonctions et les pointeurs vers données sont parfaitement incommen-
surables...
Maintenant histoire d'enfoncer le clou, considères un instant le modè le
"medium" des compilos 8086, où les pointeurs vers fonctions étaient s ur
32 bits et les pointeurs vers données étaient sur 16 bits...
Comment ton truc peut-il bien fonctionner sans invoquer des
comportements indéfinis (par la norme) ?
> Dans la documentation de dlym (Linux et Open Posix), il est
> recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide.
Mouais... sachant que dlsym doit servir 95% du temps à récupérer de s
fonctions, on pourrait le définir avec comme prototype
intptr_t dlsym(void*, const char*);
ce serait tout autant valable... et un poil moins sale.
Comment disaient-ils ? Tous les ordinateurs sont des Vax ? :^)
Enfin bon, c'est mon avis, hein.
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* e n
pointeur de fonction void (*)(void).
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* e n
pointeur de fonction void (*)(void).
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* e n
pointeur de fonction void (*)(void).
On 12 juin, 22:30, ld wrote:Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void).
C'est pas portable. (voire interdit par la norme si je me souviens
bien). Rien ne dit qu'un registre de données ait le droit de pointer
sur une zone de code exécutable, ni qu'il ait la même taille...Le
comportement est indéfini.
On 12 juin, 22:30, ld <Laurent.Den...@gmail.com> wrote:
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void).
C'est pas portable. (voire interdit par la norme si je me souviens
bien). Rien ne dit qu'un registre de données ait le droit de pointer
sur une zone de code exécutable, ni qu'il ait la même taille...Le
comportement est indéfini.
On 12 juin, 22:30, ld wrote:Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void).
C'est pas portable. (voire interdit par la norme si je me souviens
bien). Rien ne dit qu'un registre de données ait le droit de pointer
sur une zone de code exécutable, ni qu'il ait la même taille...Le
comportement est indéfini.
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void). Dans la documentation de dlym
(Linux et Open Posix), il est recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
avec gcc4 j'ai un magnifique
warning: dereferencing type-punned pointer will break strict-aliasing
rules
pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void). Dans la documentation de dlym
(Linux et Open Posix), il est recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
avec gcc4 j'ai un magnifique
warning: dereferencing type-punned pointer will break strict-aliasing
rules
pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
Je suis entrain de mettre en place la gestion des plug-in dans COS et
je suis tombé sur le problème de devoir convertir un pointeur void* en
pointeur de fonction void (*)(void). Dans la documentation de dlym
(Linux et Open Posix), il est recommandé de faire:
void (*symbol)(void);
*(void**) &symbol = dlsym(lib_handle, symbol_name);
avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
avec gcc4 j'ai un magnifique
warning: dereferencing type-punned pointer will break strict-aliasing
rules
pour éliminer le warning (que je ne veux pas désactiver) je passe par
une variable intermédiaire
void **tmp = (void**)&symbol;
*tmp = dlsym(lib_handle, symbol_name);
et le warning disparaît.
Alors est-ce que le problème est résolu (et portable) ou j'ai
seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
On 2009-06-12, ld wrote:
> Je suis entrain de mettre en place la gestion des plug-in dans COS et
> je suis tombé sur le problème de devoir convertir un pointeur void* en
> pointeur de fonction void (*)(void). Dans la documentation de dlym
> (Linux et Open Posix), il est recommandé de faire:
> void (*symbol)(void);
> *(void**) &symbol = dlsym(lib_handle, symbol_name);
> avec void *dlsym(void*, const char*), qui selon eux est valide. Mais
> avec gcc4 j'ai un magnifique
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules
> pour éliminer le warning (que je ne veux pas désactiver) je passe p ar
> une variable intermédiaire
> void **tmp = (void**)&symbol;
> *tmp = dlsym(lib_handle, symbol_name);
> et le warning disparaît.
> Alors est-ce que le problème est résolu (et portable) ou j'ai
> seulement trompé gcc? Ca sent le UB à plein nez tout ca, non?
D'apres :
http://www.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html
<cite>
2.12.3 Pointer Types
All function pointer types shall have the same representation as the
type pointer to void. Conversion of a function pointer to void * shall
not alter the representation. A void * value resulting from such a
conversion can be converted back to the original function pointer type,
using an explicit cast, without loss of information.
Note:
The ISO C standard does not require this, but it is required for
POSIX conformance.
</cite>
Comme Linux est POSIX, forcement ca marche. Par contre, en dehors d'un
systeme POSIX, vous prenez des risques.
A plus,
--
Bruno Ducrot
-- Which is worse: ignorance or apathy?
-- Don't know. Don't care.
- Si dlsym n'est pas disponible, le code en question est remplacé par
un code qui lève une exception.
- Si dlsym n'est pas disponible, le code en question est remplacé par
un code qui lève une exception.
- Si dlsym n'est pas disponible, le code en question est remplacé par
un code qui lève une exception.
Cette partie de la norme n'existe que dans le nouveau draft POSIX
2008, non encore implémenté, et est encore activement discuté par les
membres de l'opengroup.
J'attend moi aussi avec impatience LE pointeur de fonction générique
mais il faut encore patienter...
Cette partie de la norme n'existe que dans le nouveau draft POSIX
2008, non encore implémenté, et est encore activement discuté par les
membres de l'opengroup.
J'attend moi aussi avec impatience LE pointeur de fonction générique
mais il faut encore patienter...
Cette partie de la norme n'existe que dans le nouveau draft POSIX
2008, non encore implémenté, et est encore activement discuté par les
membres de l'opengroup.
J'attend moi aussi avec impatience LE pointeur de fonction générique
mais il faut encore patienter...