Come compilare Clang su Windows

Come compilare Clang su Windows

Ho cercato di trovare un modo per far funzionare Clang su Windows, ma ho problemi. Faccio in modo che Clang compili correttamente, ma quando provo a compilare un programma ho un sacco di errori nelle intestazioni standard.

Sono a conoscenza delle eccellenti versioni predefinite di clang di rubenvb, ma voglio compilarlo da solo. Stavo anche ascoltando i discorsi di GoingNative sul clang che dicevano che non aveva ancora un ottimo supporto per Windows. Come posso far funzionare il clang su Windows?

Risposte:

Ho usato il seguente metodo per compilare clang per C++ su Windows 7 ed è stato convalidato da Mysticial e altri:

Scarica e installa MinGW (assicurati di installare il compilatore C++) e metti la cartella bin nel tuo PATH (ho MinGW 4.6.1 e testato con successo su un altro computer con 4.6.2)

Assicurati di avere Python nel tuo PERCORSO (non 3 , ho 2.7)

(Facoltativo:assicurati di avere Perl nel PERCORSO (ho usato ActivePerl 5.14.2 64-bit))

Ottieni CMake e inseriscilo nel tuo PERCORSO

Vai alla pagina dei download di LLVM e scarica il codice sorgente di LLVM 3.0 insieme al codice sorgente di Clang. Non ottenere il codice dall'SVN, non funziona con le intestazioni MinGW.

Estrai i codici sorgente; Avevo il sorgente llvm in una cartella denominata llvm-3.0.src sul mio desktop

Metti il sorgente del clang direttamente in una cartella chiamata "clang" (deve essere chiamato esattamente così o compilerai llvm ma clang non verrà compilato) nella cartella "tools" all'interno della cartella del sorgente llvm, questo dovrebbe rendere le tue directory assomigliano a:
- fonte llvm
  - cartella autoconf
  - ...
  - cartella strumenti
    - ...
    - cartella clang
      - cartella binding
      - ...
      - File di creazione
      - ...
    - ...
  - ...

Crea una cartella denominata "build" nella stessa directory della cartella di origine llvm

Apri una riga di comando e cd nella cartella build

Esegui il comando cmake -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release ..\llvm-3.0.src
- (l'ultimo argomento è il percorso relativo alla cartella che contiene il sorgente llvm (e il sorgente clang nella sottodirectory tools/clang))
- Questo farà l'equivalente di un comando "configure" e i makefile e tutto il resto verranno generati nella cartella build
- Ci vorranno alcuni minuti

Esegui il comando mingw32-make
- Questo compilerà llvm e clang e gli eseguibili clang verranno generati nella cartella build/bin
- Ci vorrà probabilmente molto tempo. (Puoi provare a velocizzarlo aggiungendo build parallele, -j<number> opzione) Potrebbe essere utile chiudere tutti gli altri programmi in modo che il computer possa concentrarsi, in modo che non interferiscano con il lungo processo di compilazione, come bloccare una cartella in cui il compilatore sta scrivendo (è successo a me ). Ho persino disattivato il mio software antivirus e firewall in modo che non tentassero di scansionare i file generati e si intromettessero.

È ora di provarlo

Crea un file .cpp nella cartella build/bin (Userò hello.cpp). Utilizzare un'intestazione di libreria standard per assicurarsi che i percorsi di inclusione e le librerie funzionino. Inizia con un programma molto semplice.

(Con cosa ho iniziato:
```
#include <iostream>
 int main() {
     std::cout << "hi";
 }
 
```
)

Esegui il comando clang hello.cpp -std=c++0x -I"C:\MinGW\lib\gcc\mingw32\4.6.1\include\c++" -I"C:\MinGW\lib\gcc\mingw32\4.6.1\include\c++\mingw32" -Lc:/mingw/bin/../lib/gcc/mingw32/4.6.1 -Lc:/mingw/bin/../lib/gcc -Lc:/mingw/bin/../lib/gcc/mingw32/4.6.1/../../../../mingw32/lib -Lc:/mingw/bin/../lib/gcc/mingw32/4.6.1/../../.. -L/mingw/lib -lstdc++ -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt

(-L specifica una directory in cui cercare le librerie e -l specifica una libreria da collegare)
(Se MinGW non è installato nel mio stesso percorso, puoi scoprire i percorsi con il comando "g++ somefile.cpp -v" per fare in modo che g++ spieghi quali opzioni sta usando per i percorsi della libreria e i file della libreria e tutto il resto
Cerca verso la fine dell'output per le opzioni -L e -l . Fai attenzione ai nomi dei file .o che sono intervallati dalle -L. Clang usa molte delle stesse opzioni di g++ quindi ho letteralmente copiato e incollato quella riga dall'output di g++)

Questo dovrebbe compilare il tuo programma e produrre un file chiamato a.out

rinomina a.out in a.exe o altro

Esegui il file .exe

Il tuo programma dovrebbe essere eseguito.

Clang (3.0) ha ancora alcuni problemi su Windows (non so se questi problemi sono anche su Linux). Ad esempio, la compilazione di un lambda (che clang non supporta) con -std=c++0x causerà l'arresto anomalo di clang e verrà generato un errore diagnostico.
(sono stato informato sull'IRC LLVM che ciò è dovuto al clang implementa l'analisi per le lambda ma non l'analisi semantica, che è la fase in cui si arresta in modo anomalo (perché si sono dimenticati di disabilitare l'analisi delle lambda per la versione 3.0) e già conoscono questo bug)

Inoltre, l'illustre Mistico ha gentilmente acconsentito a testare questa guida e ha fatto alcune osservazioni durante i suoi test:

Le intestazioni di Windows sembrano funzionare.

Attualmente funziona solo a 32 bit.

64-bit si compila bene, ma non si assembla.

SSE probabilmente va bene. ([Mysticial non ha] testato un SSE funzionante su 32 bit.)

Alcune risposte al codice

 $ cat t.c #include <stdio.h>
int main(int argc, char **argv) { printf("hello world\n");
} $ clang t.c $ ./a.out hello world

 $ cat ~/t.c typedef float V __attribute__((vector_size(16)));
V foo(V a, V b) { return a+b*a;
}

 $ clang ~/t.c -E # 1 "/Users/sabre/t.c" 1  typedef float V __attribute__((vector_size(16)));
 V foo(V a, V b) { return a+b*a;
}

 $ clang -fsyntax-only ~/t.c

 $ clang -fsyntax-only ~/t.c -pedantic /Users/sabre/t.c:2:17: warning: extension used typedef float V __attribute__((vector_size(16)));     ^ 1 diagnostic generated.

 $ clang -cc1 ~/t.c -ast-print typedef float V __attribute__(( vector_size(16) ));
V foo(V a, V b) {    return a + b * a;
}

 $ clang ~/t.c -S -emit-llvm -o - define <4 x float>
@foo(<4 x float>
%a, <4 x float>
%b) { entry:
   %mul = mul <4 x float>
%b, %a
   %add = add <4 x float>
%mul, %a
   ret <4 x float>
%add } $ clang -fomit-frame-pointer -O3 -S -o - t.c # On x86_64 ... _foo: Leh_func_begin1: 	mulps	%xmm0, %xmm1 	addps	%xmm1, %xmm0 	ret Leh_func_end1: