在程序开发中，内存复制操作（如memcpy）往往是性能瓶颈的关键来源——尤其是大型内存块的复制，可能导致缓存失效、带宽占用过高等问题。为了精准定位这些潜在的性能热点，开发者需要一种能自动识别程序中memcpy调用，并提取其关键信息（如复制大小、所在位置）的工具。本文将解析一款基于LLVM的memcpy静态分析工具，探讨其设计思路、实现原理及相关技术背景。

工具功能概述

这款工具的核心目标是静态扫描LLVM IR（中间表示）或bitcode文件，自动识别其中所有的llvm.memcpy调用（LLVM中内存复制的标准内在函数），并输出以下关键信息：

每次memcpy的复制大小（以字节为单位）；
调用所在的函数；
对应的源代码位置（文件名、行号）——依赖调试信息（Debug Info）；
支持按复制大小排序（从大到小），并可切换"详细信息"和"摘要"两种输出模式。

简单来说，它就像一个"内存复制探测器"，能帮开发者快速找到程序中哪些地方在进行大型内存复制，以及这些操作对应源代码的具体位置。

设计思路：从需求到方案的映射

工具的设计围绕"如何高效定位并提取memcpy关键信息"展开，核心思路可概括为**“层次化遍历+精准筛选+信息聚合”**。

1. 层次化遍历：从文件到指令的解析路径

要分析memcpy调用，首先需要"读懂"LLVM IR文件。LLVM IR是一种结构化的中间表示，其核心层次结构为：模块（Module）→ 函数（Function）→ 基本块（BasicBlock）→ 指令（Instruction）。

工具的遍历逻辑正是遵循这一层次：

先加载整个IR文件作为一个"模块"（Module），这是LLVM IR的顶层容器；
遍历模块中的所有函数（Function）——函数是程序行为的基本单元；
每个函数由多个基本块（BasicBlock）组成，遍历每个基本块；
最终遍历基本块中的每一条指令（Instruction），因为memcpy调用本质上是一条函数调用指令。

这种层次化遍历确保不会遗漏任何潜在的memcpy调用，符合LLVM IR的结构化设计特点。

2. 精准筛选：锁定`llvm.memcpy`调用

在遍历指令的过程中，需要从海量指令中精准识别出memcpy调用。关键筛选逻辑基于两点：

指令类型：memcpy是函数调用，因此只关注CallInst（函数调用指令）类型的指令；
被调用函数名：LLVM中内存复制操作统一通过内在函数llvm.memcpy实现（其变体如llvm.memcpy.p0i8.p0i8.i64等也包含"memcpy"标识），因此通过检查被调用函数的名称是否包含"memcpy"即可锁定目标。

3. 信息聚合：提取关键数据

找到memcpy调用后，需要提取三类核心信息：

复制大小：llvm.memcpy的函数签名为void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %size, i32 %align, i1 %isvolatile)，其中第三个参数正是复制大小（%size）。工具通过解析该参数（需确保其为常量，否则无法确定具体值），获取字节数；
所在函数：记录该memcpy调用属于哪个函数，用于定位上下文；
调试信息：通过LLVM的元数据（Metadata）中的"dbg"字段，解析出对应的源代码文件名、行号甚至所属子程序（Subprogram），实现IR指令到源代码的映射。

4. 排序与输出：聚焦关键热点

为了让开发者快速关注最可能影响性能的大型复制操作，工具会按复制大小从大到小排序结果。同时，提供"详细信息"（包含调试信息、所在函数）和"摘要"（仅显示大小）两种输出模式，兼顾深度分析与快速概览的需求。

实现原理：依托LLVM的核心技术

来看看代码实现

#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Debug.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/Support/SourceMgr.h"#include "llvm/Support/raw_ostream.h"
#include "llvm/Bitcode/BitcodeReader.h"
#include <iostream>...void print_all(vector<tuple<CallInst*, uint64_t, Function*>> &memcpys) {for (auto& i : memcpys) {
...cout << "memcpy" << " of " << size << " in " << function->getName().data() << " @ " << std::endl;MDNode* metadata = callInst->getMetadata("dbg");if (!metadata) {cout << "  no debug info" << endl;continue;}DILocation *debugLocation = dyn_cast<DILocation>(metadata);while (debugLocation) {DILocalScope *scope = debugLocation->getScope();cout << "  ";if (scope) {DISubprogram *subprogram = scope->getSubprogram();if (subprogram) {const char* name = subprogram->getName().data();cout << name << " ";}}cout << debugLocation->getFilename().data() << ":" << debugLocation->getLine() << std::endl;debugLocation = debugLocation->getInlinedAt();}}
}void print_summary(vector<tuple<CallInst*, uint64_t, Function*>> &memcpys) {for (auto& i : memcpys) {auto callInst = get<0>(i);auto size = get<1>(i);auto function = get<2>(i);cout << "memcpy" << " of " << size << std::endl;}
}int main(int argc, char **argv) {
...if (argc > 2) {if (std::string(argv[2]) == "summary") {summary = true;}}Expected<std::unique_ptr<Module> > m = parseIRFile(fileName, Err, context);if (!m) {errs() << toString(m.takeError()) << "\n";}vector<tuple<CallInst*, uint64_t, Function*>> memcpys;{auto &functionList = m->get()->getFunctionList();for (auto &function : functionList) {//printf("%s\n", function.getName().data());for (auto &bb : function) {for (auto &instruction : bb) {//printf("  %s\n", instruction.getOpcodeName());CallInst *callInst = dyn_cast<CallInst>(&instruction);if (callInst == nullptr) {continue;}//printf("have call\n");Function *calledFunction = callInst->getCalledFunction();if (calledFunction == nullptr) {//printf("no calledFunction\n");continue;}StringRef cfName = calledFunction->getName();if (cfName.find("llvm.memcpy") != std::string::npos) {auto size_operand = callInst->getOperand(2);auto size_constant = dyn_cast<ConstantInt>(size_operand);if (!size_constant) {//printf("not constant\n");continue;}auto size = size_constant->getValue().getLimitedValue();memcpys.push_back({callInst, size, &function});}}}}}std::sort(memcpys.begin(), memcpys.end(), [](auto& x, auto &y) {if (get<1>(y) == get<1>(x)) {return get<2>(x) > get<2>(y);} else {return get<1>(x) > get<1>(y);}});if (summary) {print_summary(memcpys);} else {print_all(memcpys);}
}

If you need the complete source code, please add the WeChat number (c17865354792)

工具的实现深度依赖LLVM的API和中间表示特性，其核心原理可归纳为三点：

1. LLVM IR的结构化访问

LLVM提供了一套完整的API用于遍历和操作IR结构：

通过parseIRFile加载IR文件并解析为Module对象；
通过Module::getFunctionList()遍历所有函数；
函数的基本块可通过Function::begin()到Function::end()遍历；
基本块中的指令可通过BasicBlock::begin()到BasicBlock::end()遍历。

这种结构化访问方式让工具能高效遍历程序中的所有指令，无需关心IR的底层语法细节。

2. 内在函数与指令解析

LLVM的内在函数（如llvm.memcpy）是编译器内部用于表达特定操作的特殊函数，其名称和参数列表具有固定规范。工具通过以下步骤解析memcpy指令：

用dyn_cast<CallInst>判断指令是否为函数调用；
用CallInst::getCalledFunction()获取被调用函数；
检查函数名是否包含"memcpy"，确认是内存复制操作；
提取第三个参数（CallInst::getOperand(2)），并通过dyn_cast<ConstantInt>转换为整数，获取复制大小（仅处理常量大小，动态大小无法在静态分析中确定具体值）。