clang: comment lister les architectures cibles supscopes?

Actuellement, je m’intéresse à ARM en général et spécifiquement aux cibles iphone / android. Mais je veux juste en savoir plus sur le clang, car il a l’impression de jouer un rôle important dans les années à venir.

j’ai essayé

clang -cc1 --help|grep -i list clang -cc1 --help|grep arch|grep -v search clang -cc1 --help|grep target -sortingple  Specify target sortingple (eg i686-apple-darwin9) 

Je sais que clang a le paramètre -sortingplet, mais comment puis-je énumérer toutes les valeurs possibles pour cela? J’ai trouvé que clang est très différent de gcc en ce qui concerne la compilation croisée, dans le monde GCC, vous devriez avoir un binary séparé pour tout, comme PLATFORM_make ou PLATFORM_ld (i * 86-pc-cygwin i * 86 – * – linux-gnu etc. http : //git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS )

dans le monde de clang, ce n’est qu’un binary (comme je l’ai lu sur certains forums). Mais comment puis-je obtenir la liste des cibles sockets en charge? Et si ma cible n’est pas prise en charge sur ma dissortingbution (Linux / Windows / Macos / Peu importe), comment puis-je obtenir celle qui prend en charge davantage de plate-forme?

si je SVN dernière clang comme ceci:

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

vais-je obtenir la plupart des plates-formes? On dirait que Clang n’a pas été conçu avec la compilation en tête tout de suite, mais comme il est basé sur une licence virtuelle, il devrait en théorie être très convivial. Je vous remercie!

Autant que je sache, il n’y a pas d’option de ligne de commande pour lister les architectures clang un clang donné, et même exécuter des ssortingngs dessus n’aide pas vraiment. Clang est essentiellement un traducteur C to LLVM, et c’est LLVM lui-même qui traite des problèmes de génération de code machine, il n’est donc pas surprenant que Clang ne prête pas beaucoup d’attention à l’architecture sous-jacente.

Comme d’autres l’ont déjà noté, vous pouvez demander à llc quelles architectures sont supscopes. Cela n’est pas très utile, non seulement parce que ces composants LLVM ne sont peut-être pas installés, mais en raison des aléas des chemins de recherche et des systèmes de packaging, vos clang binarys llc et clang peuvent ne pas correspondre à la même version de LLVM.

Cependant, pour des raisons d’argument, disons que vous avez compilé LLVM et Clang vous-même ou que vous êtes heureux d’accepter vos fichiers binarys LLVM aussi bien:

  • llc --version donnera une liste de toutes les architectures supscopes. Par défaut, il est compilé pour prendre en charge toutes les architectures. Ce que vous pouvez penser comme une architecture unique, telle que ARM, peut avoir plusieurs architectures LLVM telles que ARM, Thumb et AArch64. Ceci est principalement pour faciliter la mise en œuvre car les différents modes d’exécution ont des codages d’instructions et des sémantiques très différents.
  • Pour chacune des architectures répertoriées, llc -march=ARCH -mattr=help répertorie les “CPU disponibles” et les “fonctionnalités disponibles”. Les processeurs ne sont généralement qu’un moyen pratique de définir une collection de fonctionnalités par défaut.

Mais maintenant pour les mauvaises nouvelles. Il n’y a pas de tableau pratique des sortingplets dans Clang ou LLVM qui peuvent être sauvegardés, car les backends spécifiques à l’architecture ont la possibilité d’parsingr la chaîne sortingple dans un object llvm::Triple (défini dans include / llvm / ADT / Triple.h ) . En d’autres termes, pour supprimer tous les sortingples disponibles, vous devez résoudre le problème de la mise en veille. Voir, par exemple, llvm::ARM_MC::ParseARMTriple(...) quels cas spéciaux analysant la chaîne "generic" .

En fin de compte, cependant, le “sortingple” est surtout une fonctionnalité de compatibilité ascendante pour faire de Clang un remplacement instantané pour GCC, vous n’avez donc généralement pas besoin d’y porter beaucoup d’attention à moins de porter Clang ou LLVM sur une nouvelle plate-forme ou architecture. Au lieu de cela, vous trouverez probablement la sortie de llc -march=arm -mattr=help et étonnant à l’énorme éventail de fonctionnalités ARM pour être plus utile dans vos investigations.

Bonne chance dans vos recherches!

J’utilise Clang 3.3, je pense que la meilleure façon d’obtenir la réponse est de lire le code source. dans 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 }; 

et dans clang / lib / Driver / ToolChains.cpp, il y a sth sur le arm.

 static const char *GetArmArchForMArch(SsortingngRef Value) { return llvm::SsortingngSwitch(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(SsortingngRef Value) { return llvm::SsortingngSwitch(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); } 

Selon Jonathan Roelofs, dans cet exposé, «Quelles sont les cibles que soutient Clang?» :

 $ 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 

Les futures versions de Clang peuvent fournir les éléments suivants. Ils sont répertoriés comme “proposés” mais pas encore disponibles au moins à partir de la version 3.9.0:

 $ clang -target  --print-multi-libs $ clang -print-supported-archs $ clang -march x86 -print-supported-systems $ clang -march x86 -print-available-systems 

Un conseil que vous pouvez faire: si vous essayez de trouver un sortingple cible particulier, c’est d’installer llvm sur ce système, puis

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

Ou bien:

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

Ensuite, vous savez comment le cibler lors de la compilation croisée.

Apparemment, il y a “beaucoup” de cibles, voici une liste, n’hésitez pas à y append le style wiki de la communauté:

 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 

Voici ce que la liste de documents de toute façon (apparemment c’est un quadruple [ou quintuple?] Au lieu d’un sortingple ces jours-ci):

 The sortingple has the general format ---, 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. 

et vous pouvez même affiner la spécification d’un processeur cible au-delà, bien qu’il utilise une valeur par défaut sensible pour le processeur cible basé sur le sortingple.

Parfois, les cibles «se résolvent» à la même chose, afin de voir ce que la cible est réellement traitée comme:

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

Essayez aussi

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

Il ne listera pas tous les sortingples, mais

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

va au moins lister tous les processeurs.