format interne des pointeurs

**gorgonite** · 14/03/2007, 14h50

plutot comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

**jowo** · 14/03/2007, 15h26

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

**gorgonite** · 14/03/2007, 15h30

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

**jowo** · 14/03/2007, 19h23

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

**gorgonite** · 15/03/2007, 10h38

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

**jowo** · 15/03/2007, 11h19

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.

**gorgonite** · 15/03/2007, 11h36

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

à tous

**gorgonite** · 16/03/2007, 15h58

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...

)

**Emmanuel Delahaye** · 16/03/2007, 16h02

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...

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...)

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...

)

Impossible. Pointer ne veut pas dire exécuter, surtout que c'est un pointeur sur objet.

**gorgonite** · 16/03/2007, 16h07

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

#define BYTE unsigned char

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 ?

**Emmanuel Delahaye** · 16/03/2007, 16h15

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...

**gorgonite** · 16/03/2007, 16h20

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

**Emmanuel Delahaye** · 16/03/2007, 16h45

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.

**gorgonite** · 16/03/2007, 17h17

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

la licence du code est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

#define CALL_VIRTUAL_METHOD   {      goto callMethod_virtual;          }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**gorgonite** · 21/03/2007, 01h15

alors aucune idée...

format interne des pointeurs

C

Discussions similaires

Partager

Partager