使用c语言嵌入汇编

Estr

在字符型数组里，含有10个字节8位整数，将这些整数作为有符号数，判断这些整数的正负个数

Mike_python小

自己作业自己做，自己屁股自己擦

人造人

首先，自己的作业应该自己做
这个题目我比较感兴趣，就写了一下
如果你是为了交作业的话，估计不会直接复制粘贴这个答案
不过这可以给你一个参考答案，你可以参考这个程序，然后自己写一个

1. sh-5.1$ cat main.c
   
2. #include <stdio.h>
   
3. #include <stdint.h>
   
4. 
   
5. typedef struct {
   
6.     uint64_t pn, nn, zo;
   
7. } number_type_count_t;
   
8. 
   
9. void count(const char *data, size_t size, number_type_count_t *ntc) {
   
10.     asm volatile("xorq  %%rax, %%rax\n\t"
    
11.                  "movq  %%rax, (%2)\n\t"
    
12.                  "movq  %%rax, 8(%2)\n\t"
    
13.                  "movq  %%rax, 16(%2)\n\t"
    
14.                  "movq  %0, %%rdi\n\t"
    
15.                  "addq  %1, %%rdi\n\t"
    
16.                "1:cmpq  %%rdi, %0\n\t"
    
17.                  "jge   5f\n\t"
    
18.                  "lodsb\n\t"
    
19.                  "testb %%al, %%al\n\t"
    
20.                  "jnz   2f\n\t"
    
21.                  "incq  16(%2)\n\t"
    
22.                  "jmp   4f\n\t"
    
23.                "2:jns   3f\n\t"
    
24.                  "incq  8(%2)\n\t"
    
25.                  "jmp   4f\n\t"
    
26.                "3:incq  (%2)\n\t"
    
27.                "4:jmp   1b\n\t"
    
28.                "5:nop"
    
29.             ::"S"(data), "c"(size), "r"(ntc)
    
30.             :"rax", "rdi");
    
31. }
    
32. 
    
33. int main(void) {
    
34.     char data[10] = {1, 3, -9, -7, -8, -5, 0, 1, -1, 0};
    
35.     number_type_count_t ntc;
    
36.     count(data, 10, &ntc);
    
37.     printf("%lu %lu %lu\n", ntc.pn, ntc.nn, ntc.zo);
    
38.     return 0;
    
39. }
    
40. sh-5.1$ gcc -g -Wall -o main main.c
    
41. sh-5.1$ ./main
    
42. 3 5 2
    
43. sh-5.1$
    

复制代码

bluesky5210

1. #include <stdio.h>
   
2. 
   
3. int main() {
   
4.     char data[10] = {10, -20, 30, -40, 50, -60, 70, -80, 90, -100};
   
5.     int pos_count = 0, neg_count = 0;
   
6.    
   
7.     __asm__ (
   
8.         "movl $10, %%ecx \n\t"  // ecx 寄存器存储元素个数
   
9.         "movq %[data], %%rdi \n\t"  // rdi 寄存器存储数组首地址
   
10.         "xorl %%eax, %%eax \n\t"  // eax 寄存器初始化为 0
    
11.         "loop_start: \n\t"
    
12.         "movsbq (%%rdi), %%rbx \n\t"  // rbx 寄存器存储当前元素
    
13.         "test %%bl, %%bl \n\t"  // 检查当前元素是否为负数
    
14.         "js neg \n\t"  // 如果是负数跳转到 neg 标签
    
15.         "inc %[pos_count] \n\t"  // 如果是正数，pos_count+1
    
16.         "jmp end \n\t"  // 跳转到 end 标签
    
17.         "neg: \n\t"
    
18.         "inc %[neg_count] \n\t"  // 如果是负数，neg_count+1
    
19.         "end: \n\t"
    
20.         "inc %%rdi \n\t"  // 移动指针到下一个元素
    
21.         "loop loop_start \n\t"
    
22.         : [pos_count] "+r" (pos_count), [neg_count] "+r" (neg_count)
    
23.         : [data] "r" (data)
    
24.         : "rax", "rbx", "rcx", "rdi", "memory"
    
25.     );
    
26.    
    
27.     printf("positive count: %d\n", pos_count);
    
28.     printf("negative count: %d\n", neg_count);
    
29.    
    
30.     return 0;
    
31. }
    

复制代码

在上面的代码中，我们使用了 GCC 内嵌汇编的语法，在 C 代码中插入了汇编代码。具体实现过程如下：

首先定义了 data 数组，里面存储了 10 个 8 位整数。
然后定义了 pos_count 和 neg_count 变量，分别用来记录正数和负数的个数，初始化为 0。
接下来是汇编代码部分，使用了 __asm__ 关键字将汇编代码嵌入到 C 代码中。
在汇编代码中，首先使用 movl 指令将元素个数 10 存储到 ecx 寄存器中，使用 movq 指令将 data 数组的首地址存储到 rdi 寄存器中。使用 xorl 指令将 eax 寄存器初始化为 0。