Examples of inline assembly statements

Example 1: The following example illustrates the usage of the volatile keyword.

#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;
}

Example 2: The following example illustrates the use of the symbolic names for input and output operands.

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

Example 3: The following example shows a typical use of condition registers in the clobbers.

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

In this example, apart from the registers listed in the input and output of the assembly statement, the add. instruction also affects the condition register field 0. Therefore, you must inform the compiler about this by adding cr0 to the clobbers.

Example 4: The following example shows the usage of the memory clobber.

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

In this example, the instruction dcbz clears a cache block, and might have changed the variables in the memory location. There is no way for the compiler to know which variables have been changed. Therefore, the compiler assumes that all data might be aliased with the memory changed by that instruction.

Example 5: The following example shows the usage of the = modifier and the r constraint.

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

The output operand uses the = modifier to indicate that a modifiable operand is required; it uses the r constraint to indicate that a general purpose register is required. Likewise, the r constraint in the input operands indicates that general purpose registers are required. Within these restrictions, the compiler is free to choose any registers to substitute for %0, %1, and %2.

Example 6: The following example shows the usage of the + modifier and the K constraint.

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

Example 7: The following example shows the usage of the % modifier and the f constraint.

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

This assembly statement adds operands a and b, and writes the result to operand c. The % modifier indicates that operands a and b can be switched if the compiler can generate better code in doing so. Each operand has the f constraint, which indicates that a floating point register is required.

Example 8: The following example shows the usage of the b constraint.

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

In this example, the b constraint instructs the compiler to choose a general register other than r0 for the input operand %1. The result string of this program is abcdefgy. However, if you use the r constraint and the compiler chooses r0 for %1, this instruction produces an incorrect result string ybcdefgh. For instructions that treat the designation of r0 specially, it is therefore important to denote the input operands with the b constraint.

Example 9: The following example shows the usage of the m constraint.

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