LLVM Development @ Linaro

At Linaro, we're working LLVM, Clang and related projects on ARM, as an alternative to GCC. Our focus is to assure the quality and performance of the generated code for ARM+Linux on the Cortex class of processors.

Clang is used as the default system compiler for FreeBSDAndroid and OpenMandriva. There are also projects that are looking to use Clang either by default (ex Chromium) or as a side compiler for robustness (ex. Linux Kernel).

Finally, a number of members have their own compilation infrastructure based on LLVM, for which we provide a common and upstream validation and development infrastructure, facilitating adoption of other LLVM modules and ensuring a wider coverage for the modules they have already chosen.


LLVM provides some benefits over other compilers:

  • Its pluggable, modern interface, allows quick prototyping and easy integration of new features or alternative implementations, making it a good tool for testing combinations of multiple approaches on benchmarks.
  • Its flexible license allows companies to enhance the compiler with proprietary extensions with reduced maintenance cost, which makes it easier to open source parts, but not the whole, of the extension later.
  • All back-ends build by default, making LLVM a versatile native and cross-compiler on the same binary. Production support for many architectures provide an easy way to use the same compiler/build system for all your targets.
  • Native Just-In-Time compilation and interpreter (VM) allow for run-time optimizations and adaptations, used by LLDB, OpenCL, Renderscript, OpenGL, stored procedures and interpreted languages.


Our team is working into 7 main areas:

  • Code generation quality: fixing back-end and assembler bugs, as well as correct platform support for ARM targets in the front and middle end.
  • Compatibility with other toolchains: making sure Clang/LLVM is compatible with other tools and libraries (especially the GNU toolchain).
  • Library and sanitizers: extending and validating support for Compiler-RT and the sanitizers (soon libc++ too).
  • Performance: measuring performance and working with developers and members to upstream improvements and fixes.
  • Linker: implementing both AArch64 and ARM back-ends to LLD and adding the required features for it to be a full system linker.
  • Debugger: working on LLDB to provide full ARM and AArch64 support and the full debug illusion, integrating with IDEs and as a replacement for GDB.
  • Buildbot support and validation: providing an extensive set of buildbots in a number of configurations, monitoring, fixing, keeping them green.

Our upstream activities can be seen in Bugzilla, Phabricator and the LLVM, Clang and LLDB mailing lists.


Our current roadmap is to work on the following issues:

  • Code Generation, working on the new instruction selection mechanism for ARM and AArch64, Global ISel.
  • Linker, keeping the AArch64 back-end in check and implementing an ARM back-end from scratch.
  • Debugger, Stabilising Android debugging on both ARM and AArch64 with LLDB server, investigating unaligned watchpoints, hardware breakpoints, creating buildbots for ARM and AArch64.
  • Integrated assembler, improving support for assembly files in projects like Android, Linux kernel and Chromium, as well as any other project that reports bugs on the IAS.
  • Target support, simplifying the platform choices in ARM and AArch64 targets (from Clang all the way to their back-ends), including compiler options, internal feature flags, etc.
  • Sanitizers, implementing dynamic VMA choices, TLS support in TSAN and understanding the concerns for 48 and 52 bit VMA in the future.
  • Buildbots, constantly monitoring them, as well as revamping the infrastructure to a more robust setting and adding new ones (LLD, LLDB, libc++).

Feel free to drop us an email or stop by our hacking room during Connects to discuss our activities and roadmaps.