Clang: Wie Liste unterstützte Zielarchitekturen?

Question

Momentan interessiere ich mich für ARM im Allgemeinen und speziell für iPhone/Android-Ziele. Aber ich will nur mehr über Klänge wissen, da es sich in den kommenden Jahren als wichtig erweist.

Ich versuchte

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) 

Ich weiß Klirren -triplet Parameter hat, aber wie kann ich eine Liste aller möglichen Werte für das? Ich fand, dass clang in Bezug auf Cross-Compiling sehr unterschiedlich zu gcc ist, in GCC world sollte man separate binary für alles haben, wie PLATFORM_make oder PLATFORM_ld (i * 86-pc-cygwin i * 86 - * - linux-gnu etc. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

in Clang Welt, es ist nur eine Binärdatei (wie ich in einigen Foren gelesen). Aber wie bekomme ich die Liste der unterstützten Ziele? Und wenn mein Ziel auf meiner Distribution nicht unterstützt wird (linux/windows/macos/was auch immer), wie bekomme ich dann den, der mehr Plattform unterstützt?

wenn ich letzte Klirren wie dieses SVN:

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

werde ich die meisten Plattformen bekommen? Es sieht so aus, als ob Clang nicht sofort mit Cross-Compiling erstellt wurde, aber da es basiert, sollte es in der Theorie sehr freundlich sein. Danke!

Answer 1

Ich benutze Clang 3.3, ich denke, der beste Weg, um die Antwort zu bekommen, ist das Lesen des Quellcodes. 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 
    }; 

und Klappern in/lib/Driver/ToolChains.cpp, gibt es über etw 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); 
} 

Answer 2

Es wird nicht alle Tripel Liste, aber

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

mindestens Liste alle CPUs.

Answer 3

Händler

> 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

So weit ich das beurteilen kann, gibt es keine Befehlszeilenoption zur Liste, welche clang binäre unterstützt eine gegebene Architekturen und sogar laufen strings auf sie nicht wirklich Hilfe. Clang ist im Wesentlichen nur ein C-LLVM-Übersetzer, und LLVM selbst beschäftigt sich mit der Notwendigkeit, tatsächlichen Maschinencode zu erzeugen. Daher ist es nicht völlig überraschend, dass Clang der zugrundeliegenden Architektur nicht viel Aufmerksamkeit schenkt.

Wie andere bereits bemerkt haben, können Sie llc fragen, welche Architekturen es unterstützt. Dies ist nicht gerade hilfreich, nicht nur weil diese LLVM-Komponenten möglicherweise nicht installiert sind, sondern aufgrund der Launen von Suchpfaden und Verpackungssystemen Ihre llc und clang Binaries möglicherweise nicht der gleichen Version von LLVM entsprechen.

jedoch aus Gründen der Argumentation, lassen Sie uns sagen, dass Sie zusammengestellt beide LLVM und Clang selbst oder dass Sie sonst zufrieden sind Ihre LLVM Binärdateien so gut genug, um zu akzeptieren:

• llc --version eine Liste geben wird von alle Architekturen, die es unterstützt. Standardmäßig wird es kompiliert, um alle Architekturen zu unterstützen.Was Sie sich als eine einzelne Architektur wie ARM vorstellen können, kann mehrere LLVM-Architekturen wie reguläre ARM, Thumb und AArch64 haben. Dies dient hauptsächlich der praktischen Umsetzung, da die verschiedenen Ausführungsmodi sehr unterschiedliche Befehlskodierungen und Semantiken haben.
• Für jede der aufgelisteten Architekturen werden llc -march=ARCH -mattr=help "verfügbare CPUs" und "verfügbare Funktionen" aufgelistet. Die CPUs sind im Allgemeinen nur eine bequeme Möglichkeit zum Festlegen einer Standardfunktionssammlung.

Aber jetzt für die schlechten Nachrichten. Es gibt keine praktische Tripel-Tabelle in Clang oder LLVM, die ausgegeben werden kann, weil die architekturspezifischen Backends die Option haben, die Tripel-Zeichenfolge in ein llvm::Triple-Objekt zu analysieren (definiert in include/llvm/ADT/Triple.h). Mit anderen Worten, um alle verfügbaren Tripel abzulegen, muss das Halteproblem gelöst werden. Siehe zum Beispiel llvm::ARM_MC::ParseARMTriple(...) welche Sonderfälle die Zeichenfolge "generic" analysieren. Das "Triple" ist jedoch hauptsächlich eine Abwärtskompatibilität, die Clang zu einem Drop-In-Ersatz für GCC macht. Daher müssen Sie im Allgemeinen nicht viel Aufmerksamkeit darauf richten, es sei denn, Sie portieren Clang oder LLVM zu einer neuen Plattform oder Architektur. Stattdessen werden Sie wahrscheinlich die Ausgabe von llc -march=arm -mattr=help finden und bei der großen Anzahl von verschiedenen ARM-Funktionen herumfliegen, um bei Ihren Untersuchungen nützlicher zu sein.

Viel Glück bei Ihrer Recherche!

Answer 5

Laut Jonathan Roelofs in diesem Vortrag “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 

Zukünftige Versionen von Clang können die folgenden Angaben enthalten. Sie werden als „vorgeschlagen“ aufgeführt, obwohl noch nicht verfügbar zumindest von 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

Ein Hinweis Sie tun können: wenn Sie versuchen, ein bestimmtes Ziel triple zu finden, llvm zu installieren ist auf diesem System dann tut ein

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

oder alternativ:

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

dann wissen Sie, wie es zum Ziel, wenn Quer ohnehin kompilieren.

Offenbar gibt es „viele“ von Zielen gibt, hier ist eine Liste, um es hinzuzufügen frei fühlen, Community Wiki-Stil:

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 

Hier ist, was die docs Liste sowieso (anscheinend ist es ein vervierfachen [oder verfünffachen] statt einem dreifachen diese Tage):

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. 

und Sie können sogar eine Feinabstimmung ein Ziel-CPU darüber hinaus angeben, ob es eine sinnvolle Vorgabe für den Ziel-CPU auf der triple-basierte verwendet.

Ziele Manchmal „Entschlossenheit“ auf dasselbe hinaus, so zu sehen, was ein Ziel tatsächlich so behandelt wird:

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