使用 LLVM 框架创建有效的编译器，第 2 部分

使用 clang 预处理 C/C++ 代码

无论您使用哪一种编程语言，LLVM 编译器基础架构都会提供一种强大的方法来优化您的应用程序。在这个两部分系列的第二篇文章中，了解在 LLVM 中测试代码，使用 clang API 对C/C++ 代码进行预处理。

 评论：

Arpan Sen, 作家, Independent

2012 年 7 月 31 日

• 内容

本系列的其他文章

查看 使用 LLVM 框架创建有效的编译器 系列中的更多文章。

使用 LLVM 框架创建一个工作编译器，第 1 部分 探讨了 LLVM 中间表示 (IR)。您手动创建了一个 “Hello World” 测试程序；了解了 LLVM 的一些细微差别（如类型转换）；并使用 LLVM 应用程序编程接口 (API) 创建了相同的程序。在这一过程中，您还了解到一些 LLVM 工具，如llc 和 lli，并了解了如何使用 llvm-gcc 为您发出 LLVM IR。本文是系列文章的第二篇也是最后一篇，探讨了可以与 LLVM 结合使用的其他一些炫酷功能。具体而言，本文将介绍代码测试，即向生成的最终可执行的代码添加信息。本文还简单介绍了 clang，这是 LLVM 的前端，用于支持 C、C++ 和 Objective-C。您可以使用 clang API 对 C/C++ 代码进行预处理并生成一个抽象语法树 (AST)。

LLVM 阶段

LLVM 以其提供的优化特性而著名。优化被实现为阶段 (pass)（有关 LLVM 阶段的高级功能的细节，请参见 参考资料）。这里需要注意的是 LLVM 为您提供了使用最少量的代码创建实用阶段 (utility pass) 的功能。例如，如果不希望使用 “hello” 作为函数名称的开头，那么可以使用一个实用阶段来实现这个目的。

了解 LLVM opt 工具

从 opt 的手册页中可以看到，“opt 命令是模块化的 LLVM 优化器和分析器”。一旦您的代码支持定制阶段，您将使用 opt 把代码编译为一个共享库并对其进行加载。如果您的 LLVM 安装进展顺利，那么 opt 应该已经位于您的系统中。opt 命令接受 LLVM IR（扩展名为 .ll）和 LLVM 位码格式（扩展名为 .bc），可以生成 LLVM IR 或位码格式的输出。下面展示了如何使用 opt 加载您的定制共享库：

tintin# opt –load=mycustom_pass.so –help –S

还需注意，从命令行运行 opt –help 会生成一个 LLVM 将要执行的阶段的细目清单。对 help 使用 load 选项将生成一条帮助消息，其中包括有关定制阶段的信息。

创建定制的 LLVM 阶段

您需要在 Pass.h 文件中声明 LLVM 阶段，该文件在我的系统中被安装到 /usr/include/llvm 下。该文件将各个阶段的接口定义为 Pass 类的一部分。各个阶段的类型都从 Pass 中派生，也在该文件中进行了声明。阶段类型包括：

• BasicBlockPass 类。用于实现本地优化，优化通常每次针对一个基本块或指令运行
• FunctionPass 类。用于全局优化，每次执行一个功能
• ModulePass 类。用于执行任何非结构化的过程间优化

由于您打算创建一个阶段，该阶段拒绝任何以 “Hello ” 开头的函数名，因此需要通过从 FunctionPass 派生来创建自己的阶段。从 Pass.h 中复制 清单 1 中的代码。

清单 1. 覆盖 FunctionPass 中的 runOnFunction 类

Class FunctionPass : public Pass {   /// explicit FunctionPass(char &pid) : Pass(PT_Function, pid) {}  /// runOnFunction - Virtual method overridden by subclasses to do the  /// per-function processing of the pass.  ///  virtual bool runOnFunction(Function &F) = 0;  /// …};

同样，BasicBlockPass 类声明了一个 runOnBasicBlock，而 ModulePass 类声明了 runOnModule 纯虚拟方法。子类需要为虚拟方法提供一个定义。

返回到 清单 1 中的 runOnFunction 方法，您将看到输出为类型 Function 的对象。深入钻研 /usr/include/llvm/Function.h 文件，就会很容易发现 LLVM 使用 Function 类封装了一个 C/C++ 函数的功能。而 Function 派生自 Value.h 中定义的 Value 类，并支持 getName 方法。清单 2 显示了代码。

清单 2. 创建一个定制 LLVM 阶段

#include "llvm/Pass.h"#include "llvm/Function.h"class TestClass : public llvm::FunctionPass {public:virtual bool runOnFunction(llvm::Function &F)  {    if (F.getName().startswith("hello"))    {      std::cout << "Function name starts with hello\n";    }    return false;  }};

清单 2 中的代码遗漏了两个重要的细节：

• FunctionPass 构造函数需要一个 char，用于在 LLVM 内部使用。LLVM 使用 char 的地址，因此您可以使用任何内容对它进行初始化。
• 您需要通过某种方式让 LLVM 系统理解您所创建的类是一个新阶段。这正是 RegisterPass LLVM 模板发挥作用的地方。您在 PassSupport.h 头文件中声明了 RegisterPass 模板；该文件包含在 Pass.h 中，因此无需额外的标头。

清单 3 展示了完整的代码。

清单 3. 注册 LLVM Function 阶段

class TestClass : public llvm::FunctionPass{public:  TestClass() : llvm::FunctionPass(TestClass::ID) { }  virtual bool runOnFunction(llvm::Function &F) {    if (F.getName().startswith("hello")) {      std::cout << "Function name starts with hello\n";    }    return false;  }  static char ID; // could be a global too};char TestClass::ID = 'a';static llvm::RegisterPass<TestClass> global_("test_llvm", "test llvm", false, false);

RegisterPass 模板中的参数 template 是将要在命令行中与 opt 一起使用的阶段的名称。也就是说，您现在所需做的就是在 清单 3 中的代码之外创建一个共享库，然后运行 opt 来加载该库，之后是使用 RegisterPass 注册的命令的名称（在本例中为 test_llvm），最后是一个位码文件，您的定制阶段将在该文件中与其他阶段一起运行。清单 4 中概述了这些步骤。

清单 4. 运行定制阶段

bash$ g++ -c pass.cpp -I/usr/local/include `llvm-config --cxxflags`bash$ g++ -shared -o pass.so pass.o -L/usr/local/lib `llvm-config --ldflags -libs`bash$ opt -load=./pass.so –test_llvm < test.bc

现在让我们了解另一个工具（LLVM 后端的前端）：clang。

回页首

clang 简介

开始之前的注意事项

Clang 目前正在开发阶段，和相同规模的任何项目一样，项目文档通常要在代码基完成之后才能就绪。因此，最好的方法是查看开发人员邮件列表（参见 参考资料 中的链接）。您可能希望构建并安装 clang 源，为此，您需要执行 clang 起步指南（参见 参考资料）中的说明。注意，要安装到默认的系统文件夹，您需要在构建完成后发出make install 命令。本文后面的内容将假设 clang 标头和库分别位于类似于 /usr/local/include 和 /usr/local/lib 的系统文件夹中。

LLVM 拥有自己的前端：名为 clang 的一种工具（恰如其分）。Clang 是一种功能强大的C/C++/Objective-C 编译器，其编译速度可以媲美甚至超过 GNU Compiler Collection (GCC) 工具（参见 参考资料 中的链接，获取更多信息）。更重要的是，clang 拥有一个可修改的代码基，可以轻松实现定制扩展。与在 使用 LLVM 框架创建一个工作编译器，第 1 部分 中对定制插件使用 LLVM 后端 API 的方式非常类似，本文将对 LLVM 前端使用该 API 并开发一些小的应用程序来实现预处理和解析功能。

常见的 clang 类

您需要熟悉一些最常见的 clang 类：

• CompilerInstance
• Preprocessor
• FileManager
• SourceManager
• DiagnosticsEngine
• LangOptions
• TargetInfo
• ASTConsumer
• Sema
• ParseAST 也许是最重要的 clang 方法。

稍后将详细介绍 ParseAST 方法。

要实现所有实用的用途，考虑使用适当的 CompilerInstance 编译器。它提供了接口，管理对 AST 的访问，对输入源进行预处理，而且维护目标信息。典型的应用程序需要创建 CompilerInstance 对象来完成有用的功能。清单 5 展示了 CompilerInstance.h 头文件的大致内容。

清单 5. CompilerInstance 类

class CompilerInstance : public ModuleLoader {  /// The options used in this compiler instance.  llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation;  /// The diagnostics engine instance.  llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;  /// The target being compiled for.  llvm::IntrusiveRefCntPtr<TargetInfo> Target;  /// The file manager.  llvm::IntrusiveRefCntPtr<FileManager> FileMgr;  /// The source manager.  llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr;  /// The preprocessor.  llvm::IntrusiveRefCntPtr<Preprocessor> PP;  /// The AST context.  llvm::IntrusiveRefCntPtr<ASTContext> Context;  /// The AST consumer.  OwningPtr<ASTConsumer> Consumer; /// \brief The semantic analysis object.  OwningPtr<Sema> TheSema; //… the list continues};

回页首

预处理 C 文件

在 clang 中，至少可以使用两种方法创建一个预处理器对象：

• 直接实例化一个 Preprocessor 对象
• 使用 CompilerInstance 类创建一个 Preprocessor 对象

让我们首先使用后一种方法。

使用 Helper 和实用工具类实现预处理功能

单独使用 Preprocessor 不会有太大的帮助：您需要 FileManager 和 SourceManager 类来读取文件并跟踪源位置，实现故障诊断。FileManager 类支持文件系统查找、文件系统缓存和目录搜索。查看 FileEntry 类，它为一个源文件定义了 clang 抽象。清单 6 提供了 FileManager.h 头文件的一个摘要。

清单 6. clang FileManager 类

class FileManager : public llvm::RefCountedBase<FileManager> {  FileSystemOptions FileSystemOpts;   /// \brief The virtual directories that we have allocated.  For each  /// virtual file (e.g. foo/bar/baz.cpp), we add all of its parent  /// directories (foo/ and foo/bar/) here.  SmallVector<DirectoryEntry*, 4> VirtualDirectoryEntries;  /// \brief The virtual files that we have allocated.  SmallVector<FileEntry*, 4> VirtualFileEntries; /// NextFileUID - Each FileEntry we create is assigned a unique ID #.  unsigned NextFileUID;  // Statistics.  unsigned NumDirLookups, NumFileLookups;  unsigned NumDirCacheMisses, NumFileCacheMisses; // …  // Caching.  OwningPtr<FileSystemStatCache> StatCache;

SourceManager 类通常用来查询 SourceLocation 对象。在 SourceManager.h 头文件中，清单 7 提供了有关 SourceLocation 对象的信息。

清单 7. 理解 SourceLocation

/// There are three different types of locations in a file: a spelling/// location, an expansion location, and a presumed location.////// Given an example of:/// #define min(x, y) x < y ? x : y////// and then later on a use of min:/// #line 17/// return min(a, b);////// The expansion location is the line in the source code where the macro/// was expanded (the return statement), the spelling location is the/// location in the source where the macro was originally defined,/// and the presumed location is where the line directive states that/// the line is 17, or any other line.

很明显，SourceManager 取决于底层的 FileManager；事实上，SourceManager 类构造函数接受一个 FileManager 类作为输入参数。最后，您需要跟踪处理源代码时可能出现的错误并进行报告。您可以使用 DiagnosticsEngine 类完成这项工作。和 Preprocessor 一样，您有两个选择：

• 独立创建所有必需的对象
• 使用 CompilerInstance 完成所有工作

让我们使用后一种方法。清单 8 显示了 Preprocessor 的代码；其他任何事情之前已经解释过了。

清单 8. 使用 clang API 创建一个预处理器

using namespace clang;int main(){    CompilerInstance ci;    ci.createDiagnostics(0,NULL); // create DiagnosticsEngine    ci.createFileManager();  // create FileManager    ci.createSourceManager(ci.getFileManager()); // create SourceManager    ci.createPreprocessor();  // create Preprocessor    const FileEntry *pFile = ci.getFileManager().getFile("hello.c");    ci.getSourceManager().createMainFileID(pFile);    ci.getPreprocessor().EnterMainSourceFile();    ci.getDiagnosticClient().BeginSourceFile(ci.getLangOpts(), &ci.getPreprocessor());    Token tok;    do {        ci.getPreprocessor().Lex(tok);        if( ci.getDiagnostics().hasErrorOccurred())            break;        ci.getPreprocessor().DumpToken(tok);        std::cerr << std::endl;    } while ( tok.isNot(clang::tok::eof));    ci.getDiagnosticClient().EndSourceFile();}

清单 8 使用 CompilerInstance 类依次创建 DiagnosticsEngine（ci.createDiagnostics 方法调用）和FileManager（ci.createFileManager 和 ci.CreateSourceManager）。使用 FileEntry 完成文件关联后，继续处理源文件中的每个令牌，直到达到文件的末尾 (EOF)。预处理器的 DumpToken 方法将把令牌转储到屏幕中。

要编译并运行 清单 8 中的代码，使用 清单 9 中的 makefile（针对您的 clang 和 LLVM 安装文件夹进行了相应调整）。主要想法是使用 llvm-config 工具提供任何必需的 LLVM（包含路径和库）：您永远不应尝试将这些链接传递到 g++ 命令行。

清单 9. 用于构建预处理器代码的 Makefile

CXX := g++RTTIFLAG := -fno-rttiCXXFLAGS := $(shell llvm-config --cxxflags) $(RTTIFLAG)LLVMLDFLAGS := $(shell llvm-config --ldflags --libs)DDD := $(shell echo $(LLVMLDFLAGS))SOURCES = main.cppOBJECTS = $(SOURCES:.cpp=.o)EXES = $(OBJECTS:.o=)CLANGLIBS = \    -L /usr/local/lib \    -lclangFrontend \    -lclangParse \    -lclangSema \    -lclangAnalysis \    -lclangAST \    -lclangLex \    -lclangBasic \    -lclangDriver \    -lclangSerialization \    -lLLVMMC \    -lLLVMSupport \all: $(OBJECTS) $(EXES)%: %.o        $(CXX) -o $@ $< $(CLANGLIBS) $(LLVMLDFLAGS)

编译并运行以上代码后，您应当获得 清单 10 中的输出。

清单 10. 运行清单 7 中的代码时发生崩溃

Assertion failed: (Target && "Compiler instance has no target!"),    function getTarget, file    /Users/Arpan/llvm/tools/clang/lib/Frontend/../..   /include/clang/Frontend/CompilerInstance.h,   line 294.Abort trap: 6

在这里，您遗漏了 CompilerInstance 设置的最后一部分：即编译代码所针对的目标平台。这里是 TargetInfo 和 TargetOptions 类发挥作用的地方。根据 clang 标头 TargetInfo.h，TargetInfo 类存储有关代码生成的目标系统的所需信息，并且必须在编译或预处理之前创建。和预期的一样，TargetInfo 包含有关整数和浮动宽度、对齐等信息。清单 11 提供了 TargetInfo.h 头文件的摘要。

清单 11. Clang TargetInfo 类

class TargetInfo : public llvm::RefCountedBase<TargetInfo> {  llvm::Triple Triple;protected:  bool BigEndian;  unsigned char PointerWidth, PointerAlign;  unsigned char IntWidth, IntAlign;  unsigned char HalfWidth, HalfAlign;  unsigned char FloatWidth, FloatAlign;  unsigned char DoubleWidth, DoubleAlign;  unsigned char LongDoubleWidth, LongDoubleAlign;  // …

TargetInfo 类使用两个参数实现初始化：DiagnosticsEngine 和 TargetOptions。在这两个参数中，对于当前平台，后者必须将 Triple 字符串设置为相应的值。LLVM 此时将发挥作用。清单 12 显示了对 清单 9 所附加的可以使预处理器工作的内容。

清单 12. 为编译器设置目标选项

int main(){    CompilerInstance ci;    ci.createDiagnostics(0,NULL);    // create TargetOptions    TargetOptions to;    to.Triple = llvm::sys::getDefaultTargetTriple();    // create TargetInfo    TargetInfo *pti = TargetInfo::CreateTargetInfo(ci.getDiagnostics(), to);    ci.setTarget(pti);    // rest of the code same as in Listing 9…    ci.createFileManager();    // …

就这么简单。运行代码并观察简单的 hello.c 测试的输出：

#include <stdio.h>int main() {  printf("hello world!\n"); }

清单 13 展示了部分预处理器输出。

清单 13. 预处理器输出（部分）

typedef 'typedef'struct 'struct'identifier '__va_list_tag'l_brace '{'unsigned 'unsigned'identifier 'gp_offset'semi ';'unsigned 'unsigned'identifier 'fp_offset'semi ';'void 'void'star '*'identifier 'overflow_arg_area'semi ';'void 'void'star '*'identifier 'reg_save_area'semi ';'r_brace '}'identifier '__va_list_tag'semi ';'identifier '__va_list_tag'identifier '__builtin_va_list'l_square '['numeric_constant '1'r_square ']'semi ';'

手动创建一个 Preprocessor 对象

clang 库的其中一个优点，就是您可以通过多种方法实现相同的效果。在本节中，您将创建一个 Preprocessor 对象，但是不需要直接向CompilerInstance 发出请求。从 Preprocessor.h 头文件中，清单 14 显示了 Preprocessor 的构造函数。

清单 14. 构造一个 Preprocessor 对象

Preprocessor(DiagnosticsEngine &diags, LangOptions &opts,               const TargetInfo *target,               SourceManager &SM, HeaderSearch &Headers,               ModuleLoader &TheModuleLoader,               IdentifierInfoLookup *IILookup = 0,               bool OwnsHeaderSearch = false,               bool DelayInitialization = false);

查看该构造函数，显然，要想让这个预处理器工作，您还需要创建 6 个不同的对象。您已经了解了 DiagnosticsEngine、TargetInfo 和SourceManager。CompilerInstance 派生自 ModuleLoader。因此您必须创建两个新的对象，一个用于 LangOptions，另一个用于HeaderSearch。LangOptions 类使您编译一组 C/C++ 方言，包括 C99、C11 和 C++0x。参考 LangOptions.h 和 LangOptions.def 标头，获取更多信息。最后，HeaderSearch 类存储目录的 std::vector，用于在其他对象中搜索功能。清单 15 显示了 Preprocessor 的代码。

清单 15. 手动创建的预处理器

using namespace clang;int main()  {    DiagnosticOptions diagnosticOptions;    TextDiagnosticPrinter *printer =       new TextDiagnosticPrinter(llvm::outs(), diagnosticOptions);    llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagIDs;    DiagnosticsEngine diagnostics(diagIDs, printer);    LangOptions langOpts;    clang::TargetOptions to;    to.Triple = llvm::sys::getDefaultTargetTriple();    TargetInfo *pti = TargetInfo::CreateTargetInfo(diagnostics, to);    FileSystemOptions fsopts;    FileManager fileManager(fsopts);    SourceManager sourceManager(diagnostics, fileManager);    HeaderSearch headerSearch(fileManager, diagnostics, langOpts, pti);    CompilerInstance ci;    Preprocessor preprocessor(diagnostics, langOpts, pti,      sourceManager, headerSearch, ci);    const FileEntry *pFile = fileManager.getFile("test.c");    sourceManager.createMainFileID(pFile);    preprocessor.EnterMainSourceFile();    printer->BeginSourceFile(langOpts, &preprocessor);    // … similar to Listing 8 here on}

对于 清单 15 中的代码，需要注意以下几点：

• 您没有初始化 HeaderSearch 并使它指向任何特定的目录。但是您应当这样做。
• clang API 要求在堆 (heap) 上分配 TextDiagnosticPrinter。在栈 (stack) 上分配会引起崩溃。
• 您还不能处理掉 CompilerInstance。总之是因为您正在使用 CompilerInstance，那么为什么还要费心去手动创建它而不是更舒适地使用 clang API 呢？

语言选择：C++

您目前为止一直使用的是 C 测试代码：那么使用一些 C++ 代码如何？向 清单 15 中的代码添加 langOpts.CPlusPlus = 1;，然后尝试使用 清单 16 中的测试代码。

清单 16. 对预处理器使用 C++ 测试代码

template <typename T, int n>struct s {   T array[n];};int main() {  s<int, 20> var;}

清单 17 展示了程序的部分输出。

清单 17. 清单 16 中代码的部分预处理器输出

identifier 'template'less '<'identifier 'typename'identifier 'T'comma ','int 'int'identifier 'n'greater '>'struct 'struct'identifier 's'l_brace '{'identifier 'T'identifier 'array'l_square '['identifier 'n'r_square ']'semi ';'r_brace '}'semi ';'int 'int'identifier 'main'l_paren '('r_paren ')'

回页首

创建一个解析树

clang/Parse/ParseAST.h 中定义的 ParseAST 方法是 clang 提供的重要方法之一。以下是从 ParseAST.h 复制的一个例程声明：

void ParseAST(Preprocessor &pp, ASTConsumer *C,       ASTContext &Ctx, bool PrintStats = false,       TranslationUnitKind TUKind = TU_Complete,       CodeCompleteConsumer *CompletionConsumer = 0);

ASTConsumer 为您提供了一个抽象接口，可以从该接口进行派生。这样做非常合适，因为不同的客户端很可能通过不同的方式转储或处理 AST。您的客户端代码将派生自 ASTConsumer。ASTContext 类存储有关类型声明的信息和其他信息。最简单的尝试就是使用 clang ASTConsumer API 在您的代码中输出一个全局变量列表。许多技术公司就全局变量在 C++ 代码中的使用有非常严格的要求，这应当作为创建定制 lint 工具的出发点。清单 18 中提供了定制 consumer 的代码。

清单 18. 定制 AST consumer 类

class CustomASTConsumer : public ASTConsumer {public: CustomASTConsumer () :  ASTConsumer() { }    virtual ~ CustomASTConsumer () { }    virtual bool HandleTopLevelDecl(DeclGroupRef decls)    {        clang::DeclGroupRef::iterator it;        for( it = decls.begin(); it != decls.end(); it++)        {            clang::VarDecl *vd = llvm::dyn_cast<clang::VarDecl>(*it);            if(vd)               std::cout << vd->getDeclName().getAsString() << std::endl;;        }        return true;    }};

您将使用自己的版本覆盖 HandleTopLevelDecl 方法（最初在 ASTConsumer 中提供）。Clang 将全局变量列表传递给您；您对该列表进行迭代并输出变量名称。清单 19 摘录自 ASTConsumer.h，显示了客户端 consumer 代码可以覆盖的一些其他方法。

清单 19. 其他一些可以在客户端代码中覆盖的方法

/// HandleInterestingDecl - Handle the specified interesting declaration. This/// is called by the AST reader when deserializing things that might interest/// the consumer. The default implementation forwards to HandleTopLevelDecl.virtual void HandleInterestingDecl(DeclGroupRef D);/// HandleTranslationUnit - This method is called when the ASTs for entire/// translation unit have been parsed.virtual void HandleTranslationUnit(ASTContext &Ctx) {}/// HandleTagDeclDefinition - This callback is invoked each time a TagDecl/// (e.g. struct, union, enum, class) is completed.  This allows the client to/// hack on the type, which can occur at any point in the file (because these/// can be defined in declspecs).virtual void HandleTagDeclDefinition(TagDecl *D) {}/// Note that at this point it does not have a body, its body is  /// instantiated at the end of the translation unit and passed to  /// HandleTopLevelDecl.  virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) {}

最后，清单 20 显示了您开发的定制 AST consumer 类的实际客户端代码。

清单 20. 使用定制 AST consumer 的客户端代码

int main() {     CompilerInstance ci;    ci.createDiagnostics(0,NULL);    TargetOptions to;    to.Triple = llvm::sys::getDefaultTargetTriple();    TargetInfo *tin = TargetInfo::CreateTargetInfo(ci.getDiagnostics(), to);    ci.setTarget(tin);    ci.createFileManager();    ci.createSourceManager(ci.getFileManager());    ci.createPreprocessor();    ci.createASTContext();    CustomASTConsumer *astConsumer = new CustomASTConsumer ();    ci.setASTConsumer(astConsumer);    const FileEntry *file = ci.getFileManager().getFile("hello.c");    ci.getSourceManager().createMainFileID(file);    ci.getDiagnosticClient().BeginSourceFile(       ci.getLangOpts(), &ci.getPreprocessor());    clang::ParseAST(ci.getPreprocessor(), astConsumer, ci.getASTContext());    ci.getDiagnosticClient().EndSourceFile();    return 0;}

回页首

结束语

本系列的其他文章

查看 使用 LLVM 框架创建有效的编译器 系列中的其他文章。

这篇两部分的系列文章涵盖了大量内容：它探讨了 LLVM IR，提供了通过手动创建和 LLVM API 生成 IR 的方法，展示了如何为 LLVM 后端创建一个定制插件，以及解释了 LLVM 前端及其丰富的标头集。您还了解了如何使用该前端进行预处理和使用 AST。在计算史上，创建一个编译器并进行扩展，特别是针对 C++ 等复杂的语言，看上去是个非常复杂的过程，但是有了 LLVM，一切都变得非常简单。文档工作是 LLVM 和 clang 需要继续加强的部分，但是在此之前，我建议尝试 VIM/doxygen 来浏览这些标头。祝您使用愉快！

参考资料

学习

• 在 使用 LLVM 框架创建一个工作编译器，第 1 部分（Arpan Sen，developerWorks，2012 年 6 月）中了解 LLVM 的基础知识。使用功能强大的 LLVM 编译器基础架构优化用任何语言编写的应用程序。构建一个定制编译器现在变得非常简单！
• 了解有关 LLVM 阶段 的更多信息。
• 获取 clang 开发人员邮件列表。
• 阅读 Getting Started: Building and Running Clang，获取有关构建和安装 clang 的详细信息。
• 参加 官方 LLVM 教程，获取有关 LLVM 的出色介绍。
• 深入钻研 LLVM Programmer's Manual，这是了解 LLVM API 的必不可少的资源。
• 在 developerWorks 中国网站 Linux 技术专区，查找数百篇 how-to 文章和教程，以及下载、讨论论坛和面向 Linux 开发人员和管理员的其他丰富资源。
• developerWorks 中国网站 Web 开发专区 提供了涵盖各种基于 Web 的解决方案的文章。
• 查看 developerWorks 演示中心，包括面向初学者的产品安装和设置演示，以及为经验丰富的开发人员提供的高级功能。
• 在 Twitter 上关注 developerWorks。
• 随时关注 developerWorks 技术活动和网络广播。
• 访问 developerWorks Open source 专区获得丰富的 how-to 信息、工具和项目更新以及最受欢迎的文章和教程，帮助您用开放源码技术进行开发，并将它们与 IBM 产品结合使用。

获得产品和技术

• 访问 LLVM 项目站点 并下载 最新版本。
• 从 LLVM 站点查找有关 clang 的详细信息。
• IBM 产品评估试用版软件：下载产品试用版，在线试用产品，在云环境中使用产品，或在IBM SOA 人员沙箱 中花几个小时了解如何高效实现面向服务的架构。