GCC Inline ASM

2.1.1 Special format strings

2.2.1 asmSymbolicName

2.2.2 constrint

1. Simple Constraints
   

   The simplest kind of constraint is a string full of letters, each of which describes one kind of operand that is permitted. Here are the letters that are allowed:

   Constraint	Descriptions
   whitespace	Whitespace characters are ignored and can be inserted at any position except the first.
   	This enables each alternative for different operands to be visually aligned in the machine
   	description even if they have different number of constraints and modifiers.
   'm'	A memory operand is allowed, with any kind of address that the machine supports in general.
   	Note that the letter used ofr the general memory constraint can be re-defied by a back end using
   	the TARGETMEMCONSTRAINT macro.
   'o'	A memory operand is allowed, but only if the address is offsetable. This means that adding a small
   	integer (actually, the width in bytes of the operand, as determined by its machine mode) may be added
   	to the address and the result is also a valid memory address.
   	For example, an address which is constant is offsettable; so is an address that is the sumo of a register
   	and a constant (as long as a slightly larger constant is also within the range of address-offsets supported
   	by the machine); but an autoincrement or autodescrement address is not offsettable. More complicated
   	indirect/indexed addresses may or may not be offsetable depending on the other addressing modes that the
   	machine supports.
   	Note that in an output operand which can be matched by another operand, the constraint letter 'o' is valid
   	only when accompanied by both '<' (if the target machine has predecrement addressing) and '>' (if the target
   	machine has preincrement addressing).
   'V'	A memory operand that is not offsetable. In other words, anything that would fit the 'm' constraint but not
   	the 'o' constraint.
   '<'	A memory operand with autodecrement addressing (either predecrement or postdescrement) is allowed. In inline
   	asm this constraint is only allowed if the operand is used exactly once in an instruction that can handle the
   	side effects. Not using an operand with '<' in constraint string in the inline asm pattern at all or using it
   	in multiple instructions isn't valid, because the side effects wouldn't be performed or would be performed more
   	than once.
   	Furthermore, on some targets the operand with '<' in constraint string must be accompanied by special instruction
   	suffixes like %U0 instruction suffix on PowerPC or %P0 on IA-64.
   '>'	A memory perand with autoincrement addressing (either preincrement or postincrement) is allowed. In inline asm the
   	same restrictions as for '<' apply.
   'r'	A register operand is allowed provided that it is in a general register.
   'i'	An immediate integer operand (one with constant value) is allowed. This includes symbolic constants whose values will
   	be known only at assembly time or later.
   'n'	An immediate integer operand with a known numeric value is allowed. Many systems cannot support assembly-time constants
   	for opernds less than a word wide. Constraints for these operads should use 'n' rather than 'i'.
   'I','J','K',	Other letters in the range 'I' througth 'P' may be defined in a machine-dependent fashion to permit immediate integer
   … 'P'	operands with explict integer values in specified ranges. For example, on the 68000, 'I' is defined to stand for the
   	range of values 1 to 8. This is the range permitted as a shift count in the sift instructions.
   'E'	An immediate floating operand (expression code constdouble) is allowed, but only if the target floating point format is
   	the same as that of the host machine (on which the compiler is running).
   'F'	An immediate floating operand (expression code constdouble or constvector) is allowed.
   'G', 'H'	'G' and 'H' may be defined in a machine-depedent fashion to permit immediate floating operands in particular ranges of
   	values.
   's'	An immediate integer operand whose value is not an explicit integer is allowed.
   'g'	Any register, memory or immediate integer operand is allowed, except for registers that are not general registers.
   'X'	Any operand whatsoever is allowed.
   '0', '1', '2',	An operand that matches the specified operand number is allowed. If a digit is used together with letters within the same
   … '9'	alternative, the digit should come last.
   	This is called a matching constraint and what it really means is that the assembler has only a single operand that fills
   	two roles which asm distinguishes. For example, an add instruction uses two input operands and an output operand, but on
   	most CISC machines an add instruction really has only two operands, one of them an input-output operand.
   'p'	An operand that is a valid memory address is allowed. This is for "load address" and "push address" instructions.

2. Constraints for Particular Machines
   

   Whenever possible, you should use the general-purpose constraint letters in asm arguments, since they will convey meaning more readily to people reading your code. Failing that, use the constraint letters that usually have very similar meanings across architectures. The most commonly used constraints are 'm' and 'r' (for memory and general-purpose registers respectively), and 'I', usually the letter indicating the most common immediate-constant format.

   Each architecture define additional constraints. These constraints are used by the compiler itself for instruction generation, as well as for asm statements; therefore, some of the constraints are not particularly useful for asm. Here is a summary of some of the machine-dependent constraints available on some particular machines; it includes both constraints that are useful for asm and constraints that aren't. The compiler source file mentioned in the table heading for each architecture is the definitive reference for the meanings of that architecure's constraints.

   Table 1: AArch64 family

   Constraint	Descriptions
   k	The stack pointer register (SP)
   w	Floating point register, Advanced SIMD vector register or SVE vector register
   x	Like w, but restricted to registers 0 to 15 inclusive.
   y	Like w, but restricted to registers 0 to 7 inclusive.
   Upl	One of the low eight SVE predicate registers (P0 to P7)
   Upa	Any of the SVE predicate registers (P0 to P15)
   I	Integer constant that is valid as an immediate operand in an ADD instruction
   J	Integer constant that is valid as an immediate operand in a SUB instruction (once negated)
   K	Integer constant that can be used with a 32-bit logical instruction
   L	Integer constant that can be used with a 64-bit logical instruction
   M	Integer constant that is valid as an immediate operand in a 32-bit MOV pseudo instruction.
   	The MOV may be assembled to one of several different machine instructions depending on the
   	value.
   N	Integer constant that is valid as an immediate operant in a 64-bit MOV pseudo instruction
   S	An absolute symbolic address or a label reference
   Y	Floating point constant zero
   Z	Integer constant zero
   Ush	The high part (bits 12 and upwards) of the pc-relative address of a symbol within 4GB of
   	the istruction
   Q	A memory address which uses a single base register with no offset
   Ump	A memory address suitable for a load/store pair instruction in SI, DI, SF and DF modes

   Table 2: ARM family

   Constraint	Descriptions
   h	In Thumb state, the core registers r8-r15
   k	The stack pointer register
   l	In Thumb State the core registers r0-r7. In ARM state this is an alias for the r constraint
   t	VFP floating-point registers s0-s31. Used for 32 bit values.
   w	VFP floting-point registers d0-d31 and the appropriate subset d0-d15 based on command line
   	options. Used for 64 bit values only. Not valid for Thumb1.
   y	The iWMMX co-processor registers.
   z	The iWMMX RG registers.
   G	The floating-point constant 0.0
   I	Integer that is valid as an immediate operand in a data processing instruction. That is, an
   	integer in the range 0 to 255 rotated by a multiple of 2
   J	Integer in the range -4095 to 4095
   K	Integer that satisfies constraint 'I' when inverted (ones complement)
   L	Interger that satisfies constraint 'I' when negated (twos complement)
   M	Integer in the range 0 to 32
   Q	A memory reference where the exact address is in a single register ("m" is preferable for
   	asm statements)
   R	An item in the constant pool
   S	A symbol in the text segment of the current file
   Uv	A memory reference suitable for VFP load/store insns (reg+constant offset)
   Uy	A memory reference suitable for iWMMXt load/store instructions.
   Uq	A memory reference suitable for the ARMv4 ldrsb instruction.

3. Constraint Modifier Characters
   

   Here are constraint modifier characters.

   Modifier	Descriptions
   '='	Means that this operand is written to by this instruction: the previous value is discarded and
   	replaced by new data.
   	Write-only operand, usuall used for all output operands.
   '+'	Means that this operand is both read and written by the instruction.
   	When the compiler fixes up the operands to satify the constraints, it needs to know which
   	operands are read by the instruction and which are written by it. '=' identifies an operand
   	which is only written; '+' identifies an operand that is both read and written; all other
   	operands are assumed to only be read.
   	If you specify '=' or '+' in a constraint, you put it in the first character of the constraint
   	string.
   	Read-Write operand, must be listed as an output operand.
   '&'	Means (in a particular alternative) that this operand is an earlyclobber operand, which is written
   	before the instruction is finished using the input operands. Therefore, this operand may not lie in
   	a register that is read by the instruction or as part of any memory address.
   	'&' applies only to the alternative in which it is written. In constraints with multiple alternatives,
   	sometimes one alternative requires '&' while others do not.
   	A register that should be used for output only.
   '%'	Declares the instruction to be comutative for this operand and the following operand. This means that
   	the compiler may interchange the two operands if that is the cheapest way to make all operands fit the
   	constraints. '%' applies to all alternatives and must appear as the first character int the constraint.
   	Only read-only operands can use '%'.

2.2.3 cvariablename

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

static inline uint32_t read_register(uint32_t *reg)
{
	uint32_t value;

	__asm__ __volatile__(
		"mov %0, %1\n"
		: "=rm" (value)
		: "rm" (*reg)
		);

	return value;
}

int main(void)
{
    uint32_t reg = 0x80;
    printf("register value: %lx\n", read_register(&reg));

    return 0;
}

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

static inline uint32_t read_register(uint32_t *reg)
{
	uint32_t value;

	__asm__ __volatile__(
		"mov %[val], %[reg]\n"
		: [val] "=rm" (value)
		: [reg] "rm" (*reg)
		);

	return value;
}

int main(void)
{
    uint32_t reg = 0x80;
    printf("register value: %lx\n", read_register(&reg));

    return 0;
}

2.3.1 asmSymbolicName

2.3.2 constraint

2.3.3 cexpression

__asm__ __volatile__("some instructions"
		     : /* No outputs. */
		     : "r" (Offset / 8));