Sometimes, developers choose to embed assembly code within C or C++ programs when there is no corresponding function or syntax available in the higher-level language. For instance, when I was working on an FIR filter implementation for ARM, I needed to saturate the final result. However, GCC didn’t provide a built-in function like `ssat`, so I had to insert inline assembly into my C code.
### Getting Started
The main challenge when embedding assembly in C is associating C variables with the operands of the assembly instructions. Fortunately, GCC provides mechanisms to help with this. Here's a simple example:
```c
asm("fsinx %1, %0" : "=f"(result) : "f"(angle));
```
In this example, we don't need to worry about what the `fsinx` instruction does; we just need to know that it requires two floating-point registers as operands. Since GCC doesn't inherently understand the specific requirements of each assembly instruction, we must inform it using operand constraints. The `"=f"` and `"f"` specify that these are floating-point registers. The `"="` indicates that this operand is an output, while without it, the operand is considered input.
Inside the parentheses after the constraint, you associate the register with a C variable. This tells GCC how to translate the embedded assembly into actual machine instructions:
- `fsinx`: the assembly instruction.
- `%1, %0`: the operands of the instruction.
- `"=f"(result)`: the `%0` operand is a floating-point register associated with the `result` variable (output).
- `"f"(angle)`: the `%1` operand is a floating-point register associated with the `angle` variable (input).
This embedded assembly will be converted into at least three assembly instructions (assuming no optimization):
1. Load the value of `angle` into register `%1`.
2. Execute the `fsinx` instruction, using `%1` as the source and `%0` as the destination.
3. Store the value of `%0` into the `result` variable.
Of course, this may vary at higher optimization levels, where the compiler might already have the value in a register.
The `"="` symbol in the constraint tells GCC whether the operand should be loaded from the variable before the assembly runs or stored back to the variable afterward.
### Common Operand Constraints
GCC supports several operand constraints. Some of the most commonly used ones include:
- `m`: memory operand
- `r`: general-purpose register
- `i`: immediate integer
- `f`: floating-point register
- `F`: immediate floating-point
The basic structure of inline assembly can be seen from this example:
```c
asm("assembly instruction" : "=output rule"(variable) : "input rule"(variable));
```
The output operand must be an lvalue, which is obvious since it’s where the result is stored.
### Multiple Operands or No Output Operands
If an instruction has multiple input or output operands, you separate them with commas. For example:
```c
asm("add %0, %1, %2" : "=r"(sum) : "r"(a), "r"(b));
```
Each operand rule corresponds to `%0`, `%1`, `%2` in order.
When there are no output operands, you omit the output part, resulting in two colons followed by the input rules.
### Read-Write Operands
Sometimes, an operand serves both as input and output. For example, in x86 assembly:
```c
add %eax, %ebx
```
Here, `%ebx` acts as both an input and output. To indicate this, use the `+` symbol before the constraint:
```c
asm("add %1, %0" : "+r"(a) : "r"(b));
```
This corresponds to the C statement `a = a + b`. Note that you cannot use `"="` here because it would tell GCC that this is a single-output operand, and it wouldn’t load the initial value of `a` into the register.
Another approach is to logically split the read-write operand into two parts:
```c
asm("add %2, %0" : "=r"(a) : "0"(a), "r"(b));
```
The numeric rule `"0"` means this operand uses the same register as operand 0. This allows you to associate two logical operands with different C variables.
Numeric rules can only be used for input operands and must reference an output operand. In the example above, `"0"` refers to the output operand `%0`.
It's important to note that using the same variable name in multiple operands doesn't guarantee they share the same register. For example, the following is incorrect:
```c
asm("add %2, %0" : "=r"(a) : "r"(a), "r"(b)); // error
```
### Specifying Registers
Sometimes, you need to explicitly assign a variable to a specific register, such as in system calls where certain values must be placed in specific registers. You can do this using the `asm` keyword:
```c
register int a asm("%eax") = 1; // statement 1
register int b asm("%ebx") = 2; // statement 2
asm("add %1, %0" : "+r"(a) : "r"(b)); // statement 3
```
Note that only during the execution of the assembly instruction will `a` be in `%eax` and `b` in `%ebx`. At other times, their storage locations are unknown.
Also, be cautious when using this method. For example, if `b` is initialized via a function call that returns to `%eax`, it could overwrite the value of `a`. To avoid this, store the return value in a temporary variable first:
```c
int t = func();
register int a asm("%eax") = 1;
register int b asm("%ebx") = t;
asm("add %1, %0" : "+r"(a) : "r"(b));
```
### Implicitly Modified Registers
Some assembly instructions modify registers that aren't part of the operand list. To inform GCC of this, list the modified registers after the input operands. For example:
```c
asm volatile("movc3 %0,%1,%2"
: /* no outputs */
: "g"(from), "g"(to), "g"(count)
: "r0", "r1", "r2", "r3", "r4", "r5");
```
Here, `movc3` is a character move command. It modifies several registers not listed in the input/output operands.
The registers listed in the input/output rules must not overlap with those in the implicit modification list. For example, the `"g"` constraint should not include any of the registers listed in the implicit modification list.
If you explicitly specify a register in the assembly instruction, you must also include it in the implicit modification list. Also, when using an explicit register in the instruction, you need to add a `%` prefix, like `%%eax`.
### Volatile Keyword
The `volatile` keyword tells GCC that the assembly instruction has side effects and should not be optimized away. For example:
```c
asm volatile("some_instruction");
```
If your assembly code performs calculations, you might not need `volatile`, as GCC can optimize it. However, it's safer to always use `volatile` unless you're certain that optimization won’t affect the outcome.
Aroma King Jewel Disposable Vape
Aroma King Jewel Disposable Vape has a round and lovely shape, while the surface of the transparent shell adds a diamond-shaped texture, so the whole device looks more trendy and fashionable, and it also has a flat mouthpiece, which is more ergonomic. Activated by direct inhalation without any buttons, you can enjoy it as soon as possible for the delicious taste. With the support of a 650mAh battery, it can reach 8000 puffs of awesome delivery. Not only that, Aroma King Jewel is loaded with mesh coils and air adjustment, allowing you to get completely pure and delicious clouds with 0mg of nicotine content and 15 kinds of choices.
Disposable Vape, Vaporizer. Yingyuan Vapes
Shenzhen Yingyuan Technology Co.,ltd , https://www.yingyuanvape.com