[^]Re: ASM

[^]Re: *

• [^]Re: *

  Posté par alveric () le 26/12/2006 à 08:02. (lien). Évalué à 2.

  Problème de précédence : (*alloc).addStart.

[^]Re: .

• [^]Re: .

  Posté par Pierre Maziere () le 22/12/2006 à 02:01. (lien). Évalué à 7.

  Arrgggg je viens de passer 30 min a pondre un pave pour essayer de t'expliquer ca et je me suis rendu compte que ca t'embrouillerai plus la tete qu'autre chose.

  • Pour faire simple, pour un tableau T contenant n variable de structure S telle que:

    struct S
    {
      int v;
    }
    

  • "." s'emploie lorsque la memoire utilisee pour stocker T est allouee de maniere statique:

    struct S T[n]; /* Tableau de n variable de structure S.
                            A la compilation, le compilateur sait qu'il doit reserver n blocs 
                            consecutifs de memoire de taille sizeof(S), soit 4 octets sur une 
                            architecture 32 bits.
                        */
    

    on aura alors:

    T[0].v=0xdeadbeef+0;
    .
    .
    .
    T[n].v=0xdeadbeef+n;
    

  • "->" s'emploie lorsque la memoire utilisee pour stocker T est allouee de maniere dynamique:

    struct S *T; /* Pointeur vers une zone memoire a definir qui contiendra un nombre 
                         de structure S qui est inconnu au moment  de la compilation.
                      */
    T=malloc(n*sizeof(S)); /* on alloue cette zone memoire pour n structures S 
                                           au moment de l'execution du programme.
                                        */
    

    on aura alors:

    T[0]->v=0xdeadbeef+0;
    .
    .
    .
    T[n]->v=0xdeadbeef+n;
    

    La difference se fait dans la maniere dont le programme va chercher ses donnees:
  • "." indique que les donnees se trouvent directement a la suite de l'adresse memoire T.
  • "->" indique que les donnees se trouvent a l'adresse qui est stockee à l'adresse memoire T.
  • Je ne sais pas si j'ai ete suffisament clair, mais a cette heure ci c'est tout ce que je peux faire !
  • PS: ce systeme de balise sans retour chariot est vraiment tout pourrite!

  • [^]Re: .

    Posté par Pierre Maziere () le 22/12/2006 à 02:17. (lien). Évalué à 2.

    j'oubliais:
    

    *alloc.addrStart = 0xdeadbeef;
    Me renvoit l'erreur illegal indirection...

    
    
    parce que l'operateur * sert a dereferencer un pointeur.
    
    si alloc est un pointeur, *alloc correspond a l'adresse stockee dans alloc
    et alloc->addrStart est equivalent a (*alloc).addrStart (les parentheses sont importantes)
    
    si alloc est une variable statique, *alloc ne correspond pas a une adresse memoire, mais a la valeur d'une variable. Donc *alloc.addrStart equivaut a prendre cette valeur comme une adresse memoire (ce qu'elle n'est pas sauf effet de bord) et a regarder ce qu'elle contient, ce qui mene irremediablement a une erreur.

  • [^]Re: .

    Posté par nats (Jabber id, page perso, ) le 22/12/2006 à 08:02. (lien). Évalué à 1.

    Merci beaucoup des explications :)
    Mais en fait je pense que ce que je veux faire n'est pas possible aussi directement.
    mais en gros c'est l'equivalent de:
    
    DWORD data = 0xdeadbeef;
    memcpy(alloc.addrStart, &data, sizeof(DWORD));
    
    
    mais sans memcpy. Mais en fait je me suis resigné car en regant un peu apres la compile...
    
    00401014 |. C700 EFBEADDE MOV DWORD PTR DS:[EAX],DEADBEEF
    
    Miracle :) Ca n'a pas rajouter de saloperie :)
    En gros si j'ai bien compris je suis obliger de recup alloc.addrStart et de pointer dessus, apparement la syntaxe pour faire ca d'un coup ne passe vraiment pas.

    --
    On vous ment! Mais pas moi...

    • [^]Re: .

      Posté par David Decotigny (page perso, ) le 22/12/2006 à 20:27. (lien). Évalué à 3.

      Je ne comprends pas trop ton problème. Bon, c'est sur, le memcpy avec gcc se compile plutot bien, mais une solution plus directe serait :

        DWORD * ptr = alloc.addrStart;
        *ptr = 0xdeadbeef;
      

      Ou encore, en moins lisible :

         * (DWORD*)(alloc.addrStart) = 0xdeadbeef;
      

      Ca genere le meme code que memcpy. Par exemple, si je compile avec gcc -O -fomit-frame-pointer, alors objdump -M intel -S me dit :

       8048330:       a1 64 95 04 08          mov    eax,ds:0x8049564
       8048335:       c7 00 ef be ad de       mov    DWORD PTR [eax],0xdeadbeef
      

      --
      d2

      • [^]Re: .

        Posté par nats (Jabber id, page perso, ) le 22/12/2006 à 23:21. (lien). Évalué à 1.

        DWORD * ptr = alloc.addrStart;
        *ptr = 0xdeadbeef;
        * (DWORD*)(alloc.addrStart) = 0xdeadbeef;
        Nickel :) c'etait ce genre de trucs que je cherchais :)
        Merci

        --
        On vous ment! Mais pas moi...

      • [^]Re: .

        Posté par alveric () le 26/12/2006 à 08:11. (lien). Évalué à 2.

        Question de style, mais je n'aime pas caster dans le membre gauche d'une affectation. Il y a toujours le risque d'abuser de la notation, et le compilateur ne dit jamais rien sur un cast erroné. Ici, c'est ok, mais qui sait ce qui peut se passer dans d'autres programmes, si on caste un peu trop...

  • [^]Re: .

    Posté par alveric () le 26/12/2006 à 08:07. (lien). Évalué à 2.

    Je suis d'accord avec tout ton post (et spécialement le PS... y a-t-il un tracker ouvert pour ça ? Je le plussoierais sans vergogne ;)... Enfin, sauf le fait que sizeof S vaut nécessairement 4 sur une architecture 32 bits. Ca peut être 2, 1, 4... suivant l'humeur du compilo (mais, certes, 4 est une valeur très probable en environnement Unixoïde 32 bits).