Warum asm unmögliche Einschränkungen haben, wenn ich Register registriere?

Question

Ich bin neu in Assembly in C, und ich weiß nicht, wie Sie diesen Fehler beheben. Ich mache eine Funktion, die bedeutet, eine Datei zu schreiben. Was ich habe ist:

ssize_t mywrite(int fd, const void *buf, size_t count) { 
// return write(fd, buf, count); 
    ssize_t var; 
    __asm__("movl $4,%%eax\n\t" // Write 
     "movl %1,%%ebx\n\t" 
     "movl %2,%%ecx\n\t" 
     "movl %3,%%edx\n\t" 
     "int $0x80\n\t"   // System call 
     "movl %%eax,%0" 
     :"=r"(var) 
     :"r"(fd),"r"(buf),"r"(count) 
     :"%eax","%ebx","%ecx","%edx" 
    ); 
    return var; 
} 

Meine asm soll das gleiche wie schreiben (fd, buf, count); Wenn ich es kompiliere, bekomme ich "'asm' Operand hat unmögliche Einschränkungen". Wenn Sie jedoch die Variablen nicht benennen und die Werte direkt vom Stapel abrufen, erhalte ich keinen Fehler. Hier ist der Code

__asm__("movl $4,%%eax\n\t" 
     "movl 8(%%ebp),%%ebx\n\t" 
     "movl 12(%%ebp),%%ecx\n\t" 
     "movl 16(%%ebp),%%edx\n\t" 
     "int $0x80\n\t" 
     "movl %%eax,%0" 
     :"=r"(var) 
     : 
     :"%eax","%ebx","%ecx","%edx" 
    ); 

ich den zweiten Code verwenden könnte, OFC, aber ich brauche es mit Optimierung kompiliert 2. Dann% ebp nicht zeigen, wo ich brauche es. Ich habe versucht, "a", "b", "c" und "d" anstelle von "r" zu verwenden, aber keinen Erfolg. Jeder könnte helfen? Danke: D

Answer 1

Das Problem ist, dass die Einschränkung r bedeutet Register, aber Ihre CPU hat einfach nicht so viele Register!

können Sie die Einschränkung Speicher verwenden m:

:"m"(fd),"m"(buf),"m"(count) 

, die Anweisungen generieren, wie:

movl 8(%ebp),%ebx 

Aber ich würde die x86 constraints in seiner ganzen Pracht zu verwenden, empfehlen:

ssize_t mywrite(int fd, const void *buf, size_t count) { 
    ssize_t var; 
    __asm__(
     "int $0x80" 
     :"=a"(var) 
     :"0"(4), "b"(fd),"c"(buf),"d"(count) 
    ); 
    return var; 
} 

Das, mit -Ofast gibt:

push %ebx 
mov $0x4,%eax 
mov 0x10(%esp),%edx 
mov 0xc(%esp),%ecx 
mov 0x8(%esp),%ebx 
int $0x80 
pop %ebx 
ret 

Und mit -Os:

push %ebp 
mov $0x4,%eax 
mov %esp,%ebp 
push %ebx 
mov 0x10(%ebp),%edx 
mov 0x8(%ebp),%ebx 
mov 0xc(%ebp),%ecx 
int $0x80 
pop %ebx 
pop %ebp 
ret  

Hinweis, wie durch den Einsatz von Einschränkungen anstelle der Register mit Namen, der Compiler den Code weiter optimieren kann.