Forum Programmation.c Pointeurs et structures

Posté par nats le 21 décembre 2006 à 20:01.

Étiquettes : aucune

déc.

2006

struct plageMem {


	void * addrStart;


};

alloc.addrStart = allocMemPage();


alloc.addrStart = 0xDEADBEEF;

En gros je voudrait écrire le dword à l'emplacement mémoire pointé par addrStart.

En gros, je voudrais faire l'équivalent de:
mov dword ptr[addrStart], 0DEADBEEFh

C'est sans doute une question bête de débutant mais j'ai vraiment aucune idée. Merci d'avance.

# ASM

Posté par NeoX le 21 décembre 2006 à 20:06. Évalué à 1.

ben heu

#include <asm.h>

[...]ton code[...]

asm {
mov dword ptr[addrStart], 0DEADBEEFh
}
- [^] # Re: ASM
  
  Posté par nats le 21 décembre 2006 à 20:12. Évalué à 1.
  
  Ouai enfin je voulais le faire en C complétement :)
  Mais merci quand meme.
# *

Posté par JaguarWan le 21 décembre 2006 à 21:07. Évalué à 2.

En gros je voudrait écrire le dword à l'emplacement mémoire pointé par addrStart.

struct plageMem {
void * addrStart; /* vaudrait mieux unsigned (int|char) je pense */
};

alloc.addrStart = allocMemPage();
*alloc.addrStart = 0xdeadbeef;
/* ou alternativement */
alloc.addrStart[0] = 0xdeadbeef;

Si tu veux copier beaucoup de données dans ton buffer (une page mémoire ça me semble beaucoup pour simplement écrire un dword dedans), memcpy(3)/memmove(3) sont tes amies.
- [^] # Re: *
  
  Posté par nats le 22 décembre 2006 à 01:04. Évalué à 1.
  
  *alloc.addrStart = 0xdeadbeef;
  Bah justement cette syntaxe n'a pas l'air de passer....
  En fait j'ai deja penser au memcpy et autres opérations sur les buffers mais j'avoue que j'ai mes petites habitudes d'assembleur :)
  En tout cas merci a toi et aux autres commentaires aussi :)
  (pour la peine je plussoie ^^)
  - [^] # Re: *
    
    Posté par alf le 26 décembre 2006 à 09:02. Évalué à 2.
    
    Problème de précédence : (*alloc).addStart.
# .

Posté par Anonyme le 21 décembre 2006 à 21:07. Évalué à 4.

si ptr est ton pointeur vers un dword (c'est a dire un unsigned int sur une architecture 32 bit), addrStart est l'adresse vers laquelle pointe ton pointeur et Value est la valeur a ecrire, alors ce que tu veux faire est:

unsigned int *ptr=addrStart; /* declaration et initialisation du pointeur */
*ptr=Value; /* Value est copiee a l'adresse pointee par ptr */

mais j'ai le sentiment que ce n'est pas exactement ce que tu recherches, me gourre-je ?
- [^] # Re: .
  
  Posté par nats le 22 décembre 2006 à 01:09. Évalué à 1.
  
  Bah en fait j'ai pas de problème avec les pointeurs simples, mais c'est la syntaxe quand le pointeur est dans une structure je sais aps trop comment ecrire à l'emplacement pointé avec toutes ces histoires de "." et de "->" et surtout que le:
  *alloc.addrStart = 0xdeadbeef;
  Me renvoit l'erreur illegal indirection...
  - [^] # Re: .
    
    Posté par Anonyme le 22 décembre 2006 à 03:01. É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 Anonyme le 22 décembre 2006 à 03:17. É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 le 22 décembre 2006 à 09:02. É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.
      - [^] # Re: .
        
        Posté par David Decotigny (site web personnel) le 22 décembre 2006 à 21:27. É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
        
        [^] # Re: .
        
        Posté par nats le 23 décembre 2006 à 00:21. Évalué à 1.
        
        DWORD * ptr = alloc.addrStart;
        *ptr = 0xdeadbeef;
        * (DWORD*)(alloc.addrStart) = 0xdeadbeef;
        Nickel :) c'etait ce genre de trucs que je cherchais :)
        Merci
        
        [^] # Re: .
        
        Posté par alf le 26 décembre 2006 à 09:11. É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 alf le 26 décembre 2006 à 09:07. É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).

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.