Assemblage en ligne - AT & T Syntaxe - Comment passer à une variable

Question

Je travaille donc sur une grotte de code où je remplace fondamentalement un appel à _memcpy par mon saut, et je veux ensuite enregistrer ce qui est dans la source. ORIGINALEMENT:

mov  [esp+8], edx ; size 
mov  [esp+4], eax ; ptr to source 
mov  eax, [ebp+arg_4] 
mov  [esp], eax  ; ptr to destination 
call _memcpy 

Je me bats avec/la syntaxe de cela pour AT & T, au fond, je veux stocker [esp + 8], [esp + 4] et [esp] dans mes propres variables. Je suis en train de le faire de cette façon:

void codecave_jump(void) __attribute__ ((signal, naked)); 
void codecave_jump(void){ 

    void *destination, *source; 
    size_t size; 

    // push all registers onto the stack 
    __asm__("pushal\n\t"); 

    // get size 
    __asm__ __volatile__(
      "movl 8(%ecx), %0\n\t" : "=g" (size) 
      ); 

    // get source 
    __asm__ __volatile__(
      "movl 4(%ecx), %0\n\t" : "=g" (source) 
      ); 

    // get destination 
    __asm__ __volatile__(
      "movl %%eax, %0\n\t" : "=g" (destination) 
      ); 

    // restore all of our registers 
    __asm__("popal\n\t"); 

    // call memcpy 
    __asm__("call __memcpy\n\t"); 

    // do the copy 
    memcpy(destination, source, size); 
} 

Et je reçois l'erreur suivante: erreur: numéro d'opérande manquant après% -lettre erreur: numéro d'opérande manquant après% -lettre

fondamentalement, il hurle à moi pour mon: "movl 8 (% eCX),% 0 \ n \ t": "= g" (taille)

est-ce que quelqu'un sait comment je devrais faire cela correctement dans AT & T syntaxe? Je manque vraiment la syntaxe Intel sur OS X:/

Answer 1

Depuis le résultat AT & le code T utilise des signes de pourcentage pour les noms de registre, vous devez use double percent signs pour les noms de registre quand il y a des opérandes tels que size:

"movl 8(%%ecx), %0\n\t" : "=g" (size) 

Cela ressemble à la façon dont vous avez parfois besoin de deux signes de pourcentage pour printf. Il semble que vous l'ayez juste plus bas pour %%eax, je suppose que cette ligne compile bien. Il n'y a pas d'opcode pour mov mem32, mem32. Vous devez d'abord déplacer les données vers un registre, puis déplacez-le vers un emplacement de mémoire (comme la version Intel fait pour destination)

// get size 
__asm__ __volatile__(
    "movl 8(%ecx), %eax\n\t" 
    ); 
__asm__ __volatile__(
    "movl %%eax, %0\n\t" : "=g" (size) 
    ); 

---

Pour mémoire: Je trouve aussi AT & T syntaxe incroyablement déroutant. :)