@@ -16,8 +16,8 @@
This document contains the release notes for the LLVM Compiler -Infrastructure, release 2.9. Here we describe the status of LLVM, including -major improvements from the previous release and significant known problems. -All LLVM releases may be downloaded from the LLVM releases web site.
+ Infrastructure, release 3.0. Here we describe the status of LLVM, including + major improvements from the previous release and significant known problems. + All LLVM releases may be downloaded from + the LLVM releases web site.For more information about LLVM, including information about the latest -release, please check out the main LLVM -web site. If you have questions or comments, the LLVM Developer's -Mailing List is a good place to send them.
+ release, please check out the main LLVM web + site. If you have questions or comments, + the LLVM + Developer's Mailing List is a good place to send them. -Note that if you are reading this file from a Subversion checkout or the -main LLVM web page, this document applies to the next release, not the -current one. To see the release notes for a specific release, please see the -releases page.
+Note that if you are reading this file from a Subversion checkout or the main + LLVM web page, this document applies to the next release, not the + current one. To see the release notes for a specific release, please see the + releases page.
-The LLVM 2.9 distribution currently consists of code from the core LLVM -repository (which roughly includes the LLVM optimizers, code generators -and supporting tools), the Clang repository and the llvm-gcc repository. In -addition to this code, the LLVM Project includes other sub-projects that are in -development. Here we include updates on these subprojects. -
- -The LLVM 3.0 distribution currently consists of code from the core LLVM + repository (which roughly includes the LLVM optimizers, code generators and + supporting tools), the Clang repository and the llvm-gcc repository. In + addition to this code, the LLVM Project includes other sub-projects that are + in development. Here we include updates on these subprojects.
Clang is an LLVM front end for the C, -C++, and Objective-C languages. Clang aims to provide a better user experience -through expressive diagnostics, a high level of conformance to language -standards, fast compilation, and low memory use. Like LLVM, Clang provides a -modular, library-based architecture that makes it suitable for creating or -integrating with other development tools. Clang is considered a -production-quality compiler for C, Objective-C, C++ and Objective-C++ on x86 -(32- and 64-bit), and for darwin/arm targets.
- -In the LLVM 2.9 time-frame, the Clang team has made many improvements in C, -C++ and Objective-C support. C++ support is now generally rock solid, has -been exercised on a broad variety of code, and has several new C++'0x features -implemented (such as rvalue references and variadic templates). LLVM 2.9 has -also brought in a large range of bug fixes and minor features (e.g. __label__ -support), and is much more compatible with the Linux Kernel.
+ C++, and Objective-C languages. Clang aims to provide a better user + experience through expressive diagnostics, a high level of conformance to + language standards, fast compilation, and low memory use. Like LLVM, Clang + provides a modular, library-based architecture that makes it suitable for + creating or integrating with other development tools. Clang is considered a + production-quality compiler for C, Objective-C, C++ and Objective-C++ on x86 + (32- and 64-bit), and for darwin/arm targets. + +In the LLVM 3.0 time-frame, the Clang team has made many improvements:
+ +If Clang rejects your code but another compiler accepts it, please take a -look at the language -compatibility guide to make sure this is not intentional or a known issue. -
+ look at the language + compatibility guide to make sure this is not intentional or a known + issue.-DragonEgg is a -gcc plugin that replaces GCC's -optimizers and code generators with LLVM's. -Currently it requires a patched version of gcc-4.5. -The plugin can target the x86-32 and x86-64 processor families and has been -used successfully on the Darwin, FreeBSD and Linux platforms. -The Ada, C, C++ and Fortran languages work well. -The plugin is capable of compiling plenty of Obj-C, Obj-C++ and Java but it is -not known whether the compiled code actually works or not! -
+DragonEgg is a + gcc plugin that replaces GCC's + optimizers and code generators with LLVM's. Currently it requires a patched + version of gcc-4.5. The plugin can target the x86-32 and x86-64 processor + families and has been used successfully on the Darwin, FreeBSD and Linux + platforms. The Ada, C, C++ and Fortran languages work well. The plugin is + capable of compiling plenty of Obj-C, Obj-C++ and Java but it is not known + whether the compiled code actually works or not!
+ +The 3.0 release has the following notable changes:
--The 2.9 release has the following notable changes:
-The new LLVM compiler-rt project -is a simple library that provides an implementation of the low-level -target-specific hooks required by code generation and other runtime components. -For example, when compiling for a 32-bit target, converting a double to a 64-bit -unsigned integer is compiled into a runtime call to the "__fixunsdfdi" -function. The compiler-rt library provides highly optimized implementations of -this and other low-level routines (some are 3x faster than the equivalent -libgcc routines).
+The new LLVM compiler-rt project + is a simple library that provides an implementation of the low-level + target-specific hooks required by code generation and other runtime + components. For example, when compiling for a 32-bit target, converting a + double to a 64-bit unsigned integer is compiled into a runtime call to the + "__fixunsdfdi" function. The compiler-rt library provides highly optimized + implementations of this and other low-level routines (some are 3x faster than + the equivalent libgcc routines).
-In the LLVM 2.9 timeframe, compiler_rt has had several minor changes for - better ARM support, and a fairly major license change. All of the code in the - compiler-rt project is now dual - licensed under MIT and UIUC license, which allows you to use compiler-rt - in applications without the binary copyright reproduction clause. If you - prefer the LLVM/UIUC license, you are free to continue using it under that - license as well.
+In the LLVM 3.0 timeframe,
-LLDB is a brand new member of the LLVM -umbrella of projects. LLDB is a next generation, high-performance debugger. It -is built as a set of reusable components which highly leverage existing -libraries in the larger LLVM Project, such as the Clang expression parser, the -LLVM disassembler and the LLVM JIT.
+-LLDB is has advanced by leaps and bounds in the 2.9 timeframe. It is -dramatically more stable and useful, and includes both a new tutorial and a side-by-side comparison with -GDB.
+LLDB has advanced by leaps and bounds in the 3.0 timeframe. It is + dramatically more stable and useful, and includes both a + new tutorial and + a side-by-side comparison with + GDB.
-libc++ is another new member of the LLVM -family. It is an implementation of the C++ standard library, written from the -ground up to specifically target the forthcoming C++'0X standard and focus on -delivering great performance.
+-In the LLVM 2.9 timeframe, libc++ has had numerous bugs fixed, and is now being -co-developed with Clang's C++'0x mode.
- --Like compiler_rt, libc++ is now dual - licensed under the MIT and UIUC license, allowing it to be used more - permissively. -
+Like compiler_rt, libc++ is now dual + licensed under the MIT and UIUC license, allowing it to be used more + permissively.
- - LLBrowse is an interactive viewer for LLVM modules. It can load any LLVM - module and displays its contents as an expandable tree view, facilitating an - easy way to inspect types, functions, global variables, or metadata nodes. It - is fully cross-platform, being based on the popular wxWidgets GUI toolkit. -
++ LLBrowse is an interactive viewer for LLVM modules. It can load any LLVM + module and displays its contents as an expandable tree view, facilitating an + easy way to inspect types, functions, global variables, or metadata nodes. It + is fully cross-platform, being based on the popular wxWidgets GUI + toolkit.
+The VMKit project is an implementation - of a Java Virtual Machine (Java VM or JVM) that uses LLVM for static and - just-in-time compilation. As of LLVM 2.9, VMKit now supports generational - garbage collectors. The garbage collectors are provided by the MMTk framework, - and VMKit can be configured to use one of the numerous implemented collectors - of MMTk. -
+ of a Java Virtual Machine (Java VM or JVM) that uses LLVM for static and + just-in-time compilation. As of LLVM 3.0, VMKit now supports generational + garbage collectors. The garbage collectors are provided by the MMTk + framework, and VMKit can be configured to use one of the numerous implemented + collectors of MMTk. +KLEE is a symbolic execution framework for programs in LLVM bitcode form. KLEE tries to symbolically evaluate "all" paths @@ -274,88 +262,390 @@ be used to verify some algorithms.
UPDATE!
An exciting aspect of LLVM is that it is used as an enabling technology for a lot of other language and tools projects. This section lists some of the - projects that have already been updated to work with LLVM 2.9.
+ projects that have already been updated to work with LLVM 3.0. + + +AddressSanitizer + uses compiler instrumentation and a specialized malloc library to find C/C++ + bugs such as use-after-free and out-of-bound accesses to heap, stack, and + globals. The key feature of the tool is speed: the average slowdown + introduced by AddressSanitizer is less than 2x.
+Clam AntiVirus is an open source (GPL) + anti-virus toolkit for UNIX, designed especially for e-mail scanning on mail + gateways.
+ +Since version 0.96 it + has bytecode + signatures that allow writing detections for complex malware.
+ +It uses LLVM's JIT to speed up the execution of bytecode on X86, X86-64, + PPC32/64, falling back to its own interpreter otherwise. The git version was + updated to work with LLVM 3.0.
+ +clReflect is a C++ + parser that uses clang/LLVM to derive a light-weight reflection database + suitable for use in game development. It comes with a very simple runtime + library for loading and querying the database, requiring no external + dependencies (including CRT), and an additional utility library for object + management and serialisation.
+ +Cling is an interactive compiler interface + (aka C++ interpreter). It uses LLVM's JIT and clang; it currently supports + C++ and C. It has a prompt interface, runs source files, calls into shared + libraries, prints the value of expressions, even does runtime lookup of + identifiers (dynamic scopes). And it just behaves like one would expect from + an interpreter.
+ +-Crack aims to provide the -ease of development of a scripting language with the performance of a compiled -language. The language derives concepts from C++, Java and Python, incorporating -object-oriented programming, operator overloading and strong typing.
+Crack aims to provide + the ease of development of a scripting language with the performance of a + compiled language. The language derives concepts from C++, Java and Python, + incorporating object-oriented programming, operator overloading and strong + typing.
+Eero is a fully + header-and-binary-compatible dialect of Objective-C 2.0, implemented with a + patched version of the Clang/LLVM compiler. It features a streamlined syntax, + Python-like indentation, and new operators, for improved readability and + reduced code clutter. It also has new features such as limited forms of + operator overloading and namespaces, and strict (type-and-operator-safe) + enumerations. It is inspired by languages such as Smalltalk, Python, and + Ruby.
+ +GHC is an open source, state-of-the-art programming suite for Haskell, a + standard lazy functional programming language. It includes an optimizing + static compiler generating good code for a variety of platforms, together + with an interactive system for convenient, quick development.
+ +GHC 7.0 and onwards include an LLVM code generator, supporting LLVM 2.8 and + later. Since LLVM 2.9, GHC now includes experimental support for the ARM + platform with LLVM 3.0.
+ +gwXscript is an object oriented, + aspect oriented programming language which can create both executables (ELF, + EXE) and shared libraries (DLL, SO, DYNLIB). The compiler is implemented in + its own language and translates scripts into LLVM-IR which can be optimized + and translated into native code by the LLVM framework. Source code in + gwScript contains definitions that expand the namespaces. So you can build + your project and simply 'plug out' features by removing a file. The remaining + project does not leave scars since you directly separate concerns by the + 'template' feature of gwX. It is also possible to add new features to a + project by just adding files and without editing the original project. This + language is used for example to create games or content management systems + that should be extendable.
+ +gwXscript is strongly typed and offers comfort with its native types string, + hash and array. You can easily write new libraries in gwXscript or native + code. gwXscript is type safe and users should not be able to crash your + program or execute malicious code except code that is eating CPU time.
+ +include-what-you-use
+ is a tool to ensure that a file directly #includes
+ all .h files that provide a symbol that the file uses. It also
+ removes superfluous #includes from source files.
ispc is a compiler for "single program, + multiple data" (SPMD) programs. It compiles a C-based SPMD programming + language to run on the SIMD units of CPUs; it often delivers 5-6x speedups on + a single core of a CPU with an 8-wide SIMD unit compared to serial code, + while still providing a clean and easy-to-understand programming model. For + an introduction to the language and its performance, + see the walkthrough of a short + example program. ispc is licensed under the BSD license.
+ +LanguageKit is + a framework for implementing dynamic languages sharing an object model with + Objective-C. It provides static and JIT compilation using LLVM along with + its own interpreter. Pragmatic Smalltalk is a dialect of Smalltalk, built on + top of LanguageKit, that interfaces directly with Objective-C, sharing the + same object representation and message sending behaviour. These projects are + developed as part of the Étoié desktop environment.
+ +LuaAV is a real-time + audiovisual scripting environment based around the Lua language and a + collection of libraries for sound, graphics, and other media protocols. LuaAV + uses LLVM and Clang to JIT compile efficient user-defined audio synthesis + routines specified in a declarative syntax.
+ +An open source, cross-platform implementation of C# and the CLR that is + binary compatible with Microsoft.NET. Has an optional, dynamically-loaded + LLVM code generation backend in Mini, the JIT compiler.
+ +Note that we use a Git mirror of LLVM with some patches. See: + https://github.com/mono/llvm
+ +Portable OpenCL is an open source implementation of the OpenCL standard which + can be easily adapted for new targets. One of the goals of the project is + improving performance portability of OpenCL programs, avoiding the need for + target-dependent manual optimizations. A "native" target is included, which + allows running OpenCL kernels on the host (CPU).
+ +Pure is an + algebraic/functional programming language based on term rewriting. Programs + are collections of equations which are used to evaluate expressions in a + symbolic fashion. The interpreter uses LLVM as a backend to JIT-compile Pure + programs to fast native code. Pure offers dynamic typing, eager and lazy + evaluation, lexical closures, a hygienic macro system (also based on term + rewriting), built-in list and matrix support (including list and matrix + comprehensions) and an easy-to-use interface to C and other programming + languages (including the ability to load LLVM bitcode modules, and inline C, + C++, Fortran and Faust code in Pure programs if the corresponding LLVM-enabled + compilers are installed).
+ +Pure version 0.48 has been tested and is known to work with LLVM 3.0 + (and continues to work with older LLVM releases >= 2.5).
+ +Renderscript + is Android's advanced 3D graphics rendering and compute API. It provides a + portable C99-based language with extensions to facilitate common use cases + for enhancing graphics and thread level parallelism. The Renderscript + compiler frontend is based on Clang/LLVM. It emits a portable bitcode format + for the actual compiled script code, as well as reflects a Java interface for + developers to control the execution of the compiled bitcode. Executable + machine code is then generated from this bitcode by an LLVM backend on the + device. Renderscript is thus able to provide a mechanism by which Android + developers can improve performance of their applications while retaining + portability.
+ +SAFECode is a memory safe C/C++ + compiler built using LLVM. It takes standard, unannotated C/C++ code, + analyzes the code to ensure that memory accesses and array indexing + operations are safe, and instruments the code with run-time checks when + safety cannot be proven statically. SAFECode can be used as a debugging aid + (like Valgrind) to find and repair memory safety bugs. It can also be used + to protect code from security attacks at run-time.
+ +The Stupid D Compiler is a + project seeking to write a self-hosting compiler for the D programming + language without using the frontend of the reference compiler (DMD).
+ +TCE is a toolset for designing application-specific processors (ASP) based on -the Transport triggered architecture (TTA). The toolset provides a complete -co-design flow from C/C++ programs down to synthesizable VHDL and parallel -program binaries. Processor customization points include the register files, -function units, supported operations, and the interconnection network.
+ the Transport triggered architecture (TTA). The toolset provides a complete + co-design flow from C/C++ programs down to synthesizable VHDL and parallel + program binaries. Processor customization points include the register files, + function units, supported operations, and the interconnection network.TCE uses Clang and LLVM for C/C++ language support, target independent -optimizations and also for parts of code generation. It generates new LLVM-based -code generators "on the fly" for the designed TTA processors and loads them in -to the compiler backend as runtime libraries to avoid per-target recompilation -of larger parts of the compiler chain.
+ optimizations and also for parts of code generation. It generates new + LLVM-based code generators "on the fly" for the designed TTA processors and + loads them in to the compiler backend as runtime libraries to avoid + per-target recompilation of larger parts of the compiler chain. +Tart is a general-purpose, + strongly typed programming language designed for application + developers. Strongly inspired by Python and C#, Tart focuses on practical + solutions for the professional software developer, while avoiding the clutter + and boilerplate of legacy languages like Java and C++. Although Tart is still + in development, the current implementation supports many features expected of + a modern programming language, such as garbage collection, powerful + bidirectional type inference, a greatly simplified syntax for template + metaprogramming, closures and function literals, reflection, operator + overloading, explicit mutability and immutability, and much more. Tart is + flexible enough to accommodate a broad range of programming styles and + philosophies, while maintaining a strong commitment to simplicity, minimalism + and elegance in design.
+ThreadSanitizer is a + data race detector for (mostly) C and C++ code, available for Linux, Mac OS + and Windows. On different systems, we use binary instrumentation frameworks + (Valgrind and Pin) as frontends that generate the program events for the race + detection algorithm. On Linux, there's an option of using LLVM-based + compile-time instrumentation.
+ +ZooLib is Open Source under the MIT + License. It provides GUI, filesystem access, TCP networking, thread-safe + memory management, threading and locking for Mac OS X, Classic Mac OS, + Microsoft Windows, POSIX operating systems with X11, BeOS, Haiku, Apple's iOS + and Research in Motion's BlackBerry.
+ +My current work is to use CLang's static analyzer to improve ZooLib's code + quality. I also plan to set up LLVM compiles of the demo programs and test + programs using CLang and LLVM on all the platforms that CLang, LLVM and + ZooLib all support.
+ +Pure is an - algebraic/functional - programming language based on term rewriting. Programs are collections - of equations which are used to evaluate expressions in a symbolic - fashion. The interpreter uses LLVM as a backend to JIT-compile Pure - programs to fast native code. Pure offers dynamic typing, eager and lazy - evaluation, lexical closures, a hygienic macro system (also based on - term rewriting), built-in list and matrix support (including list and - matrix comprehensions) and an easy-to-use interface to C and other - programming languages (including the ability to load LLVM bitcode - modules, and inline C, C++, Fortran and Faust code in Pure programs if - the corresponding LLVM-enabled compilers are installed).
- -Pure version 0.47 has been tested and is known to work with LLVM 2.9 - (and continues to work with older LLVM releases >= 2.5).
-GHC is an open source, state-of-the-art programming suite for Haskell, -a standard lazy functional programming language. It includes an -optimizing static compiler generating good code for a variety of -platforms, together with an interactive system for convenient, quick -development.
- -In addition to the existing C and native code generators, GHC 7.0 now -supports an LLVM code generator. GHC supports LLVM 2.7 and later.
-This release includes a huge number of bug fixes, performance tweaks and -minor improvements. Some of the major improvements and new features are listed -in this section. -
- -LLVM 2.9 includes several major new capabilities:
+LLVM 3.0 includes several major new capabilities:
LLVM IR has several new features for better support of new targets and that -expose new optimization opportunities:
+ expose new optimization opportunities: + +One of the biggest changes is that 3.0 has a new exception handling
+ system. The old system used LLVM intrinsics to convey the exception handling
+ information to the code generator. It worked in most cases, but not
+ all. Inlining was especially difficult to get right. Also, the intrinsics
+ could be moved away from the invoke instruction, making it hard
+ to recover that information.
The new EH system makes exception handling a first-class member of the IR. It + adds two new instructions:
landingpad —
+ this instruction defines a landing pad basic block. It contains all of the
+ information that's needed by the code generator. It's also required to be
+ the first non-PHI instruction in the landing pad. In addition, a landing
+ pad may be jumped to only by the unwind edge of an invoke
+ instruction.resume — this
+ instruction causes the current exception to resume traveling up the
+ stack. It replaces the @llvm.eh.resume intrinsic.Converting from the old EH API to the new EH API is rather simple, because a
+ lot of complexity has been removed. The two intrinsics,
+ @llvm.eh.exception and @llvm.eh.selector have been
+ superceded by the landingpad instruction. Instead of generating
+ a call to @llvm.eh.exception and @llvm.eh.selector:
+
+
+Function *ExcIntr = Intrinsic::getDeclaration(TheModule, + Intrinsic::eh_exception); +Function *SlctrIntr = Intrinsic::getDeclaration(TheModule, + Intrinsic::eh_selector); + +// The exception pointer. +Value *ExnPtr = Builder.CreateCall(ExcIntr, "exc_ptr"); + +std::vector<Value*> Args; +Args.push_back(ExnPtr); +Args.push_back(Builder.CreateBitCast(Personality, + Type::getInt8PtrTy(Context))); + +// Add selector clauses to Args. + +// The selector call. +Builder.CreateCall(SlctrIntr, Args, "exc_sel"); ++
You should instead generate a landingpad instruction, that
+ returns an exception object and selector value:
+LandingPadInst *LPadInst = + Builder.CreateLandingPad(StructType::get(Int8PtrTy, Int32Ty, NULL), + Personality, 0); + +Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); +Builder.CreateStore(LPadExn, getExceptionSlot()); + +Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1); +Builder.CreateStore(LPadSel, getEHSelectorSlot()); ++
It's now trivial to add the individual clauses to the landingpad
+ instruction.
+// Adding a catch clause +Constant *TypeInfo = getTypeInfo(); +LPadInst->addClause(TypeInfo); + +// Adding a C++ catch-all +LPadInst->addClause(Constant::getNullValue(Builder.getInt8PtrTy())); + +// Adding a cleanup +LPadInst->setCleanup(true); + +// Adding a filter clause +std::vector<Constant*> TypeInfos; +Constant *TypeInfo = getFilterTypeInfo(); +TypeInfos.push_back(Builder.CreateBitCast(TypeInfo, Builder.getInt8PtrTy())); + +ArrayType *FilterTy = ArrayType::get(Int8PtrTy, TypeInfos.size()); +LPadInst->addClause(ConstantArray::get(FilterTy, TypeInfos)); ++
Converting from using the @llvm.eh.resume intrinsic to
+ the resume instruction is trivial. It takes the exception
+ pointer and exception selector values returned by
+ the landingpad instruction:
+Type *UnwindDataTy = StructType::get(Builder.getInt8PtrTy(), + Builder.getInt32Ty(), NULL); +Value *UnwindData = UndefValue::get(UnwindDataTy); +Value *ExcPtr = Builder.CreateLoad(getExceptionObjSlot()); +Value *ExcSel = Builder.CreateLoad(getExceptionSelSlot()); +UnwindData = Builder.CreateInsertValue(UnwindData, ExcPtr, 0, "exc_ptr"); +UnwindData = Builder.CreateInsertValue(UnwindData, ExcSel, 1, "exc_sel"); +Builder.CreateResume(UnwindData); ++
The induction variable simplification pass in 3.0 only modifies + induction variables when profitable. Sign and zero extension + elimination, linear function test replacement, loop unrolling, and + other simplifications that require induction variable analysis have + been generalized so they no longer require loops to be rewritten in a + typically suboptimal form prior to optimization. This new design + preserves more IR level information, avoids undoing earlier loop + optimizations (particularly hand-optimized loops), and no longer + strongly depends on the code generator rewriting loops a second time + in a now optimal form--an intractable problem.
+ +The original behavior can be restored with -mllvm -enable-iv-rewrite; + however, support for this mode will be short lived. As such, bug + reports should be filed for any significant performance regressions + when moving from -mllvm -enable-iv-rewrite to the 3.0 default mode.
In addition to a large array of minor performance tweaks and bug fixes, this -release includes a few major enhancements and additions to the optimizers:
+ release includes a few major enhancements and additions to the + optimizers:- unsigned long t = a+b; - if (t < a) ... -- into: -
- addq %rdi, %rbx - jno LBB0_2 -+
-The LLVM Machine Code (aka MC) subsystem was created to solve a number -of problems in the realm of assembly, disassembly, object file format handling, -and a number of other related areas that CPU instruction-set level tools work -in.
+The LLVM Machine Code (aka MC) subsystem was created to solve a number of + problems in the realm of assembly, disassembly, object file format handling, + and a number of other related areas that CPU instruction-set level tools work + in.
+For more information, please see the Intro to the -LLVM MC Project Blog Post. -
+For more information, please see + the Intro + to the LLVM MC Project Blog Post.
We have put a significant amount of work into the code generator -infrastructure, which allows us to implement more aggressive algorithms and make -it run faster:
+ infrastructure, which allows us to implement more aggressive algorithms and + make it run faster:New features and major changes in the X86 target include: -
+New features and major changes in the X86 target include:
@llvm.x86.sse42.crc32.[8|16|32]
+ and @llvm.x86.sse42.crc64.[8|64]. They have been renamed to
+ @llvm.x86.sse42.crc32.32.[8|16|32] and
+ @llvm.x86.sse42.crc32.64.[8|64].New features of the ARM target include: -
+New features of the ARM target include:
-PPC32/ELF va_arg was implemented.
+PPC32 initial support for .o file writing was implemented.
-If you're already an LLVM user or developer with out-of-tree changes based -on LLVM 2.8, this section lists some "gotchas" that you may run into upgrading -from the previous release.
+If you're already an LLVM user or developer with out-of-tree changes based on + LLVM 2.9, this section lists some "gotchas" that you may run into upgrading + from the previous release.
LLVMC front end code was removed while separating
+ out language independence.LowerSetJmp pass wasn't used effectively by any
+ target and has been removed.TailDup pass was not used in the standard pipeline
+ and was unable to update ssa form, so it has been removed.
+ load volatile"/"store volatile". The old
+ syntax ("volatile load"/"volatile store")
+ is still accepted, but is now considered deprecated.llvm.memory.barrier and
+ llvm.atomic.*) are now gone. Please use the new atomic
+ instructions, described in the atomics guide.
+In addition, many APIs have changed in this release. Some of the major - LLVM API changes are:
+ LLVM API changes are:PHINode::reserveOperandSpace has been removed. Instead, you
+ must specify how many operands to reserve space for when you create the
+ PHINode, by passing an extra argument
+ into PHINode::Create.PHINode::block_begin
+ and PHINode::block_end.ArrayRef instead of either a
+ pair of pointers (or iterators) to the beginning and end of a range, or a
+ pointer and a length. Others now return an ArrayRef instead
+ of a reference to a SmallVector
+ or std::vector. These include:
+CallInst::CreateComputeLinearIndex (in llvm/CodeGen/Analysis.h)ConstantArray::getConstantExpr::getExtractElementConstantExpr::getGetElementPtrConstantExpr::getInBoundsGetElementPtrConstantExpr::getIndicesConstantExpr::getInsertElementConstantExpr::getWithOperandsConstantFoldCall (in llvm/Analysis/ConstantFolding.h)ConstantFoldInstOperands (in llvm/Analysis/ConstantFolding.h)ConstantVector::getDIBuilder::createComplexVariableDIBuilder::getOrCreateArrayExtractValueInst::CreateExtractValueInst::getIndexedTypeExtractValueInst::getIndicesFindInsertedValue (in llvm/Analysis/ValueTracking.h)gep_type_begin (in llvm/Support/GetElementPtrTypeIterator.h)gep_type_end (in llvm/Support/GetElementPtrTypeIterator.h)GetElementPtrInst::CreateGetElementPtrInst::CreateInBoundsGetElementPtrInst::getIndexedTypeInsertValueInst::CreateInsertValueInst::getIndicesInvokeInst::CreateIRBuilder::CreateCallIRBuilder::CreateExtractValueIRBuilder::CreateGEPIRBuilder::CreateInBoundsGEPIRBuilder::CreateInsertValueIRBuilder::CreateInvokeMDNode::getMDNode::getIfExistsMDNode::getTemporaryMDNode::getWhenValsUnresolvedSimplifyGEPInst (in llvm/Analysis/InstructionSimplify.h)TargetData::getIndexedOffsetStringMap::getOrCreateValue have been remove
+ except for the one which takes a StringRef.LLVMBuildUnwind function from the C API was removed. The
+ LLVM unwind instruction has been deprecated for a long time
+ and isn't used by the current front-ends. So this was removed during the
+ exception handling rewrite.LLVMAddLowerSetJmpPass function from the C API was
+ removed because the LowerSetJmp pass was removed.DIBuilder interface used by front ends to encode
+ debugging information in the LLVM IR now expects clients to
+ use DIBuilder::finalize() at the end of translation unit to
+ complete debugging information encoding.PATypeHolder and OpaqueType are gone,
+ and all APIs deal with Type* instead of const
+ Type*. If you need to create recursive structures, then create a
+ named structure, and use setBody() when all its elements are
+ built. Type merging and refining is gone too: named structures are not
+ merged with other structures, even if their layout is identical. (of
+ course anonymous structures are still uniqued by layout).llvm.memset.i32).INITIALIZE_PASS{BEGIN,END,}
+ and INITIALIZE_{PASS,AG}_DEPENDENCY.This section contains significant known problems with the LLVM system, -listed by component. If you run into a problem, please check the LLVM bug database and submit a bug if -there isn't already one.
- -This section contains significant known problems with the LLVM system, listed + by component. If you run into a problem, please check + the LLVM bug database and submit a bug if + there isn't already one.
The following components of this LLVM release are either untested, known to -be broken or unreliable, or are in early development. These components should -not be relied on, and bugs should not be filed against them, but they may be -useful to some people. In particular, if you would like to work on one of these -components, please contact us on the LLVMdev list.
+ be broken or unreliable, or are in early development. These components + should not be relied on, and bugs should not be filed against them, but they + may be useful to some people. In particular, if you would like to work on + one of these components, please contact us on + the LLVMdev + list.The C backend has numerous problems and is not being actively maintained. -Depending on it for anything serious is not advised.
+ Depending on it for anything serious is not advised.LLVM 2.9 will be the last release of llvm-gcc.
+LLVM 2.9 was the last release of llvm-gcc.
llvm-gcc is generally very stable for the C family of languages. The only major language feature of GCC not supported by llvm-gcc is the @@ -1007,8 +1359,11 @@ Depending on it for anything serious is not advised.
dragonegg instead.The llvm-gcc 4.2 Ada compiler has basic functionality, but is no longer being -actively maintained. If you are interested in Ada, we recommend that you -consider using dragonegg instead.
+ actively maintained. If you are interested in Ada, we recommend that you + consider using dragonegg instead. + +A wide variety of additional information is available on the LLVM web page, in particular in the documentation section. The web page also -contains versions of the API documentation which is up-to-date with the -Subversion version of the source code. -You can access versions of these documents specific to this release by going -into the "llvm/doc/" directory in the LLVM tree.
+A wide variety of additional information is available on + the LLVM web page, in particular in + the documentation section. The web page + also contains versions of the API documentation which is up-to-date with the + Subversion version of the source code. You can access versions of these + documents specific to this release by going into the "llvm/doc/" + directory in the LLVM tree.
If you have any questions or comments about LLVM, please feel free to contact -us via the mailing -lists.
+ us via the mailing lists.