# Functional overview

This document is a reference for C/C++ programmers. It describes C
and C++ compilers for the Arm processor architecture. The compilers
are based on the LLVM compiler framework and are collectively
referred to as the *LLVM compilers*.

Note

The LLVM compilers are commonly referred to as *clang*.

We strongly recommend that you try using the various LLVM code
optimizations to improve the performance of your program. Using only
the default optimization settings might result in suboptimal
performance.

## Features

The LLVM compilers offer the following features:

- ISO C conformance
Supports the International Standards Organization (ISO) C language standard
- Compatibility
Supports Arm extensions and most GCC extensions to simplify porting
- System library
Supports standard libraries as provided in the Android NDK
- Processor-specific libraries
Provides library routines that are optimized for the Qualcomm Arm architecture
- Intrinsics
Provides a mechanism for emitting Arm assembly instructions in C source code

## Languages

The LLVM compilers support C, C++, and many dialects of those
languages:

- C language dialects:
K&R C, ANSI C89, ISO C90, ISO C94 (C89+AMD1), ISO C99 (+TC1, TC2, TC3), ISO C11
- C++ language dialects:
C++98, C++11, C++14, C++17

The LLVM compilers also support a broad variety of language
extensions. These extensions are provided for compatibility with the
GCC, Microsoft, and other popular compilers, as well as to improve
functionality through the addition of extensions unique to the LLVM
compilers.

All language extensions are explicitly recognized as such by the LLVM
compilers. They are marked with extension diagnostics that can be
mapped to warnings, errors, or simply ignored.

The following C++17 features are not supported by the compiler:

- *ISO/IEC TS 19570:2015 C++ Extensions for Parallelism* technical specification
- constexpr std::hardware\_constructive
- constexpr std::hardware\_destructive

## GCC compatibility

The LLVM compiler driver and language features are intentionally
designed to be as compatible with the GNU GCC compiler as reasonably
possible, easing migration from GCC to LLVM. In most cases, code
*just works*.

## Processor versions

The LLVM compilers can generate code for all versions of the Arm
processor architecture that are supported by the standard LLVM
compiler.

Armv8 supports two instruction set architectures (ISA):

- AArch64

    The new 64-bit ISA, which supports a larger virtual and physical
address space. All general purpose registers (and many of the system
registers) are 64 bits. All instructions are encoded in 32 bits.
- AArch32

    A 32-bit ISA that incorporates the Armv7 ISA for both Arm and Thumb
modes, and also includes many aspects of AArch64 (including support
for cryptography and enhanced floating point).

For more information, see the *ARMv8-A Reference Manual*.

Note

The LLVM compilers do not define command options
specifically for V56, but they do support V56 if you use the V55
command options.

## LLVM versions

The LLVM compilers are based on LLVM 4.0+, as defined at [llvm.org](http://llvm.org/).

## C language and compiler references

This document does not describe the following:

- C or C++ languages
- Detailed descriptions of the code optimizations performed by LLVM

For suggested references, see [References](https://docs.qualcomm.com/doc/80-VB419-99/topic/references.html).

## Doc conventions

Courier font is used for computer text and code samples, for example,
`void foo()`. The following notation is used to define command syntax:

- Square brackets enclose optional items, for example, [**label**].
- **Bold** indicates literal symbols for example, [**comment**].
- The vertical bar character, |, indicates a choice of items.
- Parentheses enclose a choice of items for example,
(**add**|**del**).
- An ellipsis, … , follows items that can appear more than once. For
example:

    #define *name***(***parameter1*[*, parameter2…*]**)**
*definition*

    logging (**on**|**off**)

    Where:

    - #define is a preprocessor directive
    - *name* is the name of a defined symbol.
    - *parameter1* and *parameter2* are macro parameters. The square
brackets indicate that the second parameter is optional. The ellipsis
indicates that the macro accepts more than parameters.
    - logging is an interactive compiler command.
    - **on** and **off** are bold to show that they are literal symbols.
The vertical bar indicates that they are alternative parameters of
the logging command.

The C and C++ compilers are based on the LLVM compiler framework and
are collectively referred to as the LLVM compilers.

Last Published: May 10, 2024

[Next Topic
Get started](https://docs.qualcomm.com/bundle/publicresource/80-VB419-99/topics/get_started.md)