134

Currently I am interested in ARM in general and specifically iPhone/Android targets. But I just want to know more about clang, since it feels to play important role in the years to come.

I tried

clang -cc1 --help|grep -i list
clang -cc1 --help|grep arch|grep -v search
clang -cc1 --help|grep target

 -triple <value>         Specify target triple (e.g. i686-apple-darwin9)

I know clang has -triplet parameter, but how can I list all possible values for it?

I found that clang is very different to gcc in respect to cross compiling, in GCC world you should have separate binary for everything, like PLATFORM_make or PLATFORM_ld (i*86-pc-cygwin i*86-*-linux-gnu etc. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

In clang world, it's only one binary (as I read on some forums). But how do I get the list of supported targets? And if my target it not supported on my distro (Linux/Windows/macOS/whatever) how can I get the one that supports more platform?

If I SVN latest clang like this:

svn co http://llvm.org/svn/llvm-project/cfe/trunk clang

will I get most of platforms?

It looks like Clang was not built with cross compiling in mind right away, but since it's LLVM-based it should be very cross-friendly in theory?

phuclv
  • 37,963
  • 15
  • 156
  • 475
exebook
  • 32,014
  • 33
  • 141
  • 226
  • 9
    not a complete answer but llc --version will give you the targets – old_timer Feb 23 '13 at 04:13
  • 1
    I think you'll have to look at the source to see the triples. And as I understand it a default build of clang will include basic support for cross compiling. Basic support only turns code into object files (as long as the integrated assembler supports the triple, otherwise you'll have to take .s files). You'll have to supply headers, libraries, a linker (until lld works, anyway), etc. – bames53 Feb 23 '13 at 04:15
  • 1
    Although the default installation only has clang and clang++ executables, like other platforms you can create copies or hardlinks of them with the triples and quads encoded in the names. clang++ and clang are actually just copies of each other it checks the name of the executable to see how to process input. – LB-- Jun 06 '13 at 13:31
  • 1
    Related - [Which targets does Clang support?](https://llvm.org/devmtg/2014-04/PDFs/LightningTalks/2014-3-31_ClangTargetSupport_LighteningTalk.pdf). – Royi Apr 09 '18 at 07:44

14 Answers14

72

So far as I can tell, there is no command-line option to list which architectures a given clang binary supports, and even running strings on it doesn't really help. Clang is essentially just a C to LLVM translator, and it's LLVM itself that deals with the nitty-gritty of generating actual machine code, so it's not entirely surprising that Clang isn't paying much attention to the underlying architecture.

As others have already noted, you can ask llc which architectures it supports. This isn't all that helpful not just because these LLVM components might not be installed, but because of the vagaries of search paths and packaging systems, your llc and clang binaries may not correspond to the same version of LLVM.

However, for the sake of argument, let's say that you compiled both LLVM and Clang yourself or that you're otherwise happy to accept your LLVM binaries as good enough:

  • llc --version will give a list of all architectures it supports. By default, it is compiled to support all architectures. What you may think of as a single architecture such as ARM may have several LLVM architectures such as regular ARM, Thumb and AArch64. This is mainly for implementation convenience because the different execution modes have very different instruction encodings and semantics.
  • For each of the architectures listed, llc -march=ARCH -mattr=help will list "available CPUs" and "available features". The CPUs are generally just a convenient way of setting a default collection of features.

But now for the bad news. There is no convenient table of triples in Clang or LLVM that can be dumped, because the architecture-specific backends have the option of parsing the triple string into an llvm::Triple object (defined in include/llvm/ADT/Triple.h). In other words, to dump all available triples requires solving the Halting Problem. See, for example, llvm::ARM_MC::ParseARMTriple(...) which special-cases parsing the string "generic".

Ultimately, though, the "triple" is mostly a backwards-compatibility feature to make Clang a drop-in replacement for GCC, so you generally don't need to pay much attention to it unless you are porting Clang or LLVM to a new platform or architecture. Instead, you will probably find the output of llc -march=arm -mattr=help and boggling at the huge array of different ARM features to be more useful in your investigations.

Good luck with your research!

ljleb
  • 182
  • 1
  • 14
pndc
  • 3,710
  • 2
  • 23
  • 34
47

Starting Clang 11 (trunk), the list of supported target architectures could be handily printed using the newly added -print-targets flag:

$ clang-11 -print-targets
  Registered Targets:
    aarch64    - AArch64 (little endian)
    aarch64_32 - AArch64 (little endian ILP32)
    aarch64_be - AArch64 (big endian)
    amdgcn     - AMD GCN GPUs
    arm        - ARM
    arm64      - ARM64 (little endian)
    arm64_32   - ARM64 (little endian ILP32)
    armeb      - ARM (big endian)
    avr        - Atmel AVR Microcontroller
    bpf        - BPF (host endian)
    bpfeb      - BPF (big endian)
    bpfel      - BPF (little endian)
    hexagon    - Hexagon
    lanai      - Lanai
    mips       - MIPS (32-bit big endian)
    mips64     - MIPS (64-bit big endian)
    mips64el   - MIPS (64-bit little endian)
    mipsel     - MIPS (32-bit little endian)
    msp430     - MSP430 [experimental]
    nvptx      - NVIDIA PTX 32-bit
    nvptx64    - NVIDIA PTX 64-bit
    ppc32      - PowerPC 32
    ppc64      - PowerPC 64
    ppc64le    - PowerPC 64 LE
    r600       - AMD GPUs HD2XXX-HD6XXX
    riscv32    - 32-bit RISC-V
    riscv64    - 64-bit RISC-V
    sparc      - Sparc
    sparcel    - Sparc LE
    sparcv9    - Sparc V9
    systemz    - SystemZ
    thumb      - Thumb
    thumbeb    - Thumb (big endian)
    wasm32     - WebAssembly 32-bit
    wasm64     - WebAssembly 64-bit
    x86        - 32-bit X86: Pentium-Pro and above
    x86-64     - 64-bit X86: EM64T and AMD64
    xcore      - XCore

References: LLVM PR, LLVM commit, Clang 11 documentation.

valiano
  • 16,433
  • 7
  • 64
  • 79
41

I am using Clang 3.3, I think the best way to get the answer is reading the source code.
in llvm/ADT/Triple.h (http://llvm.org/doxygen/Triple_8h_source.html):

enum ArchType {
  UnknownArch,

  arm,     // ARM: arm, armv.*, xscale
  aarch64, // AArch64: aarch64
  hexagon, // Hexagon: hexagon
  mips,    // MIPS: mips, mipsallegrex
  mipsel,  // MIPSEL: mipsel, mipsallegrexel
  mips64,  // MIPS64: mips64
  mips64el,// MIPS64EL: mips64el
  msp430,  // MSP430: msp430
  ppc,     // PPC: powerpc
  ppc64,   // PPC64: powerpc64, ppu
  r600,    // R600: AMD GPUs HD2XXX - HD6XXX
  sparc,   // Sparc: sparc
  sparcv9, // Sparcv9: Sparcv9
  systemz, // SystemZ: s390x
  tce,     // TCE (http://tce.cs.tut.fi/): tce
  thumb,   // Thumb: thumb, thumbv.*
  x86,     // X86: i[3-9]86
  x86_64,  // X86-64: amd64, x86_64
  xcore,   // XCore: xcore
  mblaze,  // MBlaze: mblaze
  nvptx,   // NVPTX: 32-bit
  nvptx64, // NVPTX: 64-bit
  le32,    // le32: generic little-endian 32-bit CPU (PNaCl / Emscripten)
  amdil,   // amdil: amd IL
  spir,    // SPIR: standard portable IR for OpenCL 32-bit version
  spir64   // SPIR: standard portable IR for OpenCL 64-bit version
};

and in clang/lib/Driver/ToolChains.cpp , there is sth about arm.

static const char *GetArmArchForMArch(StringRef Value) {
  return llvm::StringSwitch<const char*>(Value)
    .Case("armv6k", "armv6")
    .Case("armv6m", "armv6m")
    .Case("armv5tej", "armv5")
    .Case("xscale", "xscale")
    .Case("armv4t", "armv4t")
    .Case("armv7", "armv7")
    .Cases("armv7a", "armv7-a", "armv7")
    .Cases("armv7r", "armv7-r", "armv7")
    .Cases("armv7em", "armv7e-m", "armv7em")
    .Cases("armv7f", "armv7-f", "armv7f")
    .Cases("armv7k", "armv7-k", "armv7k")
    .Cases("armv7m", "armv7-m", "armv7m")
    .Cases("armv7s", "armv7-s", "armv7s")
    .Default(0);
}

static const char *GetArmArchForMCpu(StringRef Value) {
  return llvm::StringSwitch<const char *>(Value)
    .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
    .Cases("arm10e", "arm10tdmi", "armv5")
    .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
    .Case("xscale", "xscale")
    .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "arm1176jzf-s", "armv6")
    .Case("cortex-m0", "armv6m")
    .Cases("cortex-a8", "cortex-r4", "cortex-a9", "cortex-a15", "armv7")
    .Case("cortex-a9-mp", "armv7f")
    .Case("cortex-m3", "armv7m")
    .Case("cortex-m4", "armv7em")
    .Case("swift", "armv7s")
    .Default(0);
}
phuclv
  • 37,963
  • 15
  • 156
  • 475
a'Q
  • 455
  • 4
  • 3
  • 8
    what about second and third parts of the Triple? – osgx Feb 04 '14 at 22:54
  • And actual parser of Arch name into ArchType is in http://code.metager.de/source/xref/llvm/llvm/lib/Support/Triple.cpp#221 - llvm/lib/Support/Triple.cpp function `static Triple::ArchType parseArch(StringRef ArchName)` – osgx Feb 04 '14 at 23:05
  • The clang binary being available doesn't mean the user compiled it from source. – Colin LeMahieu May 28 '15 at 03:18
  • 2
    Some descriptions of clang's targets and triples: http://llvm.org/devmtg/2014-04/PDFs/LightningTalks/2014-3-31_ClangTargetSupport_LighteningTalk.pdf, proposed in 2014: "Target Triple: ---; --print-supported-archs --print-supported-vendors --print-supported-systems --print-supported-abis --print-multi-libs --print-available-targets" and http://clang.llvm.org/UniversalDriver.html – osgx Jun 11 '17 at 00:25
23

One hint you can do: if you're trying to find a particular target triple, is to install llvm on that system then do a 

$ llc --version | grep Default
  Default target: x86_64-apple-darwin16.1.0

or alternatively:

$ llvm-config --host-target
x86_64-apple-darwin16.0.0
or
$ clang -v 2>&1 | grep Target
Target: x86_64-apple-darwin16.1.0

Then you know how to target it when cross compiling anyway.

Apparently there are "lots" of targets out there, here's a list, feel free to add to it, community wiki style:

arm-none-eabi
armv7a-none-eabi
arm-linux-gnueabihf 
arm-none-linux-gnueabi
i386-pc-linux-gnu 
x86_64-apple-darwin10
i686-w64-windows-gnu # same as i686-w64-mingw32
x86_64-pc-linux-gnu # from ubuntu 64 bit
x86_64-unknown-windows-cygnus # cygwin 64-bit
x86_64-w64-windows-gnu # same as x86_64-w64-mingw32
i686-pc-windows-gnu # MSVC
x86_64-pc-windows-gnu # MSVC 64-BIT

Here's what the docs list anyway (apparently it's a quadruple [or quintuple?] instead of a triple these days):

The triple has the general format <arch><sub>-<vendor>-<sys>-<abi>, where:
arch = x86, arm, thumb, mips, etc.
sub = for ex. on ARM: v5, v6m, v7a, v7m, etc.
vendor = pc, apple, nvidia, ibm, etc.
sys = none, linux, win32, darwin, cuda, etc.
abi = eabi, gnu, android, macho, elf, etc.

and you can even fine tune specify a target cpu beyond this, though it uses a sensible default for the target cpu based on the triple.

Sometimes targets "resolve" to the same thing, so to see what a target is actually treated as:

 $ clang -target x86_64-w64-mingw32 -v 2>&1 | grep Target
 Target: x86_64-w64-windows-gnu
rogerdpack
  • 62,887
  • 36
  • 269
  • 388
15

According to Jonathan Roelofs in this talk “Which targets does Clang support?”:

$ llc --version
LLVM (http://llvm.org/):
  LLVM version 3.6.0
  Optimized build with assertions.
  Built Apr  2 2015 (01:25:22).
  Default target: x86_64-apple-darwin12.6.0
  Host CPU: corei7-avx

  Registered Targets:
    aarch64    - AArch64 (little endian)
    aarch64_be - AArch64 (big endian)
    amdgcn     - AMD GCN GPUs
    arm        - ARM
    arm64      - ARM64 (little endian)
    armeb      - ARM (big endian)
    cpp        - C++ backend
    hexagon    - Hexagon
    mips       - Mips
    mips64     - Mips64 [experimental]
    mips64el   - Mips64el [experimental]
    mipsel     - Mipsel
    msp430     - MSP430 [experimental]
    nvptx      - NVIDIA PTX 32-bit
    nvptx64    - NVIDIA PTX 64-bit
    ppc32      - PowerPC 32
    ppc64      - PowerPC 64
    ppc64le    - PowerPC 64 LE
    r600       - AMD GPUs HD2XXX-HD6XXX
    sparc      - Sparc
    sparcv9    - Sparc V9
    systemz    - SystemZ
    thumb      - Thumb
    thumbeb    - Thumb (big endian)
    x86        - 32-bit X86: Pentium-Pro and above
    x86-64     - 64-bit X86: EM64T and AMD64
    xcore      - XCore

Future versions of Clang may provide the following. They are listed as "proposed" though not yet available at least as of v 3.9.0:

$ clang -target <target_from_list_above> --print-multi-libs
$ clang -print-supported-archs
$ clang -march x86 -print-supported-systems 
$ clang -march x86 -print-available-systems
rogerdpack
  • 62,887
  • 36
  • 269
  • 388
jww
  • 97,681
  • 90
  • 411
  • 885
7

Also try

> llc -mattr=help

Available CPUs for this target:

  amdfam10      - Select the amdfam10 processor.
  athlon        - Select the athlon processor.
  athlon-4      - Select the athlon-4 processor.
  athlon-fx     - Select the athlon-fx processor.
  athlon-mp     - Select the athlon-mp processor.
  athlon-tbird  - Select the athlon-tbird processor.
  athlon-xp     - Select the athlon-xp processor.
  athlon64      - Select the athlon64 processor.
  athlon64-sse3 - Select the athlon64-sse3 processor.
  atom          - Select the atom processor.
  ...
Available features for this target:

  16bit-mode           - 16-bit mode (i8086).
  32bit-mode           - 32-bit mode (80386).
  3dnow                - Enable 3DNow! instructions.
  3dnowa               - Enable 3DNow! Athlon instructions.
  64bit                - Support 64-bit instructions.
  64bit-mode           - 64-bit mode (x86_64).
  adx                  - Support ADX instructions.
  ...
Zinovy Nis
  • 455
  • 6
  • 9
  • 6
    clang being available doesn't mean llc is available. – Colin LeMahieu May 28 '15 at 03:17
  • 1
    seems llc is commonly installed along with clang, however...and you can install it if not from your package manager and and it should line up, I'd guess...however this list appears to be if you want to target a specific cpu, not necessarily a different "triple" architecture, as the OP wanted... – rogerdpack Nov 30 '16 at 13:36
  • 5
    To list options for other architectures, you can use the `-mtriple` option as in `llc -mtriple=arm -mattr=help`. – Lekensteyn Feb 10 '17 at 10:53
  • llc: error: : error: unable to get target for 'unknown', see --version and --triple. – Max Base Jan 08 '21 at 13:48
  • use `$ llc --version` – Max Base Jan 08 '21 at 13:48
3

It won't list all the triples, but

llvm-as < /dev/null | llc -mcpu=help

will at least list all the CPUs.

bcmills
  • 4,391
  • 24
  • 34
3

In case you are interested in which targets are supported for building LLVM or Clang from source (the values for -DLLVM_TARGETS_TO_BUILD), look for the list of subdirectories in llvm/lib/Target folder in source distribution. As of 9.0.1 there are:

AArch64
AMDGPU
ARC
ARM
AVR
BPF
Hexagon
Lanai
MSP430
Mips
NVPTX
PowerPC
RISCV
Sparc
SystemZ
WebAssembly
X86
scrutari
  • 1,378
  • 2
  • 17
  • 33
3

clang -march=dont-know empty.c

error: unknown target CPU 'dont-know'

note: valid target CPU values are: nocona, core2, penryn, bonnell, atom, silvermont, slm, goldmont, goldmont-plus, tremont, nehalem, corei7, westmere, sandybridge, corei7-avx, ivybridge, core-avx-i, haswell, core-avx2, broadwell, skylake, skylake-avx512, skx, cascadelake, cooperlake, cannonlake, icelake-client, icelake-server, tigerlake, knl, knm, k8, athlon64, athlon-fx, opteron, k8-sse3, athlon64-sse3, opteron-sse3, amdfam10, barcelona, btver1, btver2, bdver1, bdver2, bdver3, bdver4, znver1, znver2, x86-64

DTharun
  • 746
  • 7
  • 16
  • No longer, at least with Apple clang version 14.0.0 (clang-1400.0.29.102): “clang: error: the clang compiler does not support '-march=dont-know'” – Flash Sheridan Nov 15 '22 at 22:41
  • It is working with opensource latest clang-16, don't know about Apple clang. – DTharun Nov 16 '22 at 09:17
3
$ aarch64-linux-android30-clang++ -print-targets
  Registered Targets:
    aarch64    - AArch64 (little endian)
    aarch64_32 - AArch64 (little endian ILP32)
    aarch64_be - AArch64 (big endian)
    arm        - ARM
    arm64      - ARM64 (little endian)
    arm64_32   - ARM64 (little endian ILP32)
    armeb      - ARM (big endian)
    bpf        - BPF (host endian)
    bpfeb      - BPF (big endian)
    bpfel      - BPF (little endian)
    thumb      - Thumb
    thumbeb    - Thumb (big endian)
    x86        - 32-bit X86: Pentium-Pro and above
    x86-64     - 64-bit X86: EM64T and AMD64

$ aarch64-linux-android30-clang++ -print-supported-cpus
Android (8490178, based on r450784d) clang version 14.0.6 (https://android.googlesource.com/toolchain/llvm-project 4c603efb0cca074e9238af8b4106c30add4418f6)
Target: aarch64-unknown-linux-android30
Thread model: posix
InstalledDir: /opt/android-ndk-r25b/toolchains/llvm/prebuilt/linux-x86_64/bin
Available CPUs for this target:

        a64fx
        apple-a10
        apple-a11
        apple-a12
        apple-a13
        apple-a14
        apple-a7
        apple-a8
        apple-a9
        apple-latest
        apple-m1
        apple-s4
        apple-s5
        carmel
        cortex-a34
        cortex-a35
        cortex-a510
        cortex-a53
        cortex-a55
        cortex-a57
        cortex-a65
        cortex-a65ae
        cortex-a710
        cortex-a72
        cortex-a73
        cortex-a75
        cortex-a76
        cortex-a76ae
        cortex-a77
        cortex-a78
        cortex-a78c
        cortex-r82
        cortex-x1
        cortex-x2
        cyclone
        exynos-m3
        exynos-m4
        exynos-m5
        falkor
        generic
        kryo
        neoverse-512tvb
        neoverse-e1
        neoverse-n1
        neoverse-n2
        neoverse-v1
        saphira
        thunderx
        thunderx2t99
        thunderx3t110
        thunderxt81
        thunderxt83
        thunderxt88
        tsv110
Zibri
  • 9,096
  • 3
  • 52
  • 44
2

I don't know a way to get all the available triple with standard clang or llc commands. The closest is llc -mtriple=ARCH -mattr=help from
Lekensteyn's comment but it doesn't work. It just prints a huge list of CPUs and features

However if you have rust then it's easy to do using rustc --print target-list. Currently I'm seeing a list of 181 different triplets

$ rustc --print target-list | column
aarch64-apple-darwin                    aarch64_be-unknown-linux-gnu            armv7-unknown-linux-uclibceabi          i686-pc-windows-msvc                    mipsel-unknown-linux-uclibc             riscv32gc-unknown-linux-gnu             thumbv7em-none-eabi                     x86_64-pc-windows-msvc
aarch64-apple-ios                       aarch64_be-unknown-linux-gnu_ilp32      armv7-unknown-linux-uclibceabihf        i686-unknown-freebsd                    mipsel-unknown-none                     riscv32gc-unknown-linux-musl            thumbv7em-none-eabihf                   x86_64-sun-solaris
aarch64-apple-ios-macabi                arm-linux-androideabi                   armv7-unknown-netbsd-eabihf             i686-unknown-haiku                      mipsisa32r6-unknown-linux-gnu           riscv32i-unknown-none-elf               thumbv7m-none-eabi                      x86_64-unknown-dragonfly
aarch64-apple-ios-sim                   arm-unknown-linux-gnueabi               armv7-wrs-vxworks-eabihf                i686-unknown-linux-gnu                  mipsisa32r6el-unknown-linux-gnu         riscv32im-unknown-none-elf              thumbv7neon-linux-androideabi           x86_64-unknown-freebsd
aarch64-apple-tvos                      arm-unknown-linux-gnueabihf             armv7a-kmc-solid_asp3-eabi              i686-unknown-linux-musl                 mipsisa64r6-unknown-linux-gnuabi64      riscv32imac-unknown-none-elf            thumbv7neon-unknown-linux-gnueabihf     x86_64-unknown-haiku
aarch64-fuchsia                         arm-unknown-linux-musleabi              armv7a-kmc-solid_asp3-eabihf            i686-unknown-netbsd                     mipsisa64r6el-unknown-linux-gnuabi64    riscv32imc-esp-espidf                   thumbv7neon-unknown-linux-musleabihf    x86_64-unknown-hermit
aarch64-kmc-solid_asp3                  arm-unknown-linux-musleabihf            armv7a-none-eabi                        i686-unknown-openbsd                    msp430-none-elf                         riscv32imc-unknown-none-elf             thumbv8m.base-none-eabi                 x86_64-unknown-illumos
aarch64-linux-android                   armebv7r-none-eabi                      armv7a-none-eabihf                      i686-unknown-uefi                       nvptx64-nvidia-cuda                     riscv64gc-unknown-freebsd               thumbv8m.main-none-eabi                 x86_64-unknown-l4re-uclibc
aarch64-pc-windows-gnullvm              armebv7r-none-eabihf                    armv7r-none-eabi                        i686-uwp-windows-gnu                    powerpc-unknown-freebsd                 riscv64gc-unknown-linux-gnu             thumbv8m.main-none-eabihf               x86_64-unknown-linux-gnu
aarch64-pc-windows-msvc                 armv4t-unknown-linux-gnueabi            armv7r-none-eabihf                      i686-uwp-windows-msvc                   powerpc-unknown-linux-gnu               riscv64gc-unknown-linux-musl            wasm32-unknown-emscripten               x86_64-unknown-linux-gnux32
aarch64-unknown-freebsd                 armv5te-unknown-linux-gnueabi           armv7s-apple-ios                        i686-wrs-vxworks                        powerpc-unknown-linux-gnuspe            riscv64gc-unknown-none-elf              wasm32-unknown-unknown                  x86_64-unknown-linux-musl
aarch64-unknown-hermit                  armv5te-unknown-linux-musleabi          asmjs-unknown-emscripten                m68k-unknown-linux-gnu                  powerpc-unknown-linux-musl              riscv64imac-unknown-none-elf            wasm32-wasi                             x86_64-unknown-netbsd
aarch64-unknown-linux-gnu               armv5te-unknown-linux-uclibceabi        avr-unknown-gnu-atmega328               mips-unknown-linux-gnu                  powerpc-unknown-netbsd                  s390x-unknown-linux-gnu                 wasm64-unknown-unknown                  x86_64-unknown-none
aarch64-unknown-linux-gnu_ilp32         armv6-unknown-freebsd                   bpfeb-unknown-none                      mips-unknown-linux-musl                 powerpc-unknown-openbsd                 s390x-unknown-linux-musl                x86_64-apple-darwin                     x86_64-unknown-none-linuxkernel
aarch64-unknown-linux-musl              armv6-unknown-netbsd-eabihf             bpfel-unknown-none                      mips-unknown-linux-uclibc               powerpc-wrs-vxworks                     sparc-unknown-linux-gnu                 x86_64-apple-ios                        x86_64-unknown-openbsd
aarch64-unknown-netbsd                  armv6k-nintendo-3ds                     hexagon-unknown-linux-musl              mips64-openwrt-linux-musl               powerpc-wrs-vxworks-spe                 sparc64-unknown-linux-gnu               x86_64-apple-ios-macabi                 x86_64-unknown-redox
aarch64-unknown-none                    armv7-apple-ios                         i386-apple-ios                          mips64-unknown-linux-gnuabi64           powerpc64-unknown-freebsd               sparc64-unknown-netbsd                  x86_64-apple-tvos                       x86_64-unknown-uefi
aarch64-unknown-none-softfloat          armv7-linux-androideabi                 i586-pc-windows-msvc                    mips64-unknown-linux-muslabi64          powerpc64-unknown-linux-gnu             sparc64-unknown-openbsd                 x86_64-fortanix-unknown-sgx             x86_64-uwp-windows-gnu
aarch64-unknown-openbsd                 armv7-unknown-freebsd                   i586-unknown-linux-gnu                  mips64el-unknown-linux-gnuabi64         powerpc64-unknown-linux-musl            sparcv9-sun-solaris                     x86_64-fuchsia                          x86_64-uwp-windows-msvc
aarch64-unknown-redox                   armv7-unknown-linux-gnueabi             i586-unknown-linux-musl                 mips64el-unknown-linux-muslabi64        powerpc64-wrs-vxworks                   thumbv4t-none-eabi                      x86_64-linux-android                    x86_64-wrs-vxworks
aarch64-unknown-uefi                    armv7-unknown-linux-gnueabihf           i686-apple-darwin                       mipsel-sony-psp                         powerpc64le-unknown-freebsd             thumbv6m-none-eabi                      x86_64-pc-solaris
aarch64-uwp-windows-msvc                armv7-unknown-linux-musleabi            i686-linux-android                      mipsel-unknown-linux-gnu                powerpc64le-unknown-linux-gnu           thumbv7a-pc-windows-msvc                x86_64-pc-windows-gnu
aarch64-wrs-vxworks                     armv7-unknown-linux-musleabihf          i686-pc-windows-gnu                     mipsel-unknown-linux-musl               powerpc64le-unknown-linux-musl          thumbv7a-uwp-windows-msvc               x86_64-pc-windows-gnullvm

You can also use rustup target list to print all the triples that rustup supports

$ rustup target list | column
aarch64-apple-darwin                    arm-unknown-linux-gnueabi               armv7-unknown-linux-musleabi            i686-pc-windows-msvc                    mipsel-unknown-linux-musl               s390x-unknown-linux-gnu                 thumbv8m.main-none-eabihf               x86_64-pc-windows-msvc
aarch64-apple-ios                       arm-unknown-linux-gnueabihf             armv7-unknown-linux-musleabihf          i686-unknown-freebsd                    nvptx64-nvidia-cuda                     sparc64-unknown-linux-gnu               wasm32-unknown-emscripten               x86_64-sun-solaris
aarch64-apple-ios-sim                   arm-unknown-linux-musleabi              armv7a-none-eabi                        i686-unknown-linux-gnu                  powerpc-unknown-linux-gnu               sparcv9-sun-solaris                     wasm32-unknown-unknown                  x86_64-unknown-freebsd
aarch64-fuchsia                         arm-unknown-linux-musleabihf            armv7r-none-eabi                        i686-unknown-linux-musl                 powerpc64-unknown-linux-gnu             thumbv6m-none-eabi                      wasm32-wasi                             x86_64-unknown-illumos
aarch64-linux-android                   armebv7r-none-eabi                      armv7r-none-eabihf                      mips-unknown-linux-gnu                  powerpc64le-unknown-linux-gnu           thumbv7em-none-eabi                     x86_64-apple-darwin (installed)         x86_64-unknown-linux-gnu
aarch64-pc-windows-msvc                 armebv7r-none-eabihf                    asmjs-unknown-emscripten                mips-unknown-linux-musl                 riscv32i-unknown-none-elf               thumbv7em-none-eabihf                   x86_64-apple-ios                        x86_64-unknown-linux-gnux32
aarch64-unknown-linux-gnu               armv5te-unknown-linux-gnueabi           i586-pc-windows-msvc                    mips64-unknown-linux-gnuabi64           riscv32imac-unknown-none-elf            thumbv7m-none-eabi                      x86_64-fortanix-unknown-sgx             x86_64-unknown-linux-musl
aarch64-unknown-linux-musl              armv5te-unknown-linux-musleabi          i586-unknown-linux-gnu                  mips64-unknown-linux-muslabi64          riscv32imc-unknown-none-elf             thumbv7neon-linux-androideabi           x86_64-fuchsia                          x86_64-unknown-netbsd
aarch64-unknown-none                    armv7-linux-androideabi                 i586-unknown-linux-musl                 mips64el-unknown-linux-gnuabi64         riscv64gc-unknown-linux-gnu             thumbv7neon-unknown-linux-gnueabihf     x86_64-linux-android                    x86_64-unknown-none
aarch64-unknown-none-softfloat          armv7-unknown-linux-gnueabi             i686-linux-android                      mips64el-unknown-linux-muslabi64        riscv64gc-unknown-none-elf              thumbv8m.base-none-eabi                 x86_64-pc-solaris                       x86_64-unknown-redox
arm-linux-androideabi                   armv7-unknown-linux-gnueabihf           i686-pc-windows-gnu                     mipsel-unknown-linux-gnu                riscv64imac-unknown-none-elf            thumbv8m.main-none-eabi                 x86_64-pc-windows-gnu
phuclv
  • 37,963
  • 15
  • 156
  • 475
1

For those that ended up here looking to see if their specific x86 CPU family architecture has a target for llvm/clang optimisation (.e.g: zen3, zen1, skylake, penryn, etc)

You can view the list underneath or run this:

$ llc -march=x86 -mattr=help
Available CPUs for this target:

  alderlake      - Select the alderlake processor.
  amdfam10       - Select the amdfam10 processor.
  athlon         - Select the athlon processor.
  athlon-4       - Select the athlon-4 processor.
  athlon-fx      - Select the athlon-fx processor.
  athlon-mp      - Select the athlon-mp processor.
  athlon-tbird   - Select the athlon-tbird processor.
  athlon-xp      - Select the athlon-xp processor.
  athlon64       - Select the athlon64 processor.
  athlon64-sse3  - Select the athlon64-sse3 processor.
  atom           - Select the atom processor.
  barcelona      - Select the barcelona processor.
  bdver1         - Select the bdver1 processor.
  bdver2         - Select the bdver2 processor.
  bdver3         - Select the bdver3 processor.
  bdver4         - Select the bdver4 processor.
  bonnell        - Select the bonnell processor.
  broadwell      - Select the broadwell processor.
  btver1         - Select the btver1 processor.
  btver2         - Select the btver2 processor.
  c3             - Select the c3 processor.
  c3-2           - Select the c3-2 processor.
  cannonlake     - Select the cannonlake processor.
  cascadelake    - Select the cascadelake processor.
  cooperlake     - Select the cooperlake processor.
  core-avx-i     - Select the core-avx-i processor.
  core-avx2      - Select the core-avx2 processor.
  core2          - Select the core2 processor.
  corei7         - Select the corei7 processor.
  corei7-avx     - Select the corei7-avx processor.
  generic        - Select the generic processor.
  geode          - Select the geode processor.
  goldmont       - Select the goldmont processor.
  goldmont-plus  - Select the goldmont-plus processor.
  haswell        - Select the haswell processor.
  i386           - Select the i386 processor.
  i486           - Select the i486 processor.
  i586           - Select the i586 processor.
  i686           - Select the i686 processor.
  icelake-client - Select the icelake-client processor.
  icelake-server - Select the icelake-server processor.
  ivybridge      - Select the ivybridge processor.
  k6             - Select the k6 processor.
  k6-2           - Select the k6-2 processor.
  k6-3           - Select the k6-3 processor.
  k8             - Select the k8 processor.
  k8-sse3        - Select the k8-sse3 processor.
  knl            - Select the knl processor.
  knm            - Select the knm processor.
  lakemont       - Select the lakemont processor.
  nehalem        - Select the nehalem processor.
  nocona         - Select the nocona processor.
  opteron        - Select the opteron processor.
  opteron-sse3   - Select the opteron-sse3 processor.
  penryn         - Select the penryn processor.
  pentium        - Select the pentium processor.
  pentium-m      - Select the pentium-m processor.
  pentium-mmx    - Select the pentium-mmx processor.
  pentium2       - Select the pentium2 processor.
  pentium3       - Select the pentium3 processor.
  pentium3m      - Select the pentium3m processor.
  pentium4       - Select the pentium4 processor.
  pentium4m      - Select the pentium4m processor.
  pentiumpro     - Select the pentiumpro processor.
  prescott       - Select the prescott processor.
  rocketlake     - Select the rocketlake processor.
  sandybridge    - Select the sandybridge processor.
  sapphirerapids - Select the sapphirerapids processor.
  silvermont     - Select the silvermont processor.
  skx            - Select the skx processor.
  skylake        - Select the skylake processor.
  skylake-avx512 - Select the skylake-avx512 processor.
  slm            - Select the slm processor.
  tigerlake      - Select the tigerlake processor.
  tremont        - Select the tremont processor.
  westmere       - Select the westmere processor.
  winchip-c6     - Select the winchip-c6 processor.
  winchip2       - Select the winchip2 processor.
  x86-64         - Select the x86-64 processor.
  x86-64-v2      - Select the x86-64-v2 processor.
  x86-64-v3      - Select the x86-64-v3 processor.
  x86-64-v4      - Select the x86-64-v4 processor.
  yonah          - Select the yonah processor.
  znver1         - Select the znver1 processor.
  znver2         - Select the znver2 processor.
  znver3         - Select the znver3 processor.

The list above is current as of llvm-13

To run the above you need llvm installed at least and to get the same results as above you need llvm-13 at least.

DanglingPointer
  • 891
  • 1
  • 5
  • 12
  • the question is about listing all `-triplet`s or at least all the architectures, not x86 micro architectures – phuclv Mar 13 '23 at 00:21
1

For those interested in CPUs to tune for, you can use --print-supported-cpus (added here). If your clang binary can compile for more than one architecture, you have to pass --target as well to select the proper architecture; for instance, to list the ARM CPUs available on the Android cross compiler, you could use --target=aarch64-unknown-linux-gui.

swineone
  • 2,296
  • 1
  • 18
  • 32
0

Only the first one (CPU architecture) need to be exact, other parameters are processed in a smart and complex way, you can use "clang++ ... --verbose ..." to see the processed result, for example:

Command Line Input      After triple processing
x86_64                  x86_64
x86_64-foo              x86_64-foo
x86_64-windows          x86_64-unknown-windows-msvc19.28.29335
x86_64-windows-bar      x86_64-unknown-windows-msvc19.28.29335
x86_64-foo-windows-bar  x86_64-foo-windows-msvc19.28.29335
x86_64-foo-bar-foobar   x86_64-foo-bar-foobar

Commonly the parameters except the first one will only have effect when they are right (after the triple proceesing process which may make a wrong one right smartly), for example, "windows" will effect the code:

/// Tests whether the OS is Windows.
bool isOSWindows() const {
    return getOS() == Triple::Win32;
}

This method is used by other code in Clang/LLVM to affect the compiled result, it only return true when the parameter is "windows" and will return false if it is any other thing such as "foo".

jw_
  • 1,663
  • 18
  • 32