In late 2000, Lattner joined the\u00a0University of Illinois at Urbana-Champaign\u00a0as a research assistant and M.Sc. student. While working with\u00a0Vikram Adve, he designed and began implementing LLVM, an innovative infrastructure for\u00a0optimizing compilers<\/strong>, which was the subject of his 2002 M.Sc. thesis. He completed his Ph.D. in 2005, researching new techniques for optimizing pointer-intensive programs and adding them to LLVM.<\/p>\n Here’s from\u00a0his thesis abstract the motivation behind the LLVM design:<\/p>\n Modern programming languages and software engineering principles are causing increasing problems for compiler systems. Traditional approaches, which use a simple compile-link-execute model, are unable to provide adequate application performance under the demands of the new conditions. Traditional approaches to interprocedural and profile-driven compilation can provide the application performance needed, but require infeasible amounts of compilation time to build the application.<\/em><\/p>\n This thesis presents LLVM, a design and implementation of a compiler infrastructure which supports a unique\u00a0multi-stage\u00a0optimization system. This system is designed to support extensive interprocedural and profile-driven <\/em>optimizations, while being efficient enough for use in commercial compiler systems.<\/em><\/p>\n The LLVM virtual instruction set is the glue that holds the system together. It is a low-level representation, but with\u00a0high-level type information. This provides the benefits of a low-level representation (compact representation, <\/em>wide variety of available transformations, etc.) as well as providing high-level information to support aggressive interprocedural optimizations at <\/em>link– and post-link time. In particular, this system is designed to support optimization in the field, both at run-time and during <\/em>otherwise unused idle time on the machine.<\/em><\/p>\n To resume the idea behind LLVM is to use the LLVM Intermediate Representation (IR), it\u2019s like the bytecode for java or IL for .net.<\/p>\n LLVM IR is designed to host mid-level analyses and transformations that you find in the optimizer section of a compiler. It was designed with many specific goals in mind, including supporting lightweight runtime optimizations, cross-function\/interprocedural optimizations, whole program analysis, and aggressive restructuring transformations, etc. The most important aspect of it, though, is that it is itself defined as a first class language with well-defined semantics.<\/p>\n Let’s consider a relatively straightforward function that takes three integer parameters and returns an arithmetic combination of them.<\/p>\n The LLVM IR for this function will look like:<\/p>\n Back to the goal of this thesis which focuses on the optimization. To explain this compiler phase I can\u2019t say better than Chris Lattner the father of LLVM in this\u00a0post<\/a>:<\/p>\n \u201cTo give some intuition for how optimizations work, it is useful to walk through some examples. There are lots of different kinds of compiler optimizations, so it is hard to provide a recipe for how to solve an arbitrary problem. That said, most optimizations follow a simple three-part structure:<\/em><\/p>\n The optimizer reads LLVM IR in, chews on it a bit, then emits LLVM IR, which hopefully will execute faster. In LLVM (as in many other compilers) the optimizer is organized as a pipeline of distinct optimization passes each of which is run on the input and has a chance to do something. Common examples of passes are the inliner (which substitutes the body of a function into call sites), expression reassociation, loop invariant code motion, etc. Depending on the optimization level, different passes are run: for example at -O0 (no optimization) the Clang compiler runs no passes, at -O3 it runs a series of 67 passes in its optimizer (as of LLVM 2.8). LLVM and Clang as infrastructure to build tools:<\/strong><\/p>\n A major design concept for Clang is its use of a library-based architecture. In this design, various parts of the front-end can be cleanly divided into separate libraries which can then be mixed up for different needs and uses. In addition, the library-based approach encourages good interfaces and makes it easier for new developers to get involved (because they only need to understand small pieces of the big picture).<\/p>\n The design of LLVM\/Clang makes it an infrastructure to build tools. Thanks to its\u00a0library-based architecture which makes the reuse and integration of\u00a0new features more flexible\u00a0and easier to integrate into other projects.<\/p>\n Many tools are based on LLVM and Clang, we can enumerate clang-tidy, clang-query,\u00a0CppDepend and more.<\/p>\n Clang always\u00a0 up to date with the new standards<\/strong><\/p>\n Clang is always compliant with any new standard. furthermore, it always provides an experimental support for the coming new features. The current version has\u00a0experimental\u00a0support for some proposed features of the C++ standard following C++17, provisionally named C++2a. Note that support for these features may change or be removed without notice, as the draft C++2a standard evolves.<\/p>\n You can use Clang in C++2a mode with the\u00a0int mul_add(int x, int y, int z) {\r\n return x * y + z;\r\n}\r\n<\/pre>\n<\/div>\ndefine i32 @mul_add(i32 %x, i32 %y, i32 %z) {\r\nentry:\r\n %tmp = mul i32 %x, %y\r\n %tmp2 = add i32 %tmp, %z\r\n ret i32 %tmp2\r\n}\r\n<\/pre>\n<\/div>\n\n
\n<\/em><\/p>\n![\"llvm1\"](\"http:\/\/www.javadepend.com\/Blog\/wp-content\/uploads\/llvm1.png\")
<\/p>\n-std=c++2a<\/code>\u00a0option.<\/p>\n