format interne des pointeurs

Version imprimable

Voir 40 message(s) de cette discussion en une page

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

Voir 40 message(s) de cette discussion en une page