LLVM VS GCC

最新推荐文章于 2024-04-24 15:53:34 发布

颇锐克

最新推荐文章于 2024-04-24 15:53:34 发布

阅读量7.4k

点赞数 6

常用开发工具同时被 2 个专栏收录

64 篇文章 1 订阅

订阅专栏

C/C++

27 篇文章 0 订阅

订阅专栏

1.1 LLVM是什么

LLVM是什么？这是一个虽然基础，但是也曾经让很多新入门的人迷惑的一个问题。从字面上来讲，LLVM(Low Level Virtual Machine)是一个底层虚拟机，LLVM曾经有一部分功能对虚拟机有所帮助。但是现在，LLVM所代表的基本和虚拟机没有关系了，也不在作为一个缩写使用了，而是直接作为一个名字使用。那么LLVM到底是什么？
LLVM可以被看作是一系列的编译器和工具链技术的集合，而且它们是模块化并且是可重用的。这是LLVM官方的解释。原话是：The LLVM Project is a collection of modular and reusable compiler and toolchain technologies.【1】官方定义永远是准确的精炼的，那么作为刚刚接触LLVM的初学者，对LLVM的理解是什么呢？

LLVM是一个编译器；
LLVM是一个编译器框架；
LLVM是一系列的编译器工具；
LLVM是一个编译器工具链；
LLVM是一个C++实现的开源软件；

这几种对LLVM的理解都对，但是也都是LLVM的一个方面，综合起来就是一个完整的LLVM。所以，从狭义上来说，可以简单的把LLVM理解为一个编译器，但是也必须知道，这个编译器可不仅仅是个编译器，它包含了编译相关的各种工具链，并且有一些相对独立的工具，而且它还是开源的。关键一点不要再搞混了，LLVM是搞编译的，跟虚拟机已经完全没关系了。
每个人对同一个事务的理解都不会完全相同，即使是在技术领域也一样。所以，只要保证对事务理解不出现片面化错误化，使用自己的理解去思考一个事务，要比牢记住官方的定义要好的多，虽然后者往往更加的精确和简约。这是贯彻本书所建议的一个思考方式，只有这样，才能将知识和技术转化为自己的。

1.2 LLVM的发展

LLVM起源于2000年伊利诺伊大学厄巴纳-香槟分校维克拉姆•艾夫（Vikram Adve）与克里斯•拉特纳（Chris Lattner）的研究发展而成，他们想要为所有静态及动态语言创造出动态的编译技术【2】。
LLVM从创立至今，已经走过了十几个年头。在这十几个年头里，它的发展是有目共睹的，它的成绩也是令人值得骄傲的。
2005年，苹果公司雇用了克里斯•拉特纳（Chris Lattner）及他的团队，为了苹果电脑开发应用程序系统，LLVM为现今Mac OS X及iOS开发工具的一部分【2】。同时，LLVM现在也是Google的Android系统中的一部分，特别是在Android系统选着使用了新的运行时ART(Android Runtime)之后，LLVM在Android系统中的比重就得到了更大的提升。
作为开源领域第二大的编译器，甚至在某些方面专门为了替代GCC而实现的LLVM来说，近些年它已经在不断的接近甚至准备超越GCC了。但从性能来说，根据2011年的测试，运行时期的性能，平均GCC比LLVM高出10%的性能；2013年的测试结果，LLVM可以编译出接近与GCC接近相同性能的运行码【2】。

最近在Mac OS X Mountain Lion下用Xcode进行开发，发现在编译选项里有如下所示的这两种编译器：一个是Apple LLVM compiler 4.2，另外一个是LLVM GCC 4.2。

近几年一直听人说LLVM比GCC好，但是我一直没有时间研究这二者的差别。由此问题出发，我又给自己抛出了很多疑问：

cc, c89, c99是什么？有何区别？
gcc, g++, cpp, gpp又是什么？
LLVM与GCC区别大吗？
Apple LLVM compiler 4.2和LLVM GCC 4.2有何区别？
LLVM GCC 4.2到底是LLVM还是GCC？

接下来让我们一起补补历史课。

CC, C89, C99

Unix诞生之后，很多公司都开发了自己的Unix系统并且使用了自己专门的编译器。这样就导致在不同的Unix系统上，想编译C语言代码就需要使用不同的命令。于是POSIX标准Commands and Utilities中就规定了将CC作为不同编译器的统一命令接口，并且也规定了CC命令需要提供哪些必须的参数。

随着后续ISO C标准的确定，POSIX标准又规定分别将C89、C99作为ISO C的接口，而CC则继续作为非标准C的接口。但实际上后续大多数C语言编译器都实现了ISO C标准，所以POSIX标准规定后续应将CC这一历史遗留的命令取消。

GCC, G++, CPP, GPP

随着开源运动的兴起，自由软件基金会开发了自己的开源免费的C语言编译器GNU C Compiler，简称GCC。GCC中提供了C Preprocessor这个C语言的预处理器，简称CPP。后来GCC又加入了对C++等其它语言的支持，所以他的名字也改为GNU Compiler Collection。G++则是专门用来处理C++语言的。在GNU的官方手册中，有一个章节叫做G++ and GCC介绍了这二者的区别。G++是GCC编译器集合的一个前端。关于前端、后端的概念下面有更详细的介绍。而GPP呢，这个名字比较特殊，如果你用的是Linux系统，可能并没有这个命令。但是在某些特殊的系统下，例如DOS，是无法创建G++这样带有特殊符号的文件名的。所以按照DJGPP编译器的做法，GPP其实就是G++。

LLVM与GCC

回顾GCC的历史，虽然它取得了巨大的成功，但开发GCC的初衷是提供一款免费的开源的编译器，仅此而已。可后来随着GCC支持了越来越多的语言，GCC架构的问题也逐渐暴露出来。但GCC到底有什么问题呢？我们一起看看这篇文章：The Architecture of Open Source Applications: LLVM。LLVM的优点也正是GCC的缺点。

传统编译器

传统编译器的工作原理基本上都是三段式的，可以分为前端（Frontend）、优化器（Optimizer）、后端（Backend）。前端负责解析源代码，检查语法错误，并将其翻译为抽象的语法树（Abstract Syntax Tree）。优化器对这一中间代码进行优化，试图使代码更高效。后端则负责将优化器优化后的中间代码转换为目标机器的代码，这一过程后端会最大化的利用目标机器的特殊指令，以提高代码的性能。

事实上，不光静态语言如此，动态语言也符合上面这个模型，例如Java。Java Virtual Machine也利用上面这个模型，将Java代码翻译为Java bytecode。

这一模型的好处是，当我们要支持多种语言时，只需要添加多个前端就可以了。当需要支持多种目标机器时，只需要添加多个后端就可以了。对于中间的优化器，我们可以使用通用的中间代码。

这种三段式的结构还有一个好处，开发前端的人只需要知道如何将源代码转换为优化器能够理解的中间代码就可以了，他不需要知道优化器的工作原理，也不需要了解目标机器的知识。这大大降低了编译器的开发难度，使更多的开发人员可以参与进来。

虽然这种三段式的编译器有很多有点，并且被写到了教科书上，但是在实际中这一结构却从来没有被完美实现过。做的比较好的应该属Java和.NET虚拟机。虚拟机可以将目标语言翻译为bytecode，所以理论上讲我们可以将任何语言翻译为bytecode，然后输入虚拟机中运行。但是这一动态语言的模型并不太适合C语言，所以硬将C语言翻译为bytecode并实现垃圾回收机制的效率是非常低的。

GCC也将三段式做的比较好，并且实现了很多前端，支持了很多语言。但是上述这些编译器的致命缺陷是，他们是一个完整的可执行文件，没有给其它语言的开发者提供代码重用的接口。即使GCC是开源的，但是源代码重用的难度也比较大。

LLVM

LLVM最初是Low Level Virtual Machine的缩写，定位是一个虚拟机，但是是比较底层的虚拟机。它的出现正是为了解决编译器代码重用的问题，LLVM一上来就站在比较高的角度，制定了LLVM IR这一中间代码表示语言。LLVM IR充分考虑了各种应用场景，例如在IDE中调用LLVM进行实时的代码语法检查，对静态语言、动态语言的编译、优化等。

从上面这个图中我们发现LLVM与GCC在三段式架构上并没有本质区别。LLVM与其它编译器最大的差别是，它不仅仅是Compiler Collection，也是Libraries Collection。举个例子，假如说我要写一个XYZ语言的优化器，我自己实现了PassXYZ算法，用以处理XYZ语言与其它语言差别最大的地方。而LLVM优化器提供的PassA和PassB算法则提供了XYZ语言与其它语言共性的优化算法。那么我可以选择XYZ优化器在链接的时候把LLVM提供的算法链接进来。LLVM不仅仅是编译器，也是一个SDK。

Apple LLVM compiler 4.2和LLVM GCC 4.2

现在我们可以回答本文最前面我遇到的那个问题了。Apple LLVM compiler 4.2是一个真正的LLVM编译器，前端使用的是Clang，基于最新的LLVM 3.2编译的。LLVM GCC 4.2编译器的核心仍然是LLVM，但是前端使用的是GCC 4.2编译器。从LLVM的下载页面可以看出，LLVM从1.0到2.5使用的都是GCC作为前端，直到2.6开始才提供了Clang前端。

LLVM（之前称为低级虚拟机）是一种非常强大的编译器基础架构框架，专门为使用您喜爱的编程语言编写的程序的编译时、链接时和运行时优化而设计。LLVM 可运行于若干个不同的平台之上，它以能够生成快速运行的代码而著称。

LLVM 框架是围绕着代码编写良好的中间表示 (IR) 而构建的。本文（由两部分组成的系列文章的第一部分）将深入讲解 LLVM IR 的基础知识以及它的一些微妙之处。在这里，您将构建一个可以自动为您生成 LLVM IR 的代码生成器。拥有一个 LLVM IR 生成器意味着您所需要的是一个前端以供插入您所喜爱的编程语言，而且这还意味着您拥有一个完整的流程（前端解析器 + IR 生成器 + LLVM 后端）。创建一个自定义编译器会变得更加简单。

开始使用 LLVM

在开始之前，在您的开发计算器上必须已经拥有已编译好的 LLVM（参阅参考资料获取相关链接）。本文中的示例均基于 LLVM V3.0。对于 LLVM 代码的后期生成和安装，最重要的两个工具是 llc 和 lli。

llc 和 lli

因为 LLVM 是一个虚拟机，所以它可能应该拥有自己的中间字节代码表示，不是吗？最后，您需要将 LLVM 字节代码编译到特定于平台的汇编语言中。然后您才能通过本机汇编程序和链接器来运行汇编代码，从而生成可执行的共享库等。您可以使用 llc 将 LLVM 字节代码转换成特定于平台的汇编代码（请参阅参考资料，获取关于此工具的更多信息的链接）。对于 LLVM 字节代码的直接执行部分，不要等到在本机执行代码崩溃后才发现您的程序中有一个或两个 bug。这正是 lli 的用武之地，因为它可以直接执行字节代码。lli 可以通过解释器或使用高级选项中的即时 (JIT) 编译器执行此工作。请参阅参考资料，获取关于 lli 的更多信息的链接。

llvm-gcc

llvm-gcc 是 GNU Compiler Collection (gcc) 的修改版本，可以在使用 -S -emit-llvm 选项运行时会生成 LLVM 字节代码。然后您可以使用 lli 来执行这个已生成的字节代码（也称为 LLVM 汇编语言）。有关 llvm-gcc 的更多信息，请参阅参考资料。如果您没有在自己的系统中预先安装 llvm-gcc，那么您应该能够从源代码构建它，请参阅参考资料，获取分步指南的链接。

回页首

使用 LLVM 编写 Hello World

要更好地理解 LLVM，您必须了解 LLVM IR 及其微妙之处。这个过程类似于学习另一种编程语言。但是，如果您熟悉 C 语言和 C++ 语言以及它们的一些语法怪现象，那么在了解 LLVM IR 方面您应该没有太大的障碍。清单 1 给出了您的第一个程序，该程序将在控制台输出中打印 "Hello World"。要编译此代码，您可以使用 llvm-gcc。

清单 1. 看起来非常熟悉的 Hello World 程序

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

要编译此代码，请输入此命令：

Tintin.local# llvm-gcc helloworld.cpp -S -emit-llvm

完成编译后，llvm-gcc 会生成 helloworld.s 文件，您可以使用 lli 来执行该文件，将消息输出到控制台。lli 的用法如下：

Tintin.local# lli helloworld.s
Hello, World

现在，先看一下 LLVM 汇编语言。清单 2 给出了该代码。

清单 2. Hello World 程序的 LLVM 字节代码

@.str = private constant [13 x i8] c"Hello World!\00", align 1 ;

define i32 @main() ssp {
entry:
  %retval = alloca i32
  %0 = alloca i32
  %"alloca point" = bitcast i32 0 to i32
  %1 = call i32 @puts(i8* getelementptr inbounds ([13 x i8]* @.str, i64 0, i64 0))
  store i32 0, i32* %0, align 4
  %2 = load i32* %0, align 4
  store i32 %2, i32* %retval, align 4
  br label %return
return:
  %retval1 = load i32* %retval
  ret i32 %retval1
}

declare i32 @puts(i8*)

回页首

理解 LLVM IR

LLVM 提供了一个详细的汇编语言表示（参阅参考资料获取相关的链接）。在开始编写我们之前讨论的自己的 Hello World 程序版本之前，有几个需知事项：

LLVM 汇编语言中的注解以分号 (;) 开始，并持续到行末。
全局标识符要以 @ 字符开始。所有的函数名和全局变量都必须以 @ 开始。
LLVM 中的局部标识符以百分号 (%) 开始。标识符典型的正则表达式是 [%@][a-zA-Z$._][a-zA-Z$._0-9]*。
LLVM 拥有一个强大的类型系统，这也是它的一大特性。LLVM 将整数类型定义为 iN，其中 N 是整数占用的字节数。您可以指定 1 到 223- 1 之间的任意位宽度。
您可以将矢量或阵列类型声明为 [no. of elements X size of each element]。对于字符串 "Hello World!"，可以使用类型 [13 x i8]，假设每个字符占用 1 个字节，再加上为 NULL 字符提供的 1 个额外字节。
您可以对 hello-world 字符串的全局字符串常量进行如下声明：@hello = constant [13 x i8] c"Hello World!\00"。使用关键字 constant 来声明后面紧跟类型和值的常量。我们已经讨论过类型，所以现在让我们来看一下值：您以 c 开始，后面紧跟放在双引号中的整个字符串（其中包括 \0 并以 0 结尾）。不幸的是，关于字符串的声明为什么需要使用 c 前缀，并在结尾处包含 NULL 字符和 0，LLVM 文档未提供任何解释。如果您有兴趣研究更多有关 LLVM 的语法怪现象，请参阅参考资料，获取语法文件的链接。
LLVM 允许您声明和定义函数。而不是仔细查看 LLVM 函数的整个特性列表，我只需将精力集中在基本要点上即可。以关键字 define 开始，后面紧跟返回类型，然后是函数名。返回 32 字节整数的 main 的简单定义类似于：define i32 @main() { ; some LLVM assembly code that returns i32 }。
函数声明，顾名思义，有着重大的意义。这里提供了 puts 方法的最简单声明，它是 printf: declare i32 puts(i8*) 的 LLVM 等同物。该声明以关键字 declare 开始，后面紧跟着返回类型、函数名，以及该函数的可选参数列表。该声明必须是全局范围的。
每个函数均以返回语句结尾。有两种形式的返回语句：ret <type> <value> 或 ret void。对于您简单的主例程，使用 ret i32 0 就足够了。
使用 call <function return type> <function name> <optional function arguments> 来调用函数。注意，每个函数参数都必须放在其类型的前面。返回一个 6 位的整数并接受一个 36 位的整数的函数测试的语法如下：call i6 @test( i36 %arg1 )。

这只是一个开始。您还需要定义一个主例程、一个存储字符串的常量，以及处理实际打印的 puts 方法的声明。清单 3 显示第一次尝试创建的程序。

清单 3. 第一次尝试创建手动编写的 Hello World 程序

declare  i32 @puts(i8*) 
@global_str = constant [13 x i8] c"Hello World!\00"
define i32 @main { 
  call i32 @puts( [13 x i8] @global_str )
  ret i32 0 
}

这里提供了来自 lli 的日志：

lli: test.s:5:29: error: global variable reference must have pointer type
  call i32 @puts( [13 x i8] @global_str )
                            ^

程序并未按预期的运行。发生了什么？如之前所提及的，LLVM 拥有一个强大的类型系统。因为 puts 期望提供一个指向 i8 的指针，并且您能传递一个 i8 矢量，这样 lli 才能快速指出错误。该问题的常用解决方法（来自 C 编程背景）是使用类型转换。这将您引向了 LLVM 指令 getelementptr。请注意，您必须将清单 3 中的 puts 调用修改为与 call i32 @puts(i8* %t) 类似，其中 %t 是类型 i8*，并且是 [13 x i8] to i8* 的类型转换结果。（请参阅参考资料，获取 getelementptr 的详细描述的链接。）在进一步探讨之前，清单 4 提供了可行的代码。

清单 4. 使用 getelementptr 正确地将类型转换为指针

declare i32 @puts (i8*)
@global_str = constant [13 x i8] c"Hello World!\00"

define i32 @main() {
  %temp = getelementptr [13 x i8]*  @global_str, i64 0, i64 0
  call i32 @puts(i8* %temp)
  ret i32 0
}

getelementptr 的第一个参数是全局字符串变量的指针。要单步执行全局变量的指针，则需要使用第一个索引，即 i64 0。因为 getelementptr 指令的第一个参数必须始终是 pointer 类型的值，所以第一个索引会单步调试该指针。0 值表示从该指针起偏移 0 元素偏移量。我的开发计算机运行的是 64 位 Linux®，所以该指针是 8 字节。第二个索引 (i64 0) 用于选择字符串的第 0 个元素，该元素是作为 puts 的参数来提供的。

回页首

创建一个自定义的 LLVM IR 代码生成器

了解 LLVM IR 是件好事，但是您需要一个自动化的代码生成系统，用它来转储 LLVM 汇编语言。谢天谢地，LLVM 提供了强大的应用程序编程接口 (API) 支持，让您可以查看整个过程（请参阅参考资料，获取程序员手册的链接）。在您的开发计算机上查找 LLVMContext.h 文件；如果该文件缺失，那么可能是您安装 LLVM 的方式出错。

现在，让我们创建一个程序，为之前讨论的 Hello World 程序生成 LLVM IR。该程序不会处理这里的整个 LLVM API，但是接下来的代码样例会证明，适量位数的 LLVM API 很直观而且易于使用。

针对 LLVM 代码的链接

LLVM 提供了一款出色的工具，叫做 llvm-config（参阅参考资料）。运行 llvm-config –cxxflags，获取需要传递至 g++ 的编译标志、链接器选项的 llvm-config –ldflags 以及 llvm-config –ldflags，以便针对正确的 LLVM 库进行链接。在清单 5 的样例中，所有的选项均需要传递至 g++。

清单 5. 通过 LLVM API 使用 llvm-config 构建代码

tintin# llvm-config --cxxflags --ldflags --libs \
-I/usr/include  -DNDEBUG -D_GNU_SOURCE \
-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS \
-D__STDC_LIMIT_MACROS -O3  -fno-exceptions -fno-rtti -fno-common \
-Woverloaded-virtual -Wcast-qual \
-L/usr/lib  -lpthread -lm \
-lLLVMXCoreCodeGen -lLLVMTableGen -lLLVMSystemZCodeGen \
-lLLVMSparcCodeGen -lLLVMPTXCodeGen \
-lLLVMPowerPCCodeGen -lLLVMMSP430CodeGen -lLLVMMipsCodeGen \
-lLLVMMCJIT -lLLVMRuntimeDyld \
-lLLVMObject -lLLVMMCDisassembler -lLLVMXCoreDesc -lLLVMXCoreInfo \
-lLLVMSystemZDesc -lLLVMSystemZInfo \
-lLLVMSparcDesc -lLLVMSparcInfo -lLLVMPowerPCDesc -lLLVMPowerPCInfo \
-lLLVMPowerPCAsmPrinter \
-lLLVMPTXDesc -lLLVMPTXInfo -lLLVMPTXAsmPrinter -lLLVMMipsDesc \
-lLLVMMipsInfo -lLLVMMipsAsmPrinter \
-lLLVMMSP430Desc -lLLVMMSP430Info -lLLVMMSP430AsmPrinter \
-lLLVMMBlazeDisassembler -lLLVMMBlazeAsmParser \
-lLLVMMBlazeCodeGen -lLLVMMBlazeDesc -lLLVMMBlazeAsmPrinter \
-lLLVMMBlazeInfo -lLLVMLinker -lLLVMipo \
-lLLVMInterpreter -lLLVMInstrumentation -lLLVMJIT -lLLVMExecutionEngine \
-lLLVMDebugInfo -lLLVMCppBackend \
-lLLVMCppBackendInfo -lLLVMCellSPUCodeGen -lLLVMCellSPUDesc \
-lLLVMCellSPUInfo -lLLVMCBackend \
-lLLVMCBackendInfo -lLLVMBlackfinCodeGen -lLLVMBlackfinDesc \
-lLLVMBlackfinInfo -lLLVMBitWriter \
-lLLVMX86Disassembler -lLLVMX86AsmParser -lLLVMX86CodeGen \
-lLLVMX86Desc -lLLVMX86AsmPrinter -lLLVMX86Utils \
-lLLVMX86Info -lLLVMAsmParser -lLLVMARMDisassembler -lLLVMARMAsmParser \
-lLLVMARMCodeGen -lLLVMARMDesc \
-lLLVMARMAsmPrinter -lLLVMARMInfo -lLLVMArchive -lLLVMBitReader \
-lLLVMAlphaCodeGen -lLLVMSelectionDAG \
-lLLVMAsmPrinter -lLLVMMCParser -lLLVMCodeGen -lLLVMScalarOpts \
-lLLVMInstCombine -lLLVMTransformUtils \
-lLLVMipa -lLLVMAnalysis -lLLVMTarget -lLLVMCore -lLLVMAlphaDesc \
-lLLVMAlphaInfo -lLLVMMC -lLLVMSupport

LLVM 模块和上下文环境等

LLVM 模块类是其他所有 LLVM IR 对象的顶级容器。LLVM 模块类能够包含全局变量、函数、该模块所依赖的其他模块和符号表等对象的列表。这里将提供了 LLVM 模块的构造函数：

explicit Module(StringRef ModuleID, LLVMContext& C);

要构建您的程序，必须从创建 LLVM 模块开始。第一个参数是该模块的名称，可以是任何虚拟的字符串。第二个参数称为 LLVMContext。LLVMContext 类有些晦涩，但用户足以了解它提供了一个用来创建变量等对象的上下文环境。该类在多线程的上下文环境中变得非常重要，您可能想为每个线程创建一个本地上下文环境，并且想让每个线程完全独立于其他上下文环境运行。目前，使用这个默认的全局上下文来处理 LLVM 所提供的代码。这里给出了创建模块的代码：

llvm::LLVMContext& context = llvm::getGlobalContext();

llvm::Module* module = new llvm::Module("top", context);

您要了解的下一个重要类是能实际提供 API 来创建 LLVM 指令并将这些指令插入基础块的类：IRBuilder 类。IRBuilder 提供了许多华而不实的方法，但是我选择了最简单的可行方法来构建一个 LLVM 指令，即使用以下代码来传递全局上下文：

llvm::LLVMContext& context = llvm::getGlobalContext();

llvm::Module* module = new llvm::Module("top", context);

llvm::IRBuilder<> builder(context);

准备好 LLVM 对象模型后，就可以调用模块的 dump 方法来转储其内容。清单 6 给出了该代码。

清单 6. 创建一个转储模块

#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Support/IRBuilder.h"

int main()
{
  llvm::LLVMContext& context = llvm::getGlobalContext();
  llvm::Module* module = new llvm::Module("top", context);
  llvm::IRBuilder<> builder(context); 

  module->dump( );
}

运行清单 6 中的代码之后，控制台的输出如下：

; ModuleID = 'top'

然后，您需要创建 main 方法。LLVM 提供了 llvm::Function 类来创建一个函数，并提供了 llvm::FunctionType 将该函数与某个返回类型相关联。此外，请记住，main 方法必须是该模块的一部分。清单 7 给出了该代码。

清单 7. 将 main 方法添加至顶部模块

#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Support/IRBuilder.h"

int main()
{
  llvm::LLVMContext& context = llvm::getGlobalContext();
  llvm::Module *module = new llvm::Module("top", context);
  llvm::IRBuilder<> builder(context); 

  llvm::FunctionType *funcType = 
      llvm::FunctionType::get(builder.getInt32Ty(), false);
  llvm::Function *mainFunc = 
      llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "main", module);

  module->dump( );
}

请注意，您需要让 main 返回 void，这就是您调用 builder.getVoidTy() 的原因；如果 main 返回 i32，那么该调用会是 builder.getInt32Ty()。在编译并运行清单 7 中的代码后，出现的结果如下：

; ModuleID = 'top'
declare void @main()

您还尚未定义 main 要执行的指令集。为此，您必须定义一个基础块并将其与 main 方法关联。基础块 是 LLVM IR 中的一个指令集合，拥有将标签（类似于 C 标签）定义为其构造函数的一部分的选项。builder.setInsertPoint 会告知 LLVM 引擎接下来将指令插入何处。清单 8 给出了该代码。

清单 8. 向 main 添加一个基础块

#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Support/IRBuilder.h"

int main()
{
  llvm::LLVMContext& context = llvm::getGlobalContext();
  llvm::Module *module = new llvm::Module("top", context);
  llvm::IRBuilder<> builder(context); 

  llvm::FunctionType *funcType = 
      llvm::FunctionType::get(builder.getInt32Ty(), false);
  llvm::Function *mainFunc = 
      llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "main", module);

  llvm::BasicBlock *entry = llvm::BasicBlock::Create(context, "entrypoint", mainFunc);
  builder.SetInsertPoint(entry);

  module->dump( );
}

这里提供了清单 8 的输出。请注意，由于现在已经定义了 main 的基础块，所以 LLVM 转储将 main 看作为是一个方法定义，而不是一个声明。非常酷！

; ModuleID = 'top'
define void @main() { 
entrypoint: 
}

现在，向代码添加全局 hello-world 字符串。清单 9 给出了该代码。

清单 9. 向 LLVM 模块添加全局字符串

#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Support/IRBuilder.h"

int main()
{
  llvm::LLVMContext& context = llvm::getGlobalContext();
  llvm::Module *module = new llvm::Module("top", context);
  llvm::IRBuilder<> builder(context); 

  llvm::FunctionType *funcType = 
      llvm::FunctionType::get(builder.getVoidTy(), false);
  llvm::Function *mainFunc = 
      llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "main", module);

  llvm::BasicBlock *entry = llvm::BasicBlock::Create(context, "entrypoint", mainFunc);
  builder.SetInsertPoint(entry);

  llvm::Value *helloWorld = builder.CreateGlobalStringPtr("hello world!\n");

  module->dump( );
}

在清单 9 的输出中，注意 LLVM 引擎是如何转储字符串的：

; ModuleID = 'top'
@0 = internal unnamed_addr constant [14 x i8] c"hello world!\0A\00"
define void @main() {
entrypoint:
}

现在您需要做的就是声明 puts 方法，并且调用它。要声明 puts 方法，则必须创建合适的 FunctionType*。从您的 Hello World 源始代码中，您知道 puts 返回了 i32 并接受 i8* 作为输入参数。清单 10 给出了创建 puts 的正确类型的代码。

清单 10. 声明 puts 方法的代码

  std::vector<llvm::Type *> putsArgs;
  putsArgs.push_back(builder.getInt8Ty()->getPointerTo());
  llvm::ArrayRef<llvm::Type*>  argsRef(putsArgs);

  llvm::FunctionType *putsType = 
    llvm::FunctionType::get(builder.getInt32Ty(), argsRef, false);
  llvm::Constant *putsFunc = module->getOrInsertFunction("puts", putsType);

FunctionType::get 的第一个参数是返回类型；第二个参数是一个 LLVM::ArrayRef 结构，并且最后的 false 指明了后面未跟可变数量的参数。ArrayRef 结构与矢量相似，只是它不包含任何基础数据，并且主要用于包装诸如阵列和矢量等数据块。由于这个改变，输出显示将如清单 11 所示。

清单 11. 声明 puts 方法

; ModuleID = 'top'
@0 = internal unnamed_addr constant [14 x i8] c"hello world!\0A\00"
define void @main() {
entrypoint:
}
declare i32 @puts(i8*)

剩下要做的是调用 main 中的 puts 方法，并从 main 中返回。LLVM API 非常关注转换等操作：您需要做的是调用 puts 来调用 builder.CreateCall。最后，要创建返回语句，请调用 builder.CreateRetVoid。清单 12 提供了完整的运行代码。

清单 12. 输出 Hello World 的完整代码

#include "llvm/ADT/ArrayRef.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/Support/IRBuilder.h"
#include <vector>
#include <string>

int main()
{
  llvm::LLVMContext & context = llvm::getGlobalContext();
  llvm::Module *module = new llvm::Module("asdf", context);
  llvm::IRBuilder<> builder(context);

  llvm::FunctionType *funcType = llvm::FunctionType::get(builder.getVoidTy(), false);
  llvm::Function *mainFunc = 
    llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "main", module);
  llvm::BasicBlock *entry = llvm::BasicBlock::Create(context, "entrypoint", mainFunc);
  builder.SetInsertPoint(entry);

  llvm::Value *helloWorld = builder.CreateGlobalStringPtr("hello world!\n");

  std::vector<llvm::Type *> putsArgs;
  putsArgs.push_back(builder.getInt8Ty()->getPointerTo());
  llvm::ArrayRef<llvm::Type*>  argsRef(putsArgs);

  llvm::FunctionType *putsType = 
    llvm::FunctionType::get(builder.getInt32Ty(), argsRef, false);
  llvm::Constant *putsFunc = module->getOrInsertFunction("puts", putsType);

  builder.CreateCall(putsFunc, helloWorld);
  builder.CreateRetVoid();
  module->dump();
}

回页首

结束语

在这篇初步了解 LLVM 的文章中，了解了诸如 lli 和 llvm-config 等 LLVM 工具，还深入研究了 LLVM 中间代码，并使用 LLVM API 来为您自己生成中间代码。本系列的第二部分（也是最后一部分）将探讨可以使用 LLVM 完成的另一项任务，即毫不费力地添加额外的编译传递。

颇锐克

关注

6
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
LLVM VS GCC

1.1 LLVM是什么LLVM是什么？这是一个虽然基础，但是也曾经让很多新入门的人迷惑的一个问题。从字面上来讲，LLVM(Low Level Virtual Machine)是一个底层虚拟机，LLVM曾经有一部分功能对虚拟机有所帮助。但是现在，LLVM所代表的基本和虚拟机没有关系了，也不在作为一个缩写使用了，而是直接作为一个名字使用。那么LLVM到底是什么？LLVM可以被看作是一系列的
复制链接

扫一扫