syscall depuis l'assemblage en ligne GCC

Question

Est-il possible d'écrire un seul caractère à l'aide d'un appel système à partir d'un bloc d'assemblage en ligne? si c'est le cas, comment? il devrait ressembler à "quelque chose" comme ceci:

__asm__ __volatile__ 
        (
        " movl $1, %%edx \n\t" 
        " movl $80, %%ecx \n\t" 
        " movl $0, %%ebx \n\t" 
        " movl $4, %%eax \n\t" 
        " int $0x80  \n\t" 
        ::: "%eax", "%ebx", "%ecx", "%edx" 
        ); 

80 $ est 'P' en ascii, mais qui ne renvoie rien.

toutes les suggestions très appréciées!

Answer 1

Quelque chose comme

char p = 'P'; 

int main() 
{ 
__asm__ __volatile__ 
        (
        " movl $1, %%edx \n\t" 
        " leal p , %%ecx \n\t" 
        " movl $0, %%ebx \n\t" 
        " movl $4, %%eax \n\t" 
        " int $0x80  \n\t" 
        ::: "%eax", "%ebx", "%ecx", "%edx" 
        ); 
} 

Ajouter: Notez que je l'ai utilisé lea pour charger l'adresse effective du charbon dans ecx registre; pour la valeur de ebx J'ai essayé 0 $ et 1 $ et il semble fonctionner de toute façon ...

Évitez l'utilisation de charbon externe

int main() 
{ 
__asm__ __volatile__ 
        (
        " movl $1, %%edx \n\t" 
        " subl $4, %%esp \n\t" 
        " movl $80, (%%esp)\n\t" 
        " movl %%esp, %%ecx \n\t" 
        " movl $1, %%ebx \n\t" 
        " movl $4, %%eax \n\t" 
        " int $0x80  \n\t" 
        " addl $4, %%esp\n\t" 
        ::: "%eax", "%ebx", "%ecx", "%edx" 
        ); 
}

N.B. .: cela fonctionne en raison de la boutisme des processeurs intel! : D

Answer 2

IIRC, deux choses sont fausses dans votre exemple. Premièrement, vous écrivez stdin avec mov $ 0,% ebx Ensuite, write prend un pointeur comme deuxième argument, donc pour écrire un seul caractère vous avez besoin que ce caractère soit stocké quelque part en mémoire, vous ne pouvez pas écrire la valeur directement à% ecx

ex:

.data 
char: .byte 80 
.text 
mov $char, %ecx 

Je n'ai fait asm pur sous Linux, en ligne ne jamais utiliser gcc, vous ne pouvez pas supprimer des données dans le milieu de l'assemblée, donc je ne suis pas sûr comment obtenir le pointeur en utilisant l'assemblage en ligne.

EDIT: Je pense que je viens de me rappeler comment le faire. vous pouvez pousser « p » sur la pile et l'utilisation% esp

pushw $80 
movl %%esp, %%ecx 
... int $0x80 ... 
addl $2, %%esp 

Answer 3

Vous pouvez utiliser des contraintes spécifiques à l'architecture pour placer directement les arguments dans des registres spécifiques, sans avoir besoin des instructions movl dans votre assembly en ligne. De plus, vous pouvez alors utiliser l'opérateur & pour obtenir l'adresse du caractère:

#include <sys/syscall.h> 

void sys_putc(char c) { 
    // write(int fd, const void *buf, size_t count); 
    int ret; 
    asm volatile("int $0x80" : "=a"(ret): "a"(SYS_write), "b"(1), "c"(&c), "d"(1)); 
} 

int main(void) { 
    sys_putc('P'); 
    sys_putc('\n'); 
} 

(Dans ce cas, =a(ret) est nécessaire pour indiquer que le syscall aplatit EAX.)

$ cc -m32 sys_putc.c && ./a.out 
P 

Vous pouvez également renvoyer le nombre d'octets écrits que le syscall renvoie et utiliser "0" comme contrainte pour indiquer EAX à nouveau:

int sys_putc(char c) { 
    int ret; 
    asm volatile("int $0x80" : "=a"(ret) : "0"(SYS_write), "b"(1), "c"(&c), "d"(1)); 
    return ret; 
}