与硬件背靠背 · C++、C语言与汇编的协同

C++ 是一门"贴近硬件"的语言。它不仅能够无缝调用 C 语言代码，还能与汇编语言直接交互。这种能力使得 C++ 成为系统编程、嵌入式开发、性能优化领域的首选语言。

让我们探索 C++、C 语言与汇编之间的协同之道。

---

C++ 与 C 的血脉联系

C++ 起源于 C 语言，因此两者有着天然的兼容性。但直接混用时需要注意一些细节。

extern "C" 的作用

C++ 编译器会对函数名进行"名称修饰"（Name Mangling），以支持函数重载：

// C++ 中的这两个函数
void foo(int x);
void foo(double x);

// 编译后可能变成类似这样的名字
// _Z3fooi
// _Z3food

但 C 语言不支持函数重载，也不会进行名称修饰。为了让 C++ 调用 C 代码（或反过来），需要使用 extern "C"：

// 声明一个 C 函数
extern "C" void c_function(int x);

// 或者包裹多个声明
extern "C"
{
    void c_func1(int x);
    void c_func2(double y);
    int c_func3(const char* str);
}

// 在 C++ 中定义一个供 C 调用的函数
extern "C" int cpp_for_c(int a, int b)
{
    return a + b;
}

头文件的双重兼容

编写同时供 C 和 C++ 使用的头文件：

// mylib.h
#ifndef MYLIB_H
#define MYLIB_H

#ifdef __cplusplus
extern "C" {
#endif

// C 兼容的声明
void init_library(void);
int process_data(const char* input, int length);
void cleanup(void);

#ifdef __cplusplus
}
#endif

#endif // MYLIB_H

---

混合编译实战

假设我们有一个 C 语言写的数学库，想在 C++ 项目中使用：

// math_utils.c
#include "math_utils.h"

int factorial(int n)
{
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

double power(double base, int exp)
{
    double result = 1.0;
    for (int i = 0; i < exp; ++i)
        result *= base;
    return result;
}

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

#ifdef __cplusplus
extern "C" {
#endif

int factorial(int n);
double power(double base, int exp);

#ifdef __cplusplus
}
#endif

#endif

// main.cpp
#include <iostream>
#include "math_utils.h"

int main()
{
    std::cout << "5! = " << factorial(5) << std::endl;
    std::cout << "2^10 = " << power(2.0, 10) << std::endl;
    return 0;
}

编译命令：

gcc -c math_utils.c -o math_utils.o
g++ -c main.cpp -o main.o
g++ main.o math_utils.o -o program

---

内联汇编

C++ 允许在代码中直接嵌入汇编指令。不同编译器的语法略有不同。

GCC/Clang 风格（AT&T 语法）

#include <iostream>

int add_asm(int a, int b)
{
    int result;
    __asm__ (
        "addl %1, %2\n\t"    // 将 %1 加到 %2
        "movl %2, %0"        // 将结果移动到 %0
        : "=r" (result)      // 输出操作数
        : "r" (a), "r" (b)   // 输入操作数
        :                    // 被破坏的寄存器
    );
    return result;
}

// 更简单的例子：读取 CPU 时间戳
uint64_t read_tsc()
{
    uint32_t lo, hi;
    __asm__ volatile (
        "rdtsc"
        : "=a" (lo), "=d" (hi)
    );
    return ((uint64_t)hi << 32) | lo;
}

int main()
{
    std::cout << "3 + 5 = " << add_asm(3, 5) << std::endl;
    std::cout << "TSC: " << read_tsc() << std::endl;
    return 0;
}

MSVC 风格（Intel 语法）

#include <iostream>

int add_asm(int a, int b)
{
    __asm
    {
        mov eax, a
        add eax, b
        // 返回值自动在 eax 中
    }
}

int main()
{
    std::cout << "3 + 5 = " << add_asm(3, 5) << std::endl;
    return 0;
}

注意：MSVC 的内联汇编仅支持 32 位模式。64 位程序需要使用单独的汇编文件。

---

调用外部汇编函数

对于复杂的汇编代码，通常将其放在单独的 .asm 或 .s 文件中。

; fast_math.asm (NASM 语法)
section .text
global fast_multiply

; int fast_multiply(int a, int b)
fast_multiply:
    mov eax, edi      ; 第一个参数 (System V ABI)
    imul eax, esi     ; 乘以第二个参数
    ret

// main.cpp
#include <iostream>

extern "C" int fast_multiply(int a, int b);

int main()
{
    std::cout << "7 * 8 = " << fast_multiply(7, 8) << std::endl;
    return 0;
}

编译命令（Linux）：

nasm -f elf64 fast_math.asm -o fast_math.o
g++ main.cpp fast_math.o -o program

---

调用约定

不同平台有不同的函数调用约定（Calling Convention），理解它们对于 C++/汇编混合编程至关重要。

x86-64 System V ABI（Linux、macOS）

• 前 6 个整数参数：rdi, rsi, rdx, rcx, r8, r9

• 前 8 个浮点参数：xmm0 - xmm7

• 返回值：rax（整数）、xmm0（浮点）

; 示例：int func(int a, int b, int c)
; a 在 edi, b 在 esi, c 在 edx

x86-64 Windows ABI

• 前 4 个参数：rcx, rdx, r8, r9（整数或指针）

• 浮点数也用这些寄存器对应的 XMM 寄存器

• 返回值：rax

; 示例：int func(int a, int b, int c)
; a 在 ecx, b 在 edx, c 在 r8d

---

实战：SIMD 优化

使用汇编或编译器内置函数进行 SIMD（单指令多数据）优化：

#include <iostream>
#include <immintrin.h>  // Intel SIMD 内置函数
#include <chrono>

// 普通版本
void add_arrays_normal(float* a, float* b, float* c, int n)
{
    for (int i = 0; i < n; ++i)
        c[i] = a[i] + b[i];
}

// SIMD 版本（AVX）
void add_arrays_simd(float* a, float* b, float* c, int n)
{
    int i = 0;
    // 每次处理 8 个 float
    for (; i + 7 < n; i += 8)
    {
        __m256 va = _mm256_loadu_ps(&a[i]);
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(&c[i], vc);
    }
    // 处理剩余元素
    for (; i < n; ++i)
        c[i] = a[i] + b[i];
}

int main()
{
    const int N = 10000000;
    float* a = new float[N];
    float* b = new float[N];
    float* c = new float[N];
    
    // 初始化
    for (int i = 0; i < N; ++i)
    {
        a[i] = i * 0.1f;
        b[i] = i * 0.2f;
    }
    
    // 测试普通版本
    auto start = std::chrono::high_resolution_clock::now();
    add_arrays_normal(a, b, c, N);
    auto end = std::chrono::high_resolution_clock::now();
    auto normal_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    // 测试 SIMD 版本
    start = std::chrono::high_resolution_clock::now();
    add_arrays_simd(a, b, c, N);
    end = std::chrono::high_resolution_clock::now();
    auto simd_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    std::cout << "Normal: " << normal_time.count() << " us" << std::endl;
    std::cout << "SIMD:   " << simd_time.count() << " us" << std::endl;
    
    delete[] a;
    delete[] b;
    delete[] c;
    return 0;
}

---

链接 C 库

C++ 程序经常需要链接系统级 C 库：

#include <iostream>
#include <cstring>  // C 字符串函数
#include <cstdlib>  // C 标准库函数
#include <cmath>    // C 数学函数

// 直接使用 POSIX/Windows API
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
    #include <sys/types.h>
#endif

int main()
{
    // 使用 C 库函数
    char buffer[100];
    std::strcpy(buffer, "Hello");
    std::strcat(buffer, " World");
    std::cout << buffer << std::endl;
    
    // 环境变量
    const char* path = std::getenv("PATH");
    if (path)
        std::cout << "PATH: " << path << std::endl;
    
    // 数学函数
    std::cout << "sin(π/2) = " << std::sin(3.14159265 / 2) << std::endl;
    
    return 0;
}

---

volatile 关键字

在与硬件交互或多线程编程中，volatile 防止编译器优化掉看似"无用"的读写：

// 内存映射硬件寄存器
volatile uint32_t* const HARDWARE_REG = (uint32_t*)0x40000000;

void wait_for_hardware()
{
    // 没有 volatile，编译器可能优化掉这个循环
    while (*HARDWARE_REG & 0x01)
    {
        // 等待硬件就绪
    }
}

void write_hardware(uint32_t value)
{
    *HARDWARE_REG = value;  // 确保真正写入
}

---

裸函数（Naked Function）

某些编译器支持"裸函数"，让你完全控制函数的汇编代码：

// MSVC
__declspec(naked) int my_naked_func(int x)
{
    __asm
    {
        mov eax, [esp+4]
        add eax, 10
        ret
    }
}

// GCC
__attribute__((naked)) int my_naked_func(int x)
{
    __asm__ (
        "movl 4(%esp), %eax\n\t"
        "addl $10, %eax\n\t"
        "ret"
    );
}

---

总结

C++、C 语言和汇编的协同使用，打开了通往系统底层的大门：

场景	技术
调用 C 库	extern "C"
性能关键代码	内联汇编、SIMD 内置函数
硬件交互	volatile、内存映射
底层系统调用	外部汇编文件
跨语言接口	遵循调用约定

掌握这些技术，你就能在保持 C++ 高级抽象的同时，在需要时直达硬件层面，实现极致的性能优化。