clang: come elencare le architetture di destinazione supportate?

Question

Attualmente mi interessa l'ARM in generale e in particolare i target iphone/android. Ma voglio solo sapere di più su Clang, dal momento che sembra di avere un ruolo importante negli anni a venire.

ho cercato

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) 

So clang ha parametro -triplet, ma come posso elencare tutti i possibili valori per questo? Ho scoperto che clang è molto diverso da gcc rispetto alla cross-compiling, nel mondo GCC dovresti avere un binario separato per tutto, come PLATFORM_make o PLATFORM_ld (i * 86-pc-cygwin i * 86 - * - linux-gnu ecc. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

nel mondo clang, è solo un binario (come ho letto su alcuni forum). Ma come ottengo l'elenco degli obiettivi supportati? E se il mio obiettivo non è supportato sulla mia distro (linux/windows/macos/qualunque) come posso ottenere quello che supporta più piattaforma?

se svn ultima clang come questo:

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

potrò ottenere la maggior parte delle piattaforme? Sembra che Clang non sia stato costruito con la cross-compiling in mente, ma dato che è basato su llvm, dovrebbe essere molto cross-friendly in teoria? grazie!

Answer 1

Sto usando Clang 3.3, penso che il modo migliore per ottenere la risposta sia leggere il codice sorgente. 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 
    }; 

e nel clangore/lib/Driver/ToolChains.cpp, c'è sth su un braccio.

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); 
} 

Answer 2

Non elencherà tutte le triple, ma

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

sarà almeno lista tutte le CPU.

Answer 3

provare

> 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. 
    ... 

Answer 4

Per quanto posso dire Inoltre, non esiste alcuna opzione della riga di comando per elencare quali architetture un dato clang supporti binari, e anche in esecuzione strings su di essa in realtà non Aiuto. Clang è essenzialmente solo un traduttore da C a LLVM, ed è lo stesso LLVM che si occupa del nocciolo della generazione di codice macchina reale, quindi non è del tutto sorprendente che Clang non presti molta attenzione all'architettura sottostante.

Come altri hanno già notato, è possibile chiedere a llc quali architetture supporta. Questo non è molto utile non solo perché questi componenti LLVM potrebbero non essere installati, ma a causa dei capricci dei percorsi di ricerca e dei sistemi di packaging, i tuoi binari llc e clang potrebbero non corrispondere alla stessa versione di LLVM.

Tuttavia, per amor di discussione, diciamo che si è compilato sia LLVM e Clang te o che sei altrimenti felice di accettare i binari LLVM come abbastanza buono:

• llc --version darà un elenco di tutte le architetture supportate. Di default, è compilato per supportare tutte le architetture.Quello che potreste pensare come una singola architettura come ARM può avere diverse architetture LLVM come ARM, Thumb e AArch64 regolari. Ciò è principalmente utile per l'implementazione poiché le diverse modalità di esecuzione hanno codifiche e semantica di istruzioni molto diverse.
• Per ciascuna delle architetture elencate, llc -march=ARCH -mattr=help elencherà "CPU disponibili" e "Funzioni disponibili". Le CPU sono generalmente solo un modo conveniente di impostare una raccolta predefinita di funzionalità.

Ma ora per le cattive notizie. Non esiste una tabella conveniente di triple in Clang o LLVM che può essere scaricata, poiché i back-end specifici dell'architettura hanno l'opzione di analizzare la stringa tripla in un oggetto llvm::Triple (definito in include/llvm/ADT/Triple.h). In altre parole, per scaricare tutte le triple disponibili è necessario risolvere il problema di interruzione. Si veda, ad esempio, llvm::ARM_MC::ParseARMTriple(...) quali casi speciali analizzano la stringa "generic".

In definitiva, la "tripla" è principalmente una funzionalità di retrocompatibilità per rendere Clang una sostituzione drop-in per GCC, quindi in genere non è necessario prestare molta attenzione a meno che non si effettui il porting di Clang o LLVM a una nuova piattaforma o architettura. Invece, sarà probabilmente trovare l'output di llc -march=arm -mattr=help e sbalordire l'enorme serie di diverse funzionalità ARM per essere più utile nelle indagini.

Buona fortuna con la tua ricerca!

Answer 5

Secondo Jonathan Roelofs in questo discorso “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 

Le versioni future di Clang possono disporre quanto segue. Essi sono elencati come "proposta", anche se non ancora disponibile, almeno a partire dal 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 

Answer 6

Un suggerimento che si può fare: se si sta cercando di trovare un obiettivo particolare tripla, è quello di installare LLVM su quel sistema poi fare un

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

o in alternativa:

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

poi si sa come bersaglio quando croce compilazione in ogni caso.

A quanto pare ci sono "un sacco" di obiettivi là fuori, ecco una lista, sentitevi liberi di aggiungere ad essa, lo stile della comunità wiki:

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 

Ecco cosa la lista docs comunque (a quanto pare si tratta di una quadrupla [o quintuplo] invece di una tripla in questi giorni):?

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. 

e si può persino sintonizzare specificare una CPU di destinazione al di là di questo, anche se usa un default ragionevole per la CPU di destinazione in base alla tripla.

rivolge volte "risolvere" per la stessa cosa, in modo da vedere ciò che un obiettivo è in realtà considerato come:

$ clang -target x86_64-w64-mingw32 -v 2>&1 | grep Target 
Target: x86_64-w64-windows-gnu