format interne des pointeurs

Version imprimable

12/03/2007, 17h02
gorgonite

format interne des pointeurs

Salut,

Je me demande juste quel est le format "interne" dans lequel sont stockées les pointeurs dans la machine... je pensais qu'il s'agissait du type int dans mon cas (cpu intel 32 bits) ; mais après affichage, des valeurs de pointeurs avec le format %d je me retrouve avec un pointeur négatif :?

si quelqu'un comprend...

nb: je n'ai fait que stocker les pointeurs, sans faire d'opérations dessus ;)
12/03/2007, 17h32
Gruik

Ce sont des entiers 32 bit non signés
Or %d affiche un entier signé. Si l'adresse était superieure à 0x7fffffff, alors c'est normal que ça apparaisse comme un entier negatif
Utilise %p ou %lu

Le code de fonction()
Code:

1 2 3 4 5 6 7 void fonction(void) { int a = 100; int *p_int = &a; (void) p_int; }
donne chez moi le code assembleur suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 .globl fonction .type fonction, @function fonction: pushl %ebp movl %esp, %ebp subl $16, %esp movl $100, -8(%ebp) leal -8(%ebp), %eax movl %eax, -4(%ebp) leave ret
En interne avec gcc sur un processeur Intel PIII, il n'y a aucune différence entre la représentation d'un int et d'un pointeur.

Sinon, du point de vue compilateur, ce sont deux types différent. Cela n'a aucun sens de dire qu'un pointeur est représenté en interne par un int ou par un int non-signé. Tout ce qu'on peut dire, c'est que sur mon architecture particulière, la valeur contenue par un pointeur est stockée sur 32 bits.

Pour de l'affichage avec printf(), un pointeur a son propre spécificateur de format: %p.
Code:

1 2 3 4 5 6 void fonction(void) { int a = 100; int *p_int = &a; printf("La valeur de a est stockée sur la pile à l'adresse %p\n", (void *) p_int); }
Thierry

13/03/2007, 09h21
gorgonite

Citation:

Envoyé par mujigka

Cela n'a aucun sens de dire qu'un pointeur est représenté en interne par un int ou par un int non-signé. Tout ce qu'on peut dire, c'est que sur mon architecture particulière, la valeur contenue par un pointeur est stockée sur 32 bits.

désolé de te contredire, mais cela a un sens... :roll:
surtout quand on passe par des correspondances de Galois pour analyser un code. ;)

J'expose plus précisemment mon problème

J'ai des données stockées dans un grand tableau (alloué par une bibliothèque dont je n'ai pas le source), je parcours mon tableau, et je sélectionne certains patterns et j'enregistre dans un tableau que j'ai crée les pointeurs correspondants aux valeurs intéressantes...

toutes mes valeurs sont dans la plage 0x80[7-8]* sauf une qui est 0xb7d83372, sachant que cela ne devrait pas avoir lieu... etant donné la relativement petite taille du tableau de valeurs initial

quelqu'un saurait-il comment cela peut se produire ?

[EDIT]
sachant que si j'essaie d'accéder à la valeur qui serait stockée à la dite adresse je déclenche un SIGSEGV
donc j'essaie d'accéder à un bout de mémoire qui ne m'est pas destiné... :?
13/03/2007, 11h27
koala01

Salut,

Pour rappel, un pointeur, c'est une variable qui est un peu particulière en cela qu'elle contient... une adresse mémoire...

Il est donc logique d'estimer, les adresses mémoire commençant à ... 0 (pas d'adresse -123 ;)) que l'on travaille sur des valeurs non signées ;)

Comme les variables sont connues du processeur par leur adresse, il n'y a rien d'étonnant au fait que celle qui indque "l'adresse à laquelle commence le tableau" ne soit pas forcément à proximité... du début du tableau ;)

D'autant plus que, si le tableau en lui meme prend la place sur le tas, il est vraissemblable que "la variable qui prend l'adresse du tableau" prenne place, elle... sur la pile ;) (ou est-ce l'inverse :question::oops:)
14/03/2007, 09h59
Emmanuel Delahaye
Citation:

Envoyé par Gruik

Ce sont des entiers 32 bit non signés

... sur une machine donnée. Ce n'est pas une généralité. Je connais des pointeurs 16-bits... Et je ne serais pas étonné qu'ils fassent 64-bit sur les nouvelles architectures Intel...

Citation:

Or %d affiche un entier signé. Si l'adresse était superieure à 0x7fffffff, alors c'est normal que ça apparaisse comme un entier negatif
Utilise %p ou %lu

"%p" uniquement, sinon, le comportement est indefini. Et il faut un (void*).
Code:

1 2 3 4 5 int x; int *p = &x; printf ("%p\n", (void*) p);
14/03/2007, 10h08
gorgonite
Citation:

Envoyé par koala01

Comme les variables sont connues du processeur par leur adresse, il n'y a rien d'étonnant au fait que celle qui indque "l'adresse à laquelle commence le tableau" ne soit pas forcément à proximité... du début du tableau ;)

D'autant plus que, si le tableau en lui meme prend la place sur le tas, il est vraissemblable que "la variable qui prend l'adresse du tableau" prenne place, elle... sur la pile ;) (ou est-ce l'inverse :question::oops:)

normalement, n'y a-t-il pas utilisation de mémoire virtuelle de façon à obtenir un bloc contigu lors de l'allocation... ?

parce que là en gros, si j'essaie de parcours le tableau du premier pointeur à la fin... ben ça passe par une zone interdite, et tout plante

un peu dans ce genre
Code:

1 2 3 4 5 BYTE* list; while (*list++) { ... }
quelqu'un verrait-il une autre solution peu couteuse ?

nb: mon tableau fait environ 34 000 * sizeof(unsigned char)
14/03/2007, 10h57
Emmanuel Delahaye

Citation:

Envoyé par gorgonite

parce que là en gros, si j'essaie de parcours le tableau du premier pointeur à la fin... ben ça passe par une zone interdite, et tout plante

Si un pointeur a une valeur interdite, c'est qu'il y a un comportement indéfini dans ton programme, c'est tout.

Il faut corriger le bug.
14/03/2007, 11h00
gorgonite

Citation:

Envoyé par Emmanuel Delahaye

Si un pointeur a une valeur interdite, c'est qu'il y a un comportement indéfini dans ton programme, c'est tout.

Il faut corriger le bug.

le problème, c'est que ce tableau est généré par une API que je ne controle pas :cry:
14/03/2007, 11h06
jowo

Citation:

Envoyé par gorgonite

J'ai des données stockées dans un grand tableau (alloué par une bibliothèque dont je n'ai pas le source), je parcours mon tableau, et je sélectionne certains patterns et j'enregistre dans un tableau que j'ai crée les pointeurs correspondants aux valeurs intéressantes...

toutes mes valeurs sont dans la plage 0x80[7-8]* sauf une qui est 0xb7d83372, sachant que cela ne devrait pas avoir lieu... etant donné la relativement petite taille du tableau de valeurs initial

REMARQUE:
Ta bibliothèque autorise-t-elle d'accéder directement à un élément de son tableau ou dois-tu (par contrat ou par description de la documentation) y accéder seulemnet via une fonction de la bibliothèque?
14/03/2007, 11h08
gorgonite

Citation:

Envoyé par jowo

REMARQUE:
Ta bibliothèque autorise-t-elle d'accéder directement à un élément de son tableau ou dois-tu (par contrat ou par description de la documentation) y accéder seulemnet via une fonction de la bibliothèque?

directement... ils me fournissent le BYTE* tab et je dois me débrouiller sans connaitre la longueur :?
14/03/2007, 11h12
jowo

Citation:

Envoyé par gorgonite

directement... ils me fournissent le BYTE* tab et je dois me débrouiller sans connaitre la longueur :?

Utiliser un tableau sans connaître sa longueur. C'est de la barbarie.

Comment sais-tu que tu arrives à la fin de ton tableau?
14/03/2007, 11h16
gorgonite

Citation:

Envoyé par jowo

Utiliser un tableau sans connaître sa longueur. C'est de la barbarie.

Comment sais-tu que tu arrives à la fin de ton tableau?

pas besoin... en fait, je lis les motifs, et seulement sur certains motifs, je continue la lecture. à la fin, on a un motif pour terminer, et on quitte ;)
14/03/2007, 11h58
jowo

Citation:

Envoyé par gorgonite

pas besoin... en fait, je lis les motifs, et seulement sur certains motifs, je continue la lecture. à la fin, on a un motif pour terminer, et on quitte ;)

La seule raison pourquoi ton mécanisme ne fonctionne pas est tu ne détectes pas correctement le "motif de fin".

Sans code et sans autres informations sur la biblio, il est diffcile de t'aider plus ;)
14/03/2007, 12h33
gorgonite

Citation:

Envoyé par jowo

La seule raison pourquoi ton mécanisme ne fonctionne pas est tu ne détectes pas correctement le "motif de fin".

Sans code et sans autres informations sur la biblio, il est diffcile de t'aider plus ;)

je pense aussi... donc j'essaie de ruser en récupérant l'adresse du pointeur à la fin de la lecture par leur fonction "test" de parcours ;)

pour les sources, je ne peux malheureusement pas les fournir... trop longues, trop de fichiers dans tous les sens ; et surtout, je ne pense pas avoir l'autorisation :cry:
14/03/2007, 12h49
souviron34
juste une petite question :

ton adresse "singulière", ça serait pas par hasard l'adresse interne où est stockée l'adresse du tableau (ce qui expliquerait que tu n'y aies pas accès) ??

Exemple :

Si ils ont déclaré :
Code:

1 2 3 4 5 6 7 static double *MONTABLEAU=NULL ; ... MONTABLEAU = malloc (N); ....
Tu pourras sans doute d'après leur fonction accèder à l'adresse pointée par MONTABLEAU, mais certainment pas à la variable MONTABLEAU.
14/03/2007, 12h55
gorgonite

non j'ai vraiment accès à cette variable, et je peut la manipuler à ma guise...

cf while(*tab++)
14/03/2007, 12h57
souviron34

ce que je voulais dire, c'est :

es-tu sûr que cette adresse correspond à ton tableau ???
14/03/2007, 13h02
gorgonite

Citation:

Envoyé par souviron34

ce que je voulais dire, c'est :

es-tu sûr que cette adresse correspond à ton tableau ???

ben je lis des données cohérentes avec ce que j'attends... donc ça doit etre lui ;)

Comment as-tu programmé le parcours de ton tableau?

Une possibilité est
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 BYTE *table = NULL; BYTE *liste; BYTE elmnt; table = BiblioMaFonction(); if (table != null) { liste = table; while (*liste != FIN_DE_LISTE) { /* traitement d'un élément de la liste */ elmnt = *liste; /* élément suivant */ liste++; } } free(table);
Le code pour le parcours est simple. Il se peut que l'erreur provienne du traitement d'un élément de la liste (corruption des données internes du tableau table).

plutot comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
BYTE *table = NULL;
BYTE *liste;
BYTE *endOfListe;
BYTE elmnt;
 
table = BiblioMaFonction(&endOfListe);
if (table != null) {
    liste = table;
    while (liste < endOfListe) {
        /* traitement d'un élément de la liste */
        elmnt = *liste;
        ...
        if (elmnt == FIN_DE_LISTE)
            break;
        /* élément suivant */
        liste++;
    }
}
free(table);

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
BYTE *table = NULL;
BYTE *liste;
BYTE *endOfListe;
BYTE elmnt;
 
table = BiblioMaFonction(&endOfListe);
if (table != null) {
    liste = table;
    /* -fm- pour les pointeurs, je n'utilise que
       les opérateurs de comparaison == et !=.
        Faut-il traiter l'élément pointé par endOfListe?
    */
    while (liste  != endOfListe) {
        /* traitement d'un élément de la liste */
        elmnt = *liste;
        ...
        if (elmnt == FIN_DE_LISTE) {
            break;
        }
        /* élément suivant */
        liste++;
    }
}
free(table);

14/03/2007, 14h30
gorgonite

pourquoi pas les autres opérateurs de comparaisons... ?
ce serait génant, parce qu'en fait suivant le caractère que je lis je peux avancer de 2 ou 3 et non de 1 ;)

Citation:

Envoyé par gorgonite

pourquoi pas les autres opérateurs de comparaisons... ?
ce serait génant, parce qu'en fait suivant le caractère que je lis je peux avancer de 2 ou 3 et non de 1 ;)

Je ne suis pas un gourou du C donc je n'ai pas d'arguments pour consolider mon intuition.

Mais as-tu déjà essayer de faire un "dump" de ton tableau?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 BYTE *table = NULL; BYTE *liste; BYTE *endOfListe; BYTE elmnt; size_t count; table = BiblioMaFonction(&endOfListe); if (table != null) { liste = table; count = 0; while (liste != endOfListe) { /* traitement d'un élément de la liste */ elmnt = *liste; fprintf(stderr, "%p [%u] %d\n", list, count, elmnt); count++; if (elmnt == FIN_DE_LISTE) break; /* élément suivant */ liste++; } } free(table); fprintf(stderr, "%u éléments ont été visités\n", i);

15/03/2007, 09h38
gorgonite

j'ai déjà essayé... mais le problème est que le endOfListe renvoyé est parfois (pas toujours) tellement loin du début qu'il y a des blocs de mémoire "étrangers" au milieu du parcours
15/03/2007, 10h19
jowo

Es-tu sûr que la fonction de la bibliothèque fonctionne correctement?

Es-tu sûr que la fonction retourne bien un tableau de type BYTE?

Peux-tu poster le prototype de la fonction?

Un tableau est une zone mémoire contiguë donc il ne devrait pas avoir de "bloc de mémoire étrangers".

Car là, je ne vois plus aucune solution.
15/03/2007, 10h36
gorgonite

malheureusement je ne peux pas... je vais essayer de me débrouiller avec les indices que vous m'avez fournis

je vous recontacterai quand j'aurais un problème plus précis... pour pouvoir mettre un morceau de source "anodin" sur le forum ;)

:merci: à tous
16/03/2007, 14h58
gorgonite

Citation:

Envoyé par gorgonite

je vous recontacterai quand j'aurais un problème plus précis... pour pouvoir mettre un morceau de source "anodin" sur le forum ;)

Je crois avoir trouvé d'où viennent ses adresses de pointeurs bizarres au milieu de mon tableau...

en fait, je suis en train de compléter une machine virtuelle en C qui interprète du bytecode... le code est représenté sous la forme d'un tableau d'instructions (alloué dans la vm par une librairie à laquelle je n'ai pas accès)

je reçois le BYTE* instr (et oui il y a moins de 256 instructions dans cette vm ;))
je le parcours à la recherche de certains motifs, et je note les valeurs du pointeur de code à ce moment (qui devrait se balader uniquement dans ce tableau), et parfois j'en sors complètement... ce qui m'empeche d'accéder à la case mémoire en question (alors qu'a priori, on ne fait que des instr++

en fait, j'ai l'impression que la vm a "pointé" certaines cases sur l'adresse de fonctions C natives pour les appeler "dynamiquement" ; qu'en pensez-vous ? est-ce possible de faire cela en C ? (a priori, les pointeurs de fonctions marchent... :roll:)
16/03/2007, 15h02
Emmanuel Delahaye

Citation:

Envoyé par gorgonite

je reçois le BYTE* instr (et oui il y a moins de 256 instructions dans cette vm ;))

Quel rapport ? Il n'y a pas que les instructions, il y a aussi certainement des paramètres, des constantes, des données, des références, des adresses...

Citation:

je le parcours à la recherche de certains motifs, et je note les valeurs du pointeur de code à ce moment (qui devrait se balader uniquement dans ce tableau), et parfois j'en sors complètement... ce qui m'empeche d'accéder à la case mémoire en question (alors qu'a priori, on ne fait que des instr++

Ca peut vouloir dire tout simplement que le motif n'a pas été trouvé. (absent, mal lu...)

Citation:

en fait, j'ai l'impression que la vm a "pointé" certaines cases sur l'adresse de fonctions C natives pour les appeler "dynamiquement" ; qu'en pensez-vous ? est-ce possible de faire cela en C ? (a priori, les pointeurs de fonctions marchent... :roll:)

Impossible. Pointer ne veut pas dire exécuter, surtout que c'est un pointeur sur objet.
16/03/2007, 15h07
gorgonite

Citation:

Envoyé par Emmanuel Delahaye

Ca peut bouloir dire tout simplement que le motif n'a pas été trouvé. (absent, mal lu...) Il faut donc aussi limiter la lecture à 256 instructions (je ne sais pas ce que ça fait en bytes).

j'ai oublié de préciser

Code:

#define BYTE unsigned char

Citation:

Envoyé par Emmanuel Delahaye

Impossible. Pointer ne veut pas dire exécuter, surtout que ce sont des pointeurs sur objet.

oui mais justement, je repère les instructions qui font des sauts dans le code pour optimiser quelques petits trucs... et justement, j'enregistre les adresses de destination. donc s'il tombe sur le bytecode invocation_de_fonction_native, il place le pointeur de code sur la valeur du pointeur de fonctions, appelles la fonction d'invocation dynamique, qui va exécuter cette fonction grace à son pointeur
c'est possible ?
16/03/2007, 15h15
Emmanuel Delahaye

Citation:

Envoyé par gorgonite

oui mais justement, je repère les instructions qui font des sauts dans le code pour optimiser quelques petits trucs... et justement, j'enregistre les adresses de destination. donc s'il tombe sur le bytecode invocation_de_fonction_native, il place le pointeur de code sur la valeur du pointeur de fonctions, appelles la fonction d'invocation dynamique, qui va exécuter cette fonction grace à son pointeur
c'est possible ?

Si tu manipules des pointeurs de fonctions, tu ne peux pas faire de sauts, mais des call. Il n'y a aucun moyen de fait des sauts programmable en C.

Ce que tu fais (VM) m'a l'air excessivement casse-gueule et demande des précautions d'emploi draconiennes. Sans avoir d'exemple précis de code et de données, impossible d'en dire plus. On est pas dans ta tête...
16/03/2007, 15h20
gorgonite

Citation:

Envoyé par Emmanuel Delahaye

Ce que tu fais (VM) m'a l'air excessivement casse-gueule et demande des précautions d'emploi draconiennes. Sans avoir d'exemple précis de code et de données, impossible d'en dire plus. On est pas dans ta tête...

ben je n'ai accès qu'à la partie interprétation du bytecode par la vm... et pour ce genre d'invocation, ça appelle une énorme macro définie ailleurs :?
16/03/2007, 15h45
Emmanuel Delahaye

Citation:

Envoyé par gorgonite

ben je n'ai accès qu'à la partie interprétation du bytecode par la vm... et pour ce genre d'invocation, ça appelle une énorme macro définie ailleurs :?

Tu peux quand même poster une description du motif recherché, un bout de bytecode (en attaché, zip etc.) et la fonction qui cherche le motif dedans... On verra bien si c'est cohérent.

nb: le code est plein de variables globales... :?

la licence du code est

Citation:

* Copyright © 2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
SELECT(INVOKEVIRTUAL)
        unsigned int cpIndex;
        METHOD cpMethod;
 
        /* Get the constant pool index */
        cpIndex = getUShort(ip + 1);
 
        /* Resolve constant pool reference */
        VMSAVE
        cpMethod = resolveMethodReference(cp_global, cpIndex, FALSE,
                                          fp_global->thisMethod->ofClass);
        VMRESTORE
        if (cpMethod) {
            CLASS dynamicClass;
...
            dynamicClass = thisObject->ofClass;
 
            /* Find the actual method */
            VMSAVE
            thisMethod = lookupDynamicMethod(dynamicClass, cpMethod);
            VMRESTORE
 
            if (thisMethod) {
                TRACE_METHOD_ENTRY(thisMethod, "virtual");
                CALL_VIRTUAL_METHOD
            } else {  ... }
       else {    ...        }
DONE(0)

Code:

#define CALL_VIRTUAL_METHOD { goto callMethod_virtual; }

Code:

1
2
3
4
5
6
7
8
9
10
callMethod_virtual:
...
            /* Check if the method is a native method */
            if (thisMethod->accessFlags & ACC_NATIVE) {
                ip += invokerSize;
                invokeNativeFunction(thisMethod);
                TRACE_METHOD_EXIT(thisMethod)
                goto reschedulePoint;
            }
...

voilà ce que je peux fournir... on n'a pas touché à ce morceau d'après mes infos, donc les sources de Sun correspondent aux binaires que j'ai ;)

21/03/2007, 00h15
gorgonite

alors aucune idée... :?

Fuseau horaire GMT +2. Il est actuellement 18h58.