来自 GCC 内联程序集的系统调用 [重复]

Question

是否可以使用系统调用从内联汇编块中写入单个字符？如果是这样，如何？它应该看起来像这样：

__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 在 ascii 中是 'P'，但什么也不返回。

任何建议都非常感谢！

Answer 1

IIRC，您的示例中有两件事是错误的。 首先，您正在使用 mov $0, %ebx 写入标准输入 其次， write 将指针作为第二个参数，因此要写入单个字符，您需要将该字符存储在内存中的某个位置，您不能将值直接写入 %ecx

例如：

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

我只在 Linux 中做过纯 asm，从不使用 gcc 内联，你不能将数据放到程序集的中间，所以我不确定你如何使用内联程序集获取指针。

编辑：我想我只是记得怎么做。您可以将 'p' 压入堆栈并使用 %esp

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

Answer 2

类似

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"
                    );
}

添加：注意我使用lea将char的有效地址加载到ecx寄存器中；对于ebx 的价值，我尝试了 $0 和 $1，但它似乎仍然可以工作......

避免使用外部字符

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"
                    );
}

注意：它的工作原理是英特尔处理器的字节序！ :D

Answer 3

您可以使用特定于体系结构的约束将参数直接放置在特定的寄存器中，而无需在内联汇编中使用movl 指令。此外，您还可以使用& 运算符来获取字符的地址：

#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)                    // outputs
            : "a"(SYS_write), "b"(1), "c"(&c), "d"(1)  // inputs
            : "memory");                   // clobbers
}

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

（编者注：需要"memory" clobber，或以其他方式告诉编译器&c 指向的内存已被读取。How can I indicate that the memory *pointed* to by an inline ASM argument may be used?）

---

（在这种情况下，需要=a(ret) 来指示系统调用破坏了EAX。我们不能将EAX 列为破坏器，因为我们需要一个输入操作数来使用该寄存器。@ 987654330@ 约束类似于"r" 但只能选择 AL/AX/EAX/RAX。）

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

您还可以返回系统调用返回的写入字节数，并使用"0" 作为约束再次指示EAX：

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

请注意，出错时，系统调用返回值将是-errno 代码，如-EBADF（错误文件描述符）或-EFAULT（错误指针）。

普通的 libc 系统调用包装函数检查返回值是否为无符号 eax > -4096UL 并设置 errno + return -1。

---

还请注意，需要使用-m32 进行编译：64 位 syscall ABI 使用不同的调用号（和寄存器），但此 asm 对调用 32 位 ABI 的慢速方式进行了硬编码，@ 987654342@.

在 64 位模式下编译会得到 sys/syscall.h 用 64 位呼叫号码定义 SYS_write，这会破坏此代码。即使您使用了正确的数字，64 位堆栈地址也是如此。 What happens if you use the 32-bit int 0x80 Linux ABI in 64-bit code? - 不要那样做。