高级CGNU C/C++ 内联汇编——实例参考

Posted 从善若水

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了高级CGNU C/C++ 内联汇编——实例参考相关的知识,希望对你有一定的参考价值。

本人就职于国际知名终端厂商,负责modem芯片研发。
在5G早期负责终端数据业务层、核心网相关的开发工作,目前牵头6G算力网络技术标准研究。


博客内容主要围绕:
       5G协议讲解
       算力网络讲解(云计算,边缘计算,端计算)
       高级C语言讲解
       Rust语言讲解

文章目录

GNU C/C++ 内联汇编——实例参考

下面的示例以 IBM 的 Power PC 为例。

Example 1

下面的示例说明了 volatile 关键字的用法:

#include <stdio.h>
inline bool acquireLock(int *lock)
	bool returnvalue = false;
  	int lockval;
  	asm volatile(
              /*--------a fence here-----*/
               
               	"  0: lwarx %0,0,%2   \\n" // Loads the word and reserves
                                          // a memory location for the subsequent
                                          // stwcx. instruction.
				"     cmpwi %0,0      \\n" // Compares the lock value to 0.
               	"     bne- 1f         \\n" // If it is 0, you can acquire the 
                                          // lock. Otherwise, you did not get the
                                          // lock and must try again later.
                                           
               	"     ori %0,%0,1     \\n" // Sets the lock to 1. 
               	"     stwcx. %0,0,%2  \\n" // Tries to conditionally store 1
                                          // into the lock word to acquire 
                                          // the lock.
                                           
               	"     bne- 0b         \\n" // Reservation was lost. Try again.
				"     isync           \\n" // Lock acquired. The isync instruction 
                                          // implements an import barrier to 
                                          // ensure that the instructions that
                                          // access the shared region guarded by
                                          // this lock are executed only after 
                                          // they acquire the lock.
 
               	"     ori  %1,%1,1    \\n" // Sets the return value for the 
                                          // function acquireLock to true.
				"  1:                 \\n" // Did not get the lock. 
                                          // Will return false.
			/*------a fence here------*/
				:     "+r"   (lockval),
                      "+r"   (returnvalue) 
               	:     "r"    (lock)       // "lock" is the address of the lock in 
                                          // memory.
				:     "cr0"               // cr0 is clobbered by cmpwi and stwcx.
               );
                	         
	return returnvalue;


int main()

	int myLock;
  	if(acquireLock(&myLock))
    	printf("got it!\\n");
  	else 		
       	printf("someone else got it\\n");
  	 
  	return 0;

在这个例子中,%0指的是第一个操作数“+r”(lockval), %1指的是第二个操作数“+r”(returnvalue), %2指的是第三个操作数“r”(lock)。

程序使用一个锁来控制对共享存储的访问; 在获取锁之前,没有指令可以访问共享存储。

volatile关键字意味着在汇编指令组周围设置栅栏,因此任何汇编指令都不能移出汇编代码块。 如果没有volatile关键字,编译器可以移动指令进行优化。 这可能会导致一些指令在不获取锁的情况下访问共享存储。

在这个汇编语句中,没有必要使用 memory clobber,因为这些指令不会以意想不到的方式修改内存。 如果您使用 memory clobber,程序在功能上仍然是正确的。 但是, memory clobber 会导致许多不必要的重新加载,从而造成性能损失。

Example 2

下面的示例演示了输入和输出操作数的符号名称的使用:

int a ;
int b = 1, c = 2, d = 3 ;  
__asm("   addc %[result], %[first], %[second]" 
       :  [result]      "=r"       (a)
       :  [first]       "r"        (b), 
          [second]      "r"        (d)
      );

在这个例子中,%[result]指的是输出操作数变量a, %[first]指的是输入操作数变量b, %[second]指的是输入操作数变量d。

Example 3

下面的例子展示了条件寄存器在 clobber 中的典型用法:

asm ("    add. %0,%1,%2  \\n"     
      :   "=r"    (c)                    
      :   "r"     (a),
          "r"     (b)
      :   "cc"
      );

在本例中,除了程序的输入和输出中列出的寄存器外,add.指令还影响条件寄存器。 因此,您必须通过将 “cc” 添加到 clobbers 来通知编译器。

Example 4

下面的示例显示了 memory clobber 的使用情况:

 asm volatile ("   dcbz 0, %0      \\n" 
               :   "=r"(b)
               : 
               :   "memory"
               );

在这个例子中,指令 “dcbz” 清除了一个缓存块(cache block),并且可能改变了内存位置中的变量。 编译器无法知道哪些变量被更改了。

因此,所有需要的东西都必须在程序执行完成后从内存中重新加载。memory clobber 以程序性能为代价来确保程序的正确性,因为编译器可能会重新加载与这段程序无关的数据。

Example 5

下面的例子展示了 ‘=’ 约束修饰符和 ‘r’ 约束的用法 :

int a ;  
int b = 100 ;  
int c = 200 ;  
asm("   add %0, %1, %2"
    :   "=r"     (a)
    :   "r"      (b),
        "r"      (c)
    );

加法指令将两个通用寄存器的内容相加。 %0、%1和%2操作数被输出/输入操作数字段中的C表达式替换。

输出操作数使用 ‘=’ 修饰符表示需要一个可修改的操作数。它使用 ‘r’ 约束来表示需要一个通用寄存器。 同样,输入操作数中的 ‘r’ 约束表明需要通用寄存器。 在这些限制中,编译器可以自由选择任何寄存器来替换%0、%1和%2。

注意:如果编译器选择 ‘r0’ 作为第二个操作数,则 add 指令使用立即数 0 并产生一个错误的结果。 因此,为了防止编译器选择 ‘r0’ 作为第二个操作数,可以为第二个操作数使用 ‘b’ 约束。

Example 6

下面的例子展示了 ‘+’ 修饰符和 ‘K’ 约束的用法:

 asm ("   addi %0,%0,%2"
      :   "+r"    (a)
      :   "r"     (a),
          "K"     (15)
      );

此程序将操作数%0和操作数%2相加,并将结果写入操作数%0。 输出操作数使用 ‘+’ 修饰符表示操作数%0可以被指令读取和写入。 ‘K’ 约束指出,加载到操作数%2中的值必须是一个无符号的16位常量值。

Example 7

下面的示例显示了 ‘%’ 修饰符和 ‘f’ 约束的用法:

asm("   fadd %0, %1, %2"
    :   "=f"    (c)
    :   "%f"    (a),
        "f"     (b)
    ); 

这个程序将操作数a和b相加,并将结果写入操作数c。’%’ 修饰符表示,如果编译器可以通过交换操作数a和b以生成更好的代码,那么可以交换操作数a和b。 每个操作数都有 ‘f’ 约束,表示需要一个浮点寄存器。

Example 8

下面的例子展示了 ‘b’ 约束的用法:

char res[8]='a','b','c','d','e','f','g','h';
char a='y';
int  index=7;
asm ("    stbx %0,%1,%2       \\n"     \\
     :                               \\
     :    "r"    (a),
          "b"    (index),
          "r"    (res)
     ); 

在这个例子中,‘b’ 约束指示编译器为输入操作数%1选择一个普通寄存器,而不是 ‘r0’ 。 这个程序的输出结果是 “abcdefgy” 。 但是,如果使用 ‘r’ 约束,并且编译器为%1选择 ‘r0’ ,则该指令将生成一个不正确的结果字符串 “ybcdefgh” 。 因此,对于特殊处理 ‘r0’ 的指令,需要用 ‘b’ 来约束输入操作数。

Example 9

下面的例子展示了 ‘m’ 约束的用法:

 asm ("   stb %1,%0       \\n"     \\
      :   "=m"    (res)           \\
      :   "r"     (a)
      );

在这个例子中,stb指令的语法是stb RS,D(RA),其中D是一个偏移,R是一个寄存器,D+RA为有效地址。 通过使用约束 ‘m’ ,你不需要通过分别指定寄存器和位移来手动构造有效地址。

您可以使用一个约束 ‘m’ 或 ‘o’ 来引用指令中的两个操作数,而不管正确的偏移量应该是多少,也不管它是堆栈的偏移量还是ToC(Table of Contents)的偏移量。 这允许编译器选择正确的寄存器(例如,r1是一个自动变量),并自动应用正确的位移。


这里是从善若水的博客,感谢您的阅读⌨🖥🖱


文章链接

《GNU C/C++ 内联汇编编程指南全集》
《GNU C/C++ 内联汇编——入门级》
《GNU C/C++ 内联汇编——进阶——语法详解》
《GNU C/C++ 内联汇编——进阶——约束详解》
《GNU C/C++ 内联汇编——补充介绍》
《GNU C/C++ 内联汇编——实例参考》
《GNU C/C++ 内联汇编——Intel与ATT汇编语法对比》




以上是关于高级CGNU C/C++ 内联汇编——实例参考的主要内容,如果未能解决你的问题,请参考以下文章

高级CGNU C/C++ 内联汇编——Intel与ATT汇编语法对比

高级CGNU C/C++ 内联汇编——入门级

高级CGNU C/C++ 内联汇编——补充介绍

高级CGNU C/C++ 内联汇编——入门级

高级CGNU C/C++ 内联汇编——进阶——约束详解

高级CGNU C/C++ 内联汇编——进阶——语法详解