Inline Assembly & Low-Level Intrinsics

By the end of this lesson you'll be able to read a basic GCC/Clang inline-assembly statement, explain its output, input, and clobber operands, and — far more importantly — know why compiler intrinsics and the optimizer are almost always the better tool, plus the portability and safety traps that make hand-written asm a last resort.

1. What Inline Assembly Is (and Isn't)

Inline assembly means writing raw CPU instructions directly inside a C++ function. On GCC and Clang you use the asm keyword; on MSVC the syntax differs again — already a portability headache. It exists for the handful of cases the language genuinely cannot express: a privileged instruction in an operating-system kernel, a brand-new CPU feature with no wrapper yet, or constant-time cryptographic code. For everything else, the compiler writes better assembly than you will. Study the worked example below — the asm is in comments, and the runnable C++ computes the identical answer.

#include <iostream>
using namespace std;

// Inline assembly = raw CPU instructions written INSIDE a C++ function.
// GCC and Clang spell it:  asm volatile("..." : outputs : inputs : clobbers);
//
// Here is the SAME idea (add two numbers) written three ways, from
// highest level to lowest. Only the C++ versions run in this editor.

int main() {
    int a = 25, b = 17;

    // 1) Plain C++ — the optimizer turns this into one 'add' instruction.
    int high = a + b;                       // 42


...

2. Extended Asm Syntax: Outputs, Inputs & Clobbers

A GCC/Clang extended asm statement has four colon-separated parts: the instruction template, the output operands (what the asm writes), the input operands (what it reads), and the clobber list (registers and flags it trashes). Placeholders %0, %1, %2 in the template refer to those operands in order. The keyword asm volatile tells the optimizer "keep this exactly where it is — do not move or delete it". Read the anatomy below carefully; the operand model is the whole game.

#include <iostream>
using namespace std;

// Anatomy of a GCC/Clang EXTENDED asm statement (study, don't run):
//
//   asm volatile ( "template"
//                  : output operands     // things asm WRITES
//                  : input operands       // things asm READS
//                  : clobbers );          // registers/flags asm TRASHES
//
// %0, %1, %2 ... in the template refer to operands in order.
//
//   int x = 5, y;
//   asm volatile ("movl %1, %0"  // copy operand 1 into operand 0
/
...

int in = 10, out;
asm volatile ("incl %0"   // increment operand 0
              : "=r"(out)  // OUTPUT  %0: "=" write-only, "r" any register
              : "0"(in)    // INPUT   %1: "0" reuse %0's register, seeded with in
              : "cc");     // CLOBBER   : "cc" = we changed the flags register
// out == 11

// Constraints you meet first:
//   "r" any register   "m" memory   "i" immediate constant
//   "=" written only   "+" read AND written   "0".."9" tie to that operand
// Clobbers:  "memory" (we touched RAM)   "cc" (we touched the flags)

3. The Better Tool: Compiler Intrinsics

A compiler intrinsic looks like a normal function call but compiles down to a single CPU instruction. Examples: __builtin_popcount(x) counts set bits, __builtin_ctz(x) counts trailing zeros, and C++20's <bit> header gives portable std::popcount and std::countr_zero. The crucial difference from inline asm: the optimizer understands an intrinsic, so it can fold, reorder, and schedule it, and it stays portable across compilers. The example below uses a plain-C++ popcount so it runs here, with the real intrinsic shown in comments.

#include <iostream>
#include <cstdint>
using namespace std;

// Compiler intrinsics: function-shaped wrappers that compile to a
// single CPU instruction. They are the GOOD alternative to inline asm:
// portable, and the optimizer still understands them.
//
// GCC/Clang spell these __builtin_*; C++20 added portable versions in
// the <bit> header (std::popcount, std::countl_zero, ...).

// popcount = how many bits are set to 1. One CPU instruction on modern
// chips; here is a plain-C++ version 
...

Your turn. The program below is almost complete — fill in the two blanks marked ___ using the hints in the comments, then run it and check the expected output.

#include <iostream>
#include <cstdint>
using namespace std;

// A real program would call std::popcount; this loop is its portable twin.
int popcount(uint32_t x) {
    int count = 0;
    while (x) { count += x & 1; x >>= 1; }
    return count;
}

int main() {
    // 🎯 YOUR TURN — replace each ___ then press "Try it Yourself".

    // 1) Store the 8-bit pattern 1010 1010 (alternating bits)
    uint32_t pattern = ___;    // 👉 use 0b10101010  (binary literal)

    // 2) Count how many bits are se
...

4. SIMD & Letting the Optimizer Win

SIMD (Single Instruction, Multiple Data) processes several values with one instruction — SSE does 4 floats at a time, AVX does 8. You can hand-write it with intrinsics like _mm256_add_ps from <immintrin.h>, but the easiest and most portable path is to write a plain loop and compile with -O3 -march=native: modern compilers auto-vectorize it into exactly those wide instructions. The runnable loop below is one the optimizer will happily turn into AVX for you.

#include <iostream>
#include <vector>
using namespace std;

// SIMD = Single Instruction, Multiple Data: one instruction works on
// several values at once. SSE handles 4 floats per step, AVX handles 8.
//
// Real SIMD looks like this (study, don't run — needs the right CPU):
//   #include <immintrin.h>                  // AVX intrinsics
//   __m256 va = _mm256_loadu_ps(a + i);     // load 8 floats
//   __m256 vb = _mm256_loadu_ps(b + i);     // load 8 floats
//   __m256 vc = _mm256_add_ps(va, v
...

#include <iostream>
#include <cstdint>
using namespace std;

// A portable stand-in for the intrinsic std::countr_zero / __builtin_ctz.
int trailingZeros(uint32_t x) {
    if (x == 0) return 32;
    int count = 0;
    while (!(x & 1)) { count++; x >>= 1; }   // count low 0-bits
    return count;
}

int main() {
    // 🎯 MINI-CHALLENGE: alignment checker
    // Many fast routines need data aligned to 16 bytes. A value is
    // 16-byte aligned when its lowest 4 bits are zero — i.e. it has
    //
...