+
+
+Written by the LLVM Team
-This document contains the release notes for the LLVM Compiler - Infrastructure, release 3.0. Here we describe the status of LLVM, including + Infrastructure, release 3.2. Here we describe the status of LLVM, including major improvements from the previous release, improvements in various - subprojects of LLVM, and some of the current users of the code. - All LLVM releases may be downloaded from - the LLVM releases web site.
+ subprojects of LLVM, and some of the current users of the code. 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 @@ -62,8 +62,8 @@ Release Notes. releases page.
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), and the Clang 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.2 distribution currently consists of code from the core LLVM + repository, which roughly includes the LLVM optimizers, code generators and + supporting tools, and the Clang repository. In addition to this code, the + LLVM Project includes other sub-projects that are in development. Here we + include updates on these subprojects.
In the LLVM 3.0 time-frame, the Clang team has made many improvements:
- +In the LLVM 3.2 time-frame, the Clang team has made many improvements. + Highlights include:
For more details about the changes to Clang since the 3.1 release, see the + Clang release + notes.
+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 @@ -152,31 +117,19 @@ Release Notes.
DragonEgg is a gcc plugin that replaces GCC's - optimizers and code generators with LLVM's. It works with gcc-4.5 or gcc-4.6, - targets the x86-32 and x86-64 processor families, and has been successfully - used on the Darwin, FreeBSD, KFreeBSD, Linux and OpenBSD platforms. It fully - supports Ada, C, C++ and Fortran. It has partial support for Go, Java, Obj-C - and Obj-C++.
- -The 3.0 release has the following notable changes:
+ optimizers and code generators with LLVM's. It works with gcc-4.5 and gcc-4.6 + (and partially with gcc-4.7), can target the x86-32/x86-64 and ARM processor + families, and has been successfully used on the Darwin, FreeBSD, KFreeBSD, + Linux and OpenBSD platforms. It fully supports Ada, C, C++ and Fortran. It + has partial support for Go, Java, Obj-C and Obj-C++. -The 3.2 release has the following notable changes:
+__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 3.0 timeframe, the target specific ARM code has converted to - "unified" assembly syntax, and several new functions have been added to the - library.
+The 3.2 release has the following notable changes:
+ +LLDB is a ground-up implementation of a command line debugger, as well as a - debugger API that can be used from other applications. LLDB makes use of the - Clang parser to provide high-fidelity expression parsing (particularly for - C++) and uses the LLVM JIT for target support.
- -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.
+ +LLDB is a ground-up implementation of a + command line debugger, as well as a debugger API that can be used from other + applications. LLDB makes use of the Clang parser to provide high-fidelity + expression parsing (particularly for C++) and uses the LLVM JIT for target + support.
+ +The 3.2 release has the following notable changes:
+ +Libc++ has been ported to FreeBSD and imported into the base system. It is - planned to be the default STL implementation for FreeBSD 10.
+Within the LLVM 3.2 time-frame there were the following highlights:
+ +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. - -
In the LLVM 3.0 time-frame, VMKit has had significant improvements on both - runtime and startup performance:
+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.
-The 3.2 release has the following notable changes:
-- 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.
- -Polly is an experimental + optimizer for data locality and parallelism. It currently provides high-level + loop optimizations and automatic parallelisation (using the OpenMP run time). + Work in the area of automatic SIMD and accelerator code generation was + started.
- - +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 3.0.
+ a lot of other language and tools projects. This section lists some of the + projects that have already been updated to work with LLVM 3.2. - -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.
- -clang_complete is a - VIM plugin, that provides accurate C/C++ autocompletion using the clang front - end. The development version of clang complete, can directly use libclang - which can maintain a cache to speed up auto completion.
- -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 supports C++ and C, and uses LLVM's JIT and the - Clang parser. 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.
- -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.
- -FAUST is a compiled language for - real-time audio signal processing. The name FAUST stands for Functional - AUdio STream. Its programming model combines two approaches: functional - programming and block diagram composition. In addition with the C, C++, Java - output formats, the Faust compiler can now generate LLVM bitcode, and works - with LLVM 2.7-3.0. -
+ real-time audio signal processing. The name FAUST stands for Functional + AUdio STream. Its programming model combines two approaches: functional + programming and block diagram composition. In addition with the C, C++, Java, + JavaScript output formats, the Faust compiler can generate LLVM bitcode, and + works with LLVM 2.7-3.1.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.
- -GHC is an open source compiler and + programming suite for Haskell, a 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.
- -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.
- -GHC 7.0 and onwards include an LLVM code generator, supporting LLVM 2.8 and + later.
-Julia is a high-level, - high-performance dynamic language for technical - computing. It provides a sophisticated compiler, distributed parallel - execution, numerical accuracy, and an extensive mathematical function - library. The compiler uses type inference to generate fast code - without any type declarations, and uses LLVM's optimization passes and - JIT compiler. The language is designed around multiple dispatch, - giving programs a large degree of flexibility. It is ready for use on many - kinds of problems.
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 Étoilé desktop environment.
+Julia is a high-level, + high-performance dynamic language for technical computing. It provides a + sophisticated compiler, distributed parallel execution, numerical accuracy, + and an extensive mathematical function library. The compiler uses type + inference to generate fast code without any type declarations, and uses + LLVM's optimization passes and JIT compiler. The + Julia Language is designed + around multiple dispatch, giving programs a large degree of flexibility. It + is ready for use on many kinds of problems.
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.
+LLVM D Compiler (LDC) is + a compiler for the D programming Language. It is based on the DMD frontend + and uses LLVM as backend.
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.
+Open Shading + Language (OSL) is a small but rich language for programmable shading in + advanced global illumination renderers and other applications, ideal for + describing materials, lights, displacement, and pattern generation. It uses + LLVM to JIT complex shader networks to x86 code at runtime.
-Note that we use a Git mirror of LLVM with some patches.
+OSL was developed by Sony Pictures Imageworks for use in its in-house + renderer used for feature film animation and visual effects, and is + distributed as open source software with the "New BSD" license.
Polly is an advanced data-locality - optimizer and automatic parallelizer. It uses an advanced, mathematical - model to calculate detailed data dependency information which it uses to - optimize the loop structure of a program. Polly can speed up sequential code - by improving memory locality and consequently the cache use. Furthermore, - Polly is able to expose different kind of parallelism which it exploits by - introducing (basic) OpenMP and SIMD code. A mid-term goal of Polly is to - automatically create optimized GPU code.
- -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).
+In addition to producing an easily portable open source OpenCL + implementation, another major goal of + pocl is improving performance portability of OpenCL programs with + compiler optimizations, reducing the need for target-dependent manual + optimizations. An important part of pocl is a set of LLVM passes used to + statically parallelize multiple work-items with the kernel compiler, even in + the presence of work-group barriers. This enables static parallelization of + the fine-grained static concurrency in the work groups in multiple ways + (SIMD, VLIW, superscalar,...).
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.
- -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).
-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).
+Pure version 0.54 has been tested and is known to work with LLVM 3.1 (and + continues to work with older LLVM releases >= 2.5).
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.
- +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/Verilog 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 @@ -679,54 +390,19 @@ be used to verify some algorithms. 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.
- -This release includes a huge number of bug fixes, performance tweaks and - minor improvements. Some of the major improvements and new features are + minor improvements. Some of the major improvements and new features are listed in this section.
@@ -736,13 +412,13 @@ be used to verify some algorithms.LLVM 3.0 includes several major changes and big features:
+LLVM 3.2 includes several major changes and big features:
LLVM IR has several new features for better support of new targets and that expose new optimization opportunities:
-In addition to many minor performance tweaks and bug fixes, this - release includes a few major enhancements and additions to the - optimizers:
+In addition to many minor performance tweaks and bug fixes, this release + includes a few major enhancements and additions to the optimizers:
__builtin_expect calls. That information is currently used for
- register spill placement and if-conversion, with additional optimizations
- planned for future releases. The same framework is intended for eventual
- use with profile-guided optimization.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.
+ in. For more information, please see the + Intro + to the LLVM MC Project Blog Post.Stack Coloring - We have implemented a new optimization pass + to merge stack objects which are used in disjoin areas of the code. + This optimization reduces the required stack space significantly, in cases + where it is clear to the optimizer that the stack slot is not shared. + We use the lifetime markers to tell the codegen that a certain alloca + is used within a region.
+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:
getExecutionDomain and setExecutionDomain hooks
- to use the pass.We added new TableGen infrastructure to support bundling for + Very Long Instruction Word (VLIW) architectures. TableGen can now + automatically generate a deterministic finite automaton from a VLIW + target's schedule description which can be queried to determine + legal groupings of instructions in a bundle.
+ +We have added a new target independent VLIW packetizer based on the + DFA infrastructure to group machine instructions into bundles.
+ +A probability based block placement and code layout algorithm was added to
+ LLVM's code generator. This layout pass supports probabilities derived from
+ static heuristics as well as source code annotations such as
+ __builtin_expect.
New features and major changes in the X86 target include:
-mavx to the compiler. AVX2 implementation is
- underway on mainline.@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:
The ARM target now includes a full featured macro assembler, including + direct-to-object module support for clang. The assembler is currently enabled + by default for Darwin only pending testing and any additional necessary + platform specific support for Linux.
+ +Full support is included for Thumb1, Thumb2 and ARM modes, along with + subtarget and CPU specific extensions for VFP2, VFP3 and NEON.
+ +The assembler is Unified Syntax only (see ARM Architecural Reference Manual + for details). While there is some, and growing, support for pre-unfied + (divided) syntax, there are still significant gaps in that support.
+ +This release has seen major new work on just about every aspect of the MIPS - backend. Some of the major new features include:
+New features and major changes in the MIPS target include:
- The PTX back-end is still experimental, but is fairly usable for compute kernels - in LLVM 3.0. Most scalar arithmetic is implemented, as well as intrinsics to - access the special PTX registers and sync instructions. The major missing - pieces are texture/sampler support and some vector operations.
- -That said, the backend is already being used for domain-specific languages - and works well with the libclc - library to supply OpenCL built-ins. With it, you can use Clang to compile - OpenCL code into PTX and execute it by loading the resulting PTX as a binary - blob using the nVidia OpenCL library. It has been tested with several OpenCL - programs, including some from the nVidia GPU Computing SDK, and the performance - is on par with the nVidia compiler.
- + +-mcpu=mblaze3
- and the 5-stage pipeline model can be selected with
- -mcpu=mblaze5.If you're already an LLVM user or developer with out-of-tree changes based on + LLVM 3.2, 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.
+In addition, many APIs have changed in this release. Some of the major + LLVM API changes are:
LLVMC meta compiler driver was 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 and will be removed in
- 3.1.llvm.memory.barrier and
- llvm.atomic.*) are now gone. Please use the new atomic
- instructions, described in the atomics guide.
- In addition, some tools have changed in this release. Some of the changes + are:
+In addition, many APIs have changed in this release. Some of the major - LLVM API changes are:
+Officially supported Python bindings have been added! Feature support is far + from complete. The current bindings support interfaces to:
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.LLVM is generally a production quality compiler, and is used by a broad range of applications and shipping in many products. That said, not every subsystem is as mature as the aggregate, particularly the more obscure - targets. If you run into a problem, please check the LLVM bug database and submit a bug if - there isn't already one or ask on the LLVMdev - list.
- + targets. If you run into a problem, please check + the LLVM bug database and submit a bug if + there isn't already one or ask on + the LLVMdev + list. +Known problem areas include:
- +