adresse d'un fonction - Page 1

comment peut on retrouver l'adresse d'une fonction?

Si tu as la fonction :
void Fonction(void) { ... }

essaie : (char *)Fonction

&fonction

dans les cas où je veux passer un pointeur sur une fonction en param d'une autre fonction, ça marche

tout a fait ... c le truc qui m'avait surpris dans un boukin sur le C ..

c surprenant, mais bon, c du C
=> la puissance avant tout (même si ça permet de faire tout et n'importe quoi )

pourquoi quand je veux mettre l'adresse de la fonction en mémoire (à une adresse précise), gcc me dit
warning: assignment makes integer from pointer without a cast.

En plus ça a pas l'air de marcher.

j'utilise ça:

*(u16*)0x3007ffc=&func;

heu...
je sais pas trop.
(vive les pointeurs)

essaye de supprimer la première étoile...

à non.
déjà, ya quelque chose qui va pas : sur proc M68k, les adresses sont sur 32bits (enfin, sur 245 bits, vu que le bus d'adresse est de 24 bits), mais elles sont mémorisées sur 32 bits...
or, u16, je suppose que c 16 bits (unsigbed short, sur 16 bits, surement)
=> déjà là, y'a qqc qui va pas aller

Il me semblait que l'adrese d'une fonction s'obtenait en écrivant le nom de la fonction sans parenthèses (donc pas besoin de &)

Méthode utilisée pour déterminer la taille d'une fonction (cf. FAQ de TIGCC) :
void MyFunction(void)
{
// The function body...
}
void End_Marker(void);
asm("End_Marker:")
...
...
num_of_bytes = (char*)End_Marker - (char*)MyFunction;

D'où le post #1 et ta remarque, Thibaut.

ouias excusez moi u16 c'est unigned short.
Comme je travaille sur gba je pense ps que ce soit pareill que sur m68k.
Par contre ce que j'aimerais savoir c'est pourquoi il ya ce warning

Essaie :
*(u16*)0x3007ffc=(u16*)(&func);
ou
*(u16*)0x3007ffc=(u16*)(func);

Merde j'avais oublié de répondre au post #5, désolé
C'est quoi l'adresse 0x3007ffc ? un vecteur vers ta fonction (c'est à dire que les 4 octets à partir de 0x3007ffc doivent contenir l'adresse de ta fonction) ?

Il nous faudrait déjà savoir ça pour pouvoir te répondre

ça me fait toujours la même chose..

en fait ce que contient l'adresse 0x3007ffc c'est l'adresse de la fonction vers laquelle le processeur doit s'orienter lors d'un interuption. c'est ce que j'en ai déduit d'aprés ça:

It then passes control to the address stored in the memory address 0x3007FFC. This is where we need to put our interrupt handler. What do I mean by that? That just means that the we need to point that register to our interrupt handler by making it equal to our interrupt handlers address

Alors ce qu'il faut écrire c'est : *(void **)0x3007ffc= &func;

Et s'il te fait chier avec le type du pointeur, alors fait plutôt : *(void **)0x3007ffc= (void *)func;

voilà; un pro des pointeurs....

J'arrive pas toujours à bien comprendre la syntaxe des pointeurs... c'est embétant c'est un des trucs les plus importants.

void * = emplacement en mémoire qui contient l'adresse d'une variable (ou d'une focntion) dont le type est quelconque (void signifie "indéfini") => c'est un pointeur "classique"

void ** = emplacement en mémoire qui contient l'adresse d'une variable qui est en fait un pointeur vers une variable (ou d'une fonction) dont le type est quelconque (void signifie "indéfini") => c'est un pointeur qui pointe () vers un pointeur "classique"

(void **)0x3007ffc = transtype le nombre 0x3007ffc en un un pointeur qui pointe vers un pointeur "classique"

*((void **)0x3007ffc)= adresse_de_la_fonction = écriture de l'adresse de la fonction à l'emplacement pointé par le nombre 0x3007ffc, bref à l'adresse 0x3007ffc


J'ai été assez clair ?

trop simple je v vous expliquer mais pas ménen g plein de choses a faire ai barth ton truc sa marche poa

lolllll carbune Retourne dans ton forum PHP au lieu de venir flooder des conneries ici

Thibaut a écrit :
Il me semblait que l'adrese d'une fonction s'obtenait en écrivant le nom de la fonction sans parenthèses (donc pas besoin de &)

Pour les fonctions et les tableaux, si on ne met que leur nom, le & est sous-entendu.

Thibaut a écrit :
Alors ce qu'il faut écrire c'est : *(void **)0x3007ffc= &func;

En effet, c'est la solution la plus propre. Une autre est:
*(u32 *)0x3007ffc=(u32)&func;
mais il faut savoir la taille d'un pointeur, et celle-ci dépend de l'architecture. Donc il vaut mieux utiliser le vrai type: void **.

Donc on aurait pu mettre :
*(void **)0x3007ffc= func; ?

Oui.