clang: làm thế nào để liệt kê các kiến ​​trúc mục tiêu được hỗ trợ?

Hiện tại tôi quan tâm đến ARM nói chung và mục tiêu cụ thể là iphone / android. Nhưng tôi chỉ muốn biết thêm về clang, vì nó cảm thấy nó đóng vai trò quan trọng trong những năm tới.

Tôi đã thử

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)

Tôi biết clang có tham số -triplet, nhưng làm cách nào để liệt kê tất cả các giá trị có thể có cho nó? Tôi thấy rằng clang rất khác với gcc liên quan đến việc biên dịch chéo, trong thế giới GCC, bạn nên có tệp nhị phân riêng biệt cho mọi thứ, như PLATFORM_make hoặc PLATFORM_ld (i * 86-pc-cygwin i * 86 - * - linux-gnu, v.v. http : //git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS )

trong thế giới clang, nó chỉ là một nhị phân (như tôi đã đọc trên một số diễn đàn). Nhưng làm cách nào để lấy danh sách các mục tiêu được hỗ trợ? Và nếu mục tiêu của tôi nó không được hỗ trợ trên bản phân phối của tôi (linux / windows / macos / bất cứ thứ gì) thì làm cách nào tôi có thể lấy bản phân phối hỗ trợ nhiều nền tảng hơn?

if I SVN tiếng kêu mới nhất như thế này:

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

tôi sẽ nhận được hầu hết các nền tảng? Có vẻ như Clang không được xây dựng với tính năng biên dịch chéo ngay lập tức, nhưng vì nó dựa trên llvm nên về lý thuyết, nó rất thân thiện với nhau? cảm ơn bạn!

Theo như tôi có thể nói, không có tùy chọn dòng lệnh nào để liệt kê kiến ​​trúc nào clanghỗ trợ nhị phân nhất định và thậm chí chạy stringstrên nó cũng không thực sự hữu ích. Về cơ bản, Clang chỉ là một trình biên dịch từ C sang LLVM và bản thân LLVM xử lý vấn đề phức tạp của việc tạo mã máy thực tế, vì vậy không hoàn toàn ngạc nhiên khi Clang không chú ý nhiều đến kiến ​​trúc cơ bản.

Như những người khác đã lưu ý, bạn có thể hỏi llcnó hỗ trợ kiến ​​trúc nào. Tất cả điều này không hữu ích không chỉ vì các thành phần LLVM này có thể không được cài đặt, mà vì sự khác biệt của đường dẫn tìm kiếm và hệ thống đóng gói, mã nhị phân llcvà của bạn clangcó thể không tương ứng với cùng một phiên bản LLVM.

Tuy nhiên, để tranh luận, giả sử rằng bạn đã tự mình biên soạn cả LLVM và Clang hoặc rằng bạn vui lòng chấp nhận các tệp nhị phân LLVM của mình là đủ tốt:

• llc --versionsẽ đưa ra danh sách tất cả các kiến ​​trúc mà nó hỗ trợ. Theo mặc định, nó được biên dịch để hỗ trợ tất cả các kiến ​​trúc. Những gì bạn có thể nghĩ về một kiến ​​trúc đơn lẻ như ARM có thể có một số kiến ​​trúc LLVM như ARM thông thường, Thumb và AArch64. Điều này chủ yếu là để thuận tiện cho việc triển khai bởi vì các chế độ thực thi khác nhau có mã hóa lệnh và ngữ nghĩa rất khác nhau.
• Đối với mỗi kiến ​​trúc được liệt kê, llc -march=ARCH -mattr=helpsẽ liệt kê "các CPU khả dụng" và "các tính năng khả dụng". Các CPU nói chung chỉ là một cách thuận tiện để thiết lập một bộ sưu tập các tính năng mặc định.

Nhưng bây giờ cho tin xấu. Không có bảng bộ ba thuận tiện nào trong Clang hoặc LLVM có thể được kết xuất, bởi vì các phụ trợ dành riêng cho kiến ​​trúc có tùy chọn phân tích cú pháp chuỗi bộ ba thành một llvm::Tripleđối tượng (được định nghĩa trong include / llvm / ADT / Triple.h ). Nói cách khác, để kết xuất tất cả các bộ ba có sẵn đòi hỏi phải giải quyết Vấn đề Tạm dừng. Ví dụ, hãy llvm::ARM_MC::ParseARMTriple(...)xem những trường hợp đặc biệt nào phân tích chuỗi "generic".

Tuy nhiên, cuối cùng thì "bộ ba" chủ yếu là một tính năng tương thích ngược để làm cho Clang trở thành một phần thay thế cho GCC, vì vậy bạn thường không cần quan tâm nhiều đến nó trừ khi bạn đang chuyển Clang hoặc LLVM sang một nền tảng mới hoặc kiến ​​trúc. Thay vào đó, bạn có thể sẽ tìm thấy đầu ra của llc -march=arm -mattr=helpvà kết hợp với một loạt các tính năng ARM khác nhau để hữu ích hơn trong các cuộc điều tra của bạn.

Chúc may mắn với nghiên cứu của bạn!

Tôi đang sử dụng Clang 3.3, tôi nghĩ rằng cách tốt nhất để nhận được câu trả lời là đọc mã nguồn. trong 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
  };

và trong clang / lib / Driver / ToolChains.cpp, có sth về 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);
}

Một gợi ý bạn có thể làm: nếu bạn đang cố gắng tìm một bộ ba mục tiêu cụ thể, là cài đặt llvm trên hệ thống đó sau đó thực hiện

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

Hay cách khác:

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

Sau đó, bạn biết cách nhắm mục tiêu nó khi biên dịch chéo.

Rõ ràng là có rất nhiều mục tiêu ở đó, đây là danh sách, vui lòng thêm vào nó, phong cách wiki cộng đồng:

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

Đây là những gì danh sách tài liệu dù sao (dường như nó là một phần tư [hoặc phần năm?] Thay vì ba lần như ngày nay):

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.

và bạn thậm chí có thể tinh chỉnh chỉ định một cpu mục tiêu ngoài mức này, mặc dù nó sử dụng một mặc định hợp lý cho cpu mục tiêu dựa trên bộ ba.

Đôi khi các mục tiêu "giải quyết" cùng một thứ, vì vậy, để xem mục tiêu thực sự được coi là gì:

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

Theo Jonathan Roelofs trong buổi nói chuyện này “Clang hỗ trợ những mục tiêu nào?” :

$ 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

Các phiên bản tương lai của Clang có thể cung cấp những điều sau đây. Chúng được liệt kê là "được đề xuất" mặc dù chưa có sẵn ít nhất là từ phiên bản 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 

Cũng cố gắng

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

Nó sẽ không liệt kê tất cả các bộ ba, nhưng

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

ít nhất sẽ liệt kê tất cả các CPU.

Bắt đầu Clang 11 (thân cây), danh sách các kiến ​​trúc đích được hỗ trợ có thể được in thủ công bằng cách sử dụng -print-targetscờ mới được thêm vào :

$ 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

Tài liệu tham khảo: LLVM PR , LLVM cam kết , tài liệu Clang 11 .

Trong trường hợp bạn quan tâm đến mục tiêu nào được hỗ trợ để xây dựng LLVM hoặc Clang từ nguồn (các giá trị cho -DLLVM_TARGETS_TO_BUILD), hãy tìm danh sách các thư mục con trong llvm/lib/Targetthư mục trong phân phối nguồn. Kể từ ngày 9.0.1 có:

AArch64
AMDGPU
ARC
ARM
AVR
BPF
Hexagon
Lanai
MSP430
Mips
NVPTX
PowerPC
RISCV
Sparc
SystemZ
WebAssembly
X86