指针与内联汇编：在C中嵌入汇编时指针的使用

说实话，很多C语言开发者一听到「内联汇编」四个字就头大。我当年也是这样。总觉得C已经够底层了，干嘛还要碰汇编？直到我在一个Bootloader项目里，需要直接操作某个特殊寄存器地址——用纯C写总是被编译器优化掉，折腾了两天。最后用内联汇编加指针，三行代码搞定。

嗯，从那天起我就明白了：指针和内联汇编，其实是天生一对。指针给你地址，汇编让你直接操作那个地址。两者结合，你就能在C代码里干一些「越界」的事。

为什么需要内联汇编中的指针？

你想想看，C语言再怎么底层，终究是高级语言。有些场景它确实管不了：

• 读写CPU的特殊寄存器（比如状态寄存器、控制寄存器）
• 执行特殊的CPU指令（比如内存屏障、关中断）
• 精确控制某段内存的访问时序

这时候，内联汇编就派上用场了。而指针，就是C和汇编之间的「信使」——你把地址通过指针传给汇编，汇编直接在那个地址上干活。

GCC内联汇编的基本语法

GCC的内联汇编用 asm() 或 __asm__() 来写。基本格式长这样：

__asm__ volatile (
    "汇编指令\n\t"
    : 输出操作数
    : 输入操作数
    : 被破坏的寄存器列表
);

这里面的 volatile 很关键——告诉编译器「别优化我，老老实实执行」。我在调试一个中断处理函数时，就因为漏了 volatile，编译器把汇编指令给挪了位置，导致中断响应时序全乱套。

指针作为内联汇编的输入

最常见的用法，就是把一个指针变量的值（也就是地址）传给汇编，让汇编去读写那个地址。看个例子：

#include <stdint.h>

void write_to_register(uint32_t *reg_addr, uint32_t value) {
    __asm__ volatile (
        "str %1, [%0]\n\t"   // ARM汇编：将value存入reg_addr指向的地址
        :
        : "r"(reg_addr), "r"(value)
        : "memory"
    );
}

这里 %0 对应第一个操作数 reg_addr，%1 对应 value。"r" 表示让编译器自己选一个通用寄存器来放这个值。

指针作为内联汇编的输出

反过来，你也可以让汇编往指针指向的地址写数据，然后C代码接着用。比如读一个硬件寄存器的值：

uint32_t read_from_register(uint32_t *reg_addr) {
    uint32_t value;
    __asm__ volatile (
        "ldr %0, [%1]\n\t"   // ARM汇编：从reg_addr指向的地址读数据到value
        : "=r"(value)
        : "r"(reg_addr)
        : "memory"
    );
    return value;
}

注意输出操作数前面多了个 =，表示「只写」。这是GCC内联汇编的规矩——告诉编译器这个操作数是被写入的，不是读入的。

避坑指南：指针类型与汇编指令的匹配

我曾经在一个项目里犯过这样的错：用 uint32_t* 指针传地址，但汇编里用了 ldrb（加载一个字节）指令。结果读出来的数据完全不对，因为 ldrb 只读一个字节，而寄存器里存的是32位值。

所以记住一条铁律：指针的类型决定了汇编指令的数据宽度。

指针类型	对应汇编指令（ARM为例）	数据宽度
uint8_t*	ldrb / strb	1字节
uint16_t*	ldrh / strh	2字节
uint32_t*	ldr / str	4字节
uint64_t*	ldrd / strd	8字节

一个完整的例子：用内联汇编实现内存拷贝

下面这个例子，用内联汇编实现了一个简单的内存拷贝函数。它用指针传递源地址和目标地址，汇编里用循环一次拷贝4字节：

#include <stdint.h>

void my_memcpy(uint32_t *dst, const uint32_t *src, uint32_t count) {
    __asm__ volatile (
        "1:\n\t"
        "ldr r3, [%1], #4\n\t"   // 从src加载，然后src+=4
        "str r3, [%0], #4\n\t"   // 存入dst，然后dst+=4
        "subs %2, %2, #1\n\t"    // count--
        "bne 1b\n\t"             // 如果count不为0，跳回1标签
        : "+r"(dst), "+r"(src), "+r"(count)
        :
        : "r3", "memory"
    );
}

这里用了 "+r" 而不是 "r"——+ 表示这个操作数既读又写。因为我们在循环里修改了 dst、src 和 count 的值。

知识体系总览

下面这张图，把指针和内联汇编的关系梳理清楚了：

实际项目中的经验

我在做嵌入式Bootloader时，经常需要直接操作NAND Flash控制器寄存器。这些寄存器都是内存映射的，说白了就是一些固定的地址。用指针加内联汇编，我可以精确控制每次读写操作的时序，不会被编译器优化打乱。

举个例子，NAND Flash的读操作需要先写命令，再写地址，最后读数据。每一步之间需要微秒级的延迟。如果用纯C，编译器可能把多个写操作合并成一次，或者调整顺序。但用内联汇编，指令的执行顺序完全由你控制：

void nand_read_page(uint32_t *buf, uint32_t page_addr) {
    uint32_t *nand_cmd  = (uint32_t*)0x4A000000;
    uint32_t *nand_addr = (uint32_t*)0x4A000004;
    uint32_t *nand_data = (uint32_t*)0x4A000008;
    
    // 写读命令
    __asm__ volatile (
        "str %0, [%1]\n\t"
        :
        : "r"(0x00), "r"(nand_cmd)
        : "memory"
    );
    
    // 写地址
    __asm__ volatile (
        "str %0, [%1]\n\t"
        :
        : "r"(page_addr), "r"(nand_addr)
        : "memory"
    );
    
    // 读数据到缓冲区
    for(int i = 0; i < 2048/4; i++) {
        __asm__ volatile (
            "ldr %0, [%1]\n\t"
            : "=r"(buf[i])
            : "r"(nand_data)
            : "memory"
        );
    }
}

你看，每个操作都用 volatile 包起来，编译器不敢动。指针直接指向硬件地址，汇编直接读写。这就是指针和内联汇编配合的典型场景。

总结一下

指针和内联汇编，说白了就是C语言里的「特权指令」。指针给你地址，汇编让你在那个地址上为所欲为。但权力越大责任越大——用的时候一定要小心：

• 指针类型要和汇编指令的数据宽度匹配
• 别忘了 volatile 和 "memory"
• 输入输出操作数的修饰符（=、+）别搞错
• 不同CPU架构的汇编指令不同，查手册再写

嗯，掌握了这些，你就能在C代码里安全地「越权」操作硬件了。下次遇到需要精确控制内存访问的场景，试试指针加内联汇编——你会发现，原来C和汇编可以配合得这么默契。

---