# 创建测试文件
cat > bench.c << 'EOF'
#include <stdio.h>
#include <time.h>

#define N 100000000

double compute(void) {
    double sum = 0.0;
    for (int i = 0; i < N; i++) {
        sum += 1.0 / (i + 1);
    }
    return sum;
}

int main(void) {
    clock_t start = clock();
    double result = compute();
    clock_t end = clock();
    printf("Result: %.6f\n", result);
    printf("Time: %.3f sec\n", (double)(end - start) / CLOCKS_PER_SEC);
    return 0;
}
EOF

# 对比不同优化级别
for opt in O0 Og O1 O2 O3 Os Ofast; do
    gcc -$opt -o bench_$opt bench.c
    echo -n "$opt: "
    ./bench_$opt
done

# 查看 -O1 包含的具体优化
gcc -O1 -Q --help=optimizers 2>&1 | grep enabled

# -Os 开启大部分 -O2 的优化，但禁用增加代码大小的优化
gcc -Os -o hello_small main.c

# 具体差异:
# - 禁用函数对齐（-falign-functions=0）
# - 更保守的内联阈值
# - 禁用循环展开
# - 优先选择更小的指令序列

# -Og 启用不影响调试的优化
gcc -g -Og -o hello main.c

# 包含的优化:
# -fauto-inc-dec
# -fdefer-pop
# -fdse
# -fif-conversion
# -fmerge-constants

# 不包含（以免影响调试）:
# - 帧指针省略（保持栈帧可追溯）
# - 激进的内联（保持函数边界清晰）
# - 指令重排序（保持执行顺序与源码一致）

# -Ofast = -O3 + 可能违反标准的优化
gcc -Ofast -o hello_fast main.c

# 包含的关键非标准优化:
# -ffast-math     ← 允许浮点运算不符合 IEEE 754
# -fallow-store-data-races  ← 允许存储数据竞争

// -ffast-math 可能导致的问题:
double x = 0.0 / 0.0;  // NaN
if (x != x) {  // NaN 的标准检测方式
    printf("NaN detected\n");
}

// 使用 -ffast-math 时，-ffinite-math-only 使此检查失效！
// 如果你的代码依赖 NaN/Inf 行为，不要使用 -Ofast

cat > vector_test.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>

#define N 10000

void add_arrays(float *a, float *b, float *c, int n) {
    for (int i = 0; i < n; i++) {
        c[i] = a[i] + b[i];
    }
}

int main(void) {
    float a[N], b[N], c[N];
    for (int i = 0; i < N; i++) {
        a[i] = (float)i;
        b[i] = (float)(i * 2);
    }
    add_arrays(a, b, c, N);
    printf("c[0]=%.1f c[N-1]=%.1f\n", c[0], c[N-1]);
    return 0;
}
EOF

# 无向量化
gcc -O2 -fopt-info-vec-missed -o vec_test vector_test.c
# 输出类似: vector_test.c:6:5: missed: couldn't vectorize loop

# 有向量化
gcc -O2 -fopt-info-vec-optimized -o vec_test vector_test.c
# 输出类似: vector_test.c:6:5: optimized: loop vectorized

# 查看向量化报告
gcc -O3 -ftree-vectorizer-verbose=2 -o vec_test vector_test.c 2>&1

cat > inline_test.c << 'EOF'
static int square(int x) { return x * x; }
static int cube(int x) { return x * x * x; }

int compute(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += square(i) + cube(i);
    }
    return sum;
}
EOF

# 查看是否内联
gcc -O2 -Winline -o inline_test inline_test.c

# 查看内联决策
gcc -O2 -fdump-ipa-inline-details -o inline_test inline_test.c
# 生成 inline_test.c.***.ipa-inline 文件

# 启用 LTO
gcc -flto -O2 -o hello main.c greet.c

# 等价于分步 LTO
gcc -flto -O2 -c main.c -o main.o
gcc -flto -O2 -c greet.c -o greet.o
gcc -flto -O2 -o hello main.o greet.o

# 默认 LTO（使用完整的 GIMPLE IR，最优化但最慢）
gcc -flto -O2 -o hello main.c

# 薄 LTO（ThinLTO，GCC 11+，更快的编译速度）
gcc -flto=auto -O2 -o hello main.c
# flto=auto 让 GCC 自动决定使用完整 LTO 还是并行 LTO

# 指定并行 LTO 线程数
gcc -flto=4 -O2 -o hello main.c  # 使用 4 个线程

# 对比 LTO 开启前后的代码大小和性能
cat > lto_test_a.c << 'EOF'
static int internal_func(int x) {
    return x * x + 2 * x + 1;
}

int compute_a(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += internal_func(i);
    }
    return sum;
}
EOF

cat > lto_test_b.c << 'EOF'
extern int compute_a(int n);
#include <stdio.h>
int main(void) {
    printf("%d\n", compute_a(1000));
    return 0;
}
EOF

# 无 LTO
gcc -O2 -c lto_test_a.c -o lto_test_a.o
gcc -O2 -c lto_test_b.c -o lto_test_b.o
gcc -o no_lto lto_test_a.o lto_test_b.o

# 有 LTO
gcc -flto -O2 -c lto_test_a.c -o lto_test_a_lto.o
gcc -flto -O2 -c lto_test_b.c -o lto_test_b_lto.o
gcc -flto -O2 -o with_lto lto_test_a_lto.o lto_test_b_lto.o

# 对比
ls -l no_lto with_lto
# with_lto 通常更小，因为 LTO 可以优化掉 internal_func

# 使用 LTO 兼容的 ar 和 ranlib
gcc -flto -O2 -c lib.c -o lib.o
gcc-ar rcs libmylib.a lib.o      # 使用 gcc-ar 而非 ar
gcc-ranlib libmylib.a            # 使用 gcc-ranlib

步骤 1: 插桩编译
  源代码 → gcc -fprofile-generate → 插桩的可执行文件

步骤 2: 收集运行数据
  插桩的可执行文件 → 运行典型负载 → .gcda 文件（性能数据）

步骤 3: 优化编译
  源代码 + .gcda → gcc -fprofile-use → 优化后的可执行文件

cat > pgo_test.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

// 模拟实际的热点函数
int process_data(const char *data, int len) {
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += data[i] * (i % 7 + 1);
    }
    return sum;
}

int classify(int value) {
    if (value > 1000) return 3;
    if (value > 100) return 2;
    if (value > 10) return 1;
    return 0;
}

int main(void) {
    srand(time(NULL));
    char data[1024];
    for (int i = 0; i < sizeof(data); i++) {
        data[i] = rand() % 256;
    }
    
    int results[4] = {0};
    for (int i = 0; i < 100000; i++) {
        int val = process_data(data, sizeof(data));
        results[classify(val)]++;
    }
    
    for (int i = 0; i < 4; i++) {
        printf("Class %d: %d\n", i, results[i]);
    }
    return 0;
}
EOF

# 步骤 1: 插桩编译
gcc -O2 -fprofile-generate -o pgo_instrumented pgo_test.c

# 步骤 2: 运行收集数据
./pgo_instrumented
# 生成 pgo_test.gcda 文件

# 步骤 3: 使用数据优化编译
gcc -O2 -fprofile-use -o pgo_optimized pgo_test.c

# 清理
rm -f pgo_instrumented pgo_test.gcda pgo_test.gcno

# 组合使用效果最佳
# 步骤 1: 插桩编译（LTO + PGO generate）
gcc -flto -O2 -fprofile-generate -o pgo_instrumented main.c

# 步骤 2: 运行
./pgo_instrumented

# 步骤 3: 优化编译（LTO + PGO use）
gcc -flto -O2 -fprofile-use -o final_optimized main.c

// 对特定函数设置优化级别
__attribute__((optimize("O3")))
void hot_function(int *data, int n) {
    for (int i = 0; i < n; i++) {
        data[i] *= 2;
    }
}

__attribute__((optimize("O0")))
void debug_function(void) {
    // 不优化，便于调试
}

// 对特定函数禁用某项优化
__attribute__((optimize("no-tree-vectorize")))
void no_vectorize_func(int *data, int n) {
    // 禁止此函数的自动向量化
}

#pragma GCC optimize("O3")
void hot_function(void) { ... }
#pragma GCC reset_options

#pragma GCC target("avx2")
void avx2_function(float *data, int n) {
    // 此函数使用 AVX2 指令集
}

// -fstrict-aliasing（-O2 及以上默认开启）
// 通过不同类型指针访问同一内存是未定义行为！

int x = 0x3f800000;
float *f = (float *)&x;       // ❌ 严格别名违规
float val = *f;                // 未定义行为！

// 正确做法：使用 memcpy
int x = 0x3f800000;
float f;
memcpy(&f, &x, sizeof(f));   // ✅ 安全且编译器能优化掉

// 或使用 union（GCC 支持但标准未保证）
union { int i; float f; } u;
u.i = 0x3f800000;
float val = u.f;              // GCC 支持

// IEEE 754 保证的 NaN 检测在 -ffast-math 下失效
int is_nan(double x) {
    return x != x;  // 在 -ffast-math 下始终返回 false!
}

// 安全替代方案
#include <math.h>
int is_nan_safe(double x) {
    return isnan(x);  // 使用标准库函数
}