clang: jak wyświetlić obsługiwane architektury docelowe?

Question

Obecnie interesuję się ARM w ogólności, a konkretnie celami dla urządzeń iPhone/Android. Ale chcę wiedzieć więcej o klangu, ponieważ w nadchodzących latach ma on ważną rolę.

Próbowałem

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) 

wiem dzyń ma -triplet parametr, ale jak mogę wymienić wszystkie możliwe wartości dla tego? Zauważyłem, że klang różni się bardzo od gcc pod względem kompilacji krzyżowej, w świecie GCC powinieneś mieć oddzielne binarne dla wszystkiego, jak PLATFORM_make lub PLATFORM_ld (i * 86-pc-cygwin i * 86 - * - linux-gnu itp. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

w świecie klang, to tylko jeden plik binarny (jak czytam na niektórych forach). Ale jak uzyskać listę obsługiwanych celów? A jeśli mój cel nie jest obsługiwany w mojej dystrybucji (linux/windows/macos/cokolwiek), jak mogę uzyskać ten, który obsługuje więcej platform?

gdybym SVN najnowszą szczęk tak:

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

będę się większość platform? Wygląda na to, że Clang nie został zbudowany z myślą o kompilacji krzyżowej, ale ponieważ jest oparty na technologii LVV, powinien być bardzo przyjazny dla teorii w teorii? Dziękuję Ci!

Answer 1

Używam Clang 3.3, myślę, że najlepszym sposobem uzyskania odpowiedzi jest czytanie kodu źródłowego. w llvm/TSP/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 
    }; 

szczęk i/lib/sterownika/ToolChains.cpp istnieje s-o ramię.

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

Nie będzie lista wszystkich trójek, ale

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

będzie przynajmniej lista wszystkich procesorów.

Answer 3

także spróbować

> 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

jakim mogę powiedzieć, nie ma opcji wiersza poleceń do listy architektur, które obsługuje dana clang binarnych, a nawet działa strings na to nie ma Wsparcie. Clang jest po prostu translatorem C na LLVM, a sam LLVM zajmuje się czystością kodu generującego rzeczywisty kod maszynowy, więc nie jest całkowicie zaskakujące, że Clang nie przywiązuje zbytniej wagi do architektury bazowej.

Jak już inni zauważyli, można poprosić o numer llc, który to architektura obsługuje. Nie jest to wcale pomocne, nie tylko ze względu na to, że te komponenty LLVM mogą nie być zainstalowane, ale ze względu na kaprysy ścieżek wyszukiwania i systemów pakowania, pliki binarne llc i clang mogą nie odpowiadać tej samej wersji LLVM.

Jednak przez wzgląd na argument, powiedzmy, że skompilowany zarówno LLVM i Clang siebie lub, że jesteś inaczej chętnie zaakceptować pliki binarne LLVM jak wystarczająco dobre: ​​

• llc --version dadzą listę wszystkie architektury, które obsługuje. Domyślnie jest skompilowany do obsługi wszystkich architektur.To, co możesz uważać za jedną architekturę, taką jak ARM, może mieć kilka architektur LLVM, takich jak zwykłe ARM, Thumb i AArch64. Dotyczy to głównie wygody implementacji, ponieważ różne tryby wykonania mają bardzo różne kodowania instrukcji i semantykę.
• Dla każdej z wymienionych architektur, llc -march=ARCH -mattr=help wyświetli listę "dostępnych procesorów" i "dostępnych funkcji". Procesory są zwykle wygodnym sposobem na ustawienie domyślnego zbioru funkcji.

Ale teraz zła wiadomość. Nie ma wygodnej tabeli trójek w Clang lub LLVM, które można zrzucać, ponieważ backend specyficzny dla architektury ma opcję parsowania potrójnego ciągu znaków do obiektu llvm::Triple (zdefiniowanego w include/llvm/ADT/Triple.h). Innymi słowy, zrzucenie wszystkich dostępnych potrójnych wymaga rozwiązania problemu zatrzymania. Zobacz na przykład: llvm::ARM_MC::ParseARMTriple(...), w której przypadki specjalne analizowane są za pomocą ciągu znaków "generic".

Ostatecznie "potrójny" jest głównie funkcją kompatybilności wstecznej, która sprawia, że ​​Clang zastępuje zamiennik GCC, więc na ogół nie musisz zwracać na to uwagi, chyba że przenosisz Clang lub LLVM do nowej platformy lub architektury. Zamiast tego najprawdopodobniej znajdziesz wyjście llc -march=arm -mattr=help i zadziwisz się ogromnym zestawem różnych funkcji ARM, aby być bardziej użytecznym w twoich badaniach.

Życzymy powodzenia w badaniach!

Answer 5

Według Jonathana Roelofs w tej rozmowie “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 

Przyszłe wersje Clang może dostarczyć następujące. Są one wymienione jako „proponowane”, choć nie są jeszcze dostępne przynajmniej na 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

Jedna wskazówka można zrobić: jeśli starasz się znaleźć konkretny cel potrójne, jest zainstalowanie LLVM w tym systemie następnie zrobić

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

lub alternatywnie:

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

wtedy wiesz, jak je kierować, gdy krzyż kompilacji tak.

Podobno istnieje „wiele” tarcz tam, oto lista, nie krępuj się dodać do niego styl 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 

Oto co lista docs mimo to (podobno jest to poczwórne [lub Pięcioosobowy] zamiast potrójnego te dni):

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. 

i można nawet dostroić określić cpu docelową poza tym, mimo że używa sensownego domyślne dla procesora docelowego w oparciu o potrójne.

Czasami cele „determinację” do tej samej rzeczy, tak aby zobaczyć, co się celem jest faktycznie traktowane jako:

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