FileCheck-3.6 - Online în cloud

PROGRAM:

NUME

FileCheck - Verificator de fișiere flexibil de potrivire a modelelor

REZUMAT

FileCheck potrivire-nume fișier [--check-prefix=XXX] [--strict-spațiu alb]

DESCRIERE

FileCheck citește două fișiere (unul de la intrarea standard și unul specificat pe linia de comandă)
și folosește unul pentru a verifica celălalt. Acest comportament este deosebit de util pentru testsuite,
care dorește să verifice că rezultatul unui instrument (de ex llc) conține așteptatul
informații (de exemplu, un movsd de la esp sau orice este interesant). Acest lucru este similar
la utilizarea grep, dar este optimizat pentru potrivirea mai multor intrări diferite într-un singur fișier într-un
ordine specifică.

potrivire-nume fișier fisierul specifica fisierul care contine modelele de potrivire. Fișierul
pentru a verifica este citit de la intrarea standard, cu excepția cazului în care --fișier de intrare este folosită opțiunea.

OPŢIUNI

-Ajutor Tipăriți un rezumat al opțiunilor liniei de comandă.

--verifica-prefix prefix
FileCheck caută conținutul potrivire-nume fișier pentru ca modelele să se potrivească. De
implicit, aceste modele sunt prefixate cu „VERIFICA:". Dacă doriți să utilizați un
prefix diferit (de exemplu, deoarece același fișier de intrare verifică mai multe
instrument sau opțiuni), the --verifica-prefix argument vă permite să specificați unul sau mai multe
prefixe care să se potrivească. Prefixele multiple sunt utile pentru testele care se pot schimba pentru
opțiuni de rulare diferite, dar majoritatea liniilor rămân aceleași.

--fișier de intrare nume de fișier
Fișier de verificat (implicit la stdin).

--strict-spațiu alb
În mod implicit, FileCheck canonizează spațiul alb orizontal de intrare (spații și file)
ceea ce o face să ignore aceste diferențe (un spațiu se va potrivi cu o filă). The
--strict-spațiu alb argumentul dezactivează acest comportament. Secvențele de sfârșit de linie sunt
canonizat în stil UNIX \n în toate modurile.

--implicit-verificare-nu model de check
Adaugă verificări negative implicite pentru modelele specificate între verificările pozitive.
Opțiunea permite scrierea de teste mai stricte fără a le umple VERIFICA-NUs.

De exemplu, "--implicit-verificare-nu avertizare:" poate fi util atunci când se testează diagnosticul
mesaje de la instrumente care nu au o opțiune similară cu zăngăni -verifica. Cu asta
opțiunea FileCheck va verifica dacă intrarea nu conține avertismente care nu sunt acoperite de
Orice VERIFICA: modele.

-versiune
Afișați numărul versiunii acestui program.

EXIT STAREA

If FileCheck verifică dacă fișierul se potrivește cu conținutul așteptat, iese cu 0.
În caz contrar, dacă nu, sau dacă apare o eroare, acesta va ieși cu o valoare diferită de zero.

TUTORIAL

FileCheck este folosit de obicei din testele de regresie LLVM, fiind invocat pe linia RUN a
testul. Un exemplu simplu de utilizare a FileCheck dintr-o linie RUN arată astfel:

; RUN: llvm-as < %s | llc -march=x86-64 | Verificați fișierul %s

Această sintaxă spune să conductați fișierul curent ("%s") în llvm-as, conductă asta în llc, Apoi
conducta de iesire a llc în FileCheck. Aceasta înseamnă că FileCheck își va verifica
intrare standard (ieșirea llc) față de argumentul numelui fișierului specificat (original .ll
fișier specificat de „%s"). Pentru a vedea cum funcționează, să ne uităm la restul .ll fişier
(după linia RUN):

defineste void @sub1(i32* %p, i32 %v) {
intrare:
; VERIFICARE: sub1:
; VERIFICARE: subl
%0 = apel de coadă i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
ret vid
}

define void @inc4(i64* %p) {
intrare:
; VERIFICARE: inc4:
; VERIFICARE: incq
%0 = apel de coadă i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
ret vid
}

Aici puteți vedea câteva "VERIFICA:" linii specificate în comentarii. Acum puteți vedea cum este fișierul
este introdus în llvm-as, Apoi llc, iar rezultatul codului de mașină este ceea ce verificăm.
FileCheck verifică rezultatul codului mașinii pentru a verifica dacă se potrivește cu ce „VERIFICA:" linii
specifica.

Sintaxa lui "VERIFICA:" liniile este foarte simplu: sunt șiruri fixe care trebuie să apară în
Ordin. FileCheck ignoră implicit diferențele de spații albe orizontale (de exemplu, un spațiu este
permis să se potrivească cu o filă), dar în caz contrar, conținutul „VERIFICA:" este necesară linia pentru
potrivește exact ceva din fișierul de testare.

Un lucru bun despre FileCheck (comparativ cu grep) este că permite îmbinarea cazurilor de testare
împreună în grupuri logice. De exemplu, pentru că testul de mai sus verifică
"sub1:"Şi"inc4:" etichete, nu se va potrivi decât dacă există un "subl„între acestea
etichete. Dacă ar exista în altă parte în fișier, asta nu ar conta: "grep subl"
se potrivește dacă "subl" există oriunde în fișier.

FileCheck -verifica-prefix opțiune
FileCheck -verifica-prefix opțiunea permite controlul din mai multe configurații de testare
unu .ll fişier. Acest lucru este util în multe circumstanțe, de exemplu, testarea diferită
variante arhitecturale cu llc. Iată un exemplu simplu:

; RUN: llvm-as < %s | llc -mtriple=i686-apple-darwin9 -mattr=sse41 \
; RUN: | FileCheck %s -check-prefix=X32
; RUN: llvm-as < %s | llc -mtriple=x86_64-apple-darwin9 -mattr=sse41 \
; RUN: | FileCheck %s -check-prefix=X64

definește <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) substantiv {
%tmp1 = element de inserare <4 x i32>; %tmp, i32 %s, i32 1
ret <4 x i32> %tmp1
; X32: pinsrd_1:
; X32: pinsrd $1, 4(%esp), %xmm0

; X64: pinsrd_1:
; X64: pinsrd $1, %edi, %xmm0
}

În acest caz, testăm că obținem generarea de cod așteptată atât cu 32 de biți, cât și cu
Generarea codului pe 64 de biți.

VERIFICAȚI-URMĂTORUL: directivă
Uneori doriți să potriviți linii și doriți să verificați dacă potrivirile au loc exact
linii consecutive fără alte linii între ele. În acest caz, puteți folosi „VERIFICA:"
și "VERIFICAȚI-URMĂTORUL:" directive pentru a specifica acest lucru. Dacă ați specificat un prefix de verificare personalizat,
foloseste doar "-URMĂTORUL:". De exemplu, ceva de genul acesta funcționează așa cum v-ați aștepta:

defineste void @t2(<2 x dublu>* %r, <2 x dublu>* %A, dublu %B) {
%tmp3 = încărcare <2 x dublu>* %A, aliniați 16
%tmp7 = element de inserare <2 x dublu> undef, dublu %B, i32 0
%tmp9 = shufflevector <2 x dublu> %tmp3,
<2 x dublu> %tmp7,
<2 x i32> < i32 0, i32 2 >
stocați <2 x dublu> %tmp9, <2 x dublu>* %r, aliniați 16
ret vid

; VERIFICARE: t2:
; VERIFICARE: movl 8(%esp), %eax
; VERIFICAȚI-URMĂTOR: movapd (%eax), %xmm0
; VERIFICAȚI-URMĂTOR: movhpd 12(%esp), %xmm0
; VERIFICARE-URMĂTOR: movl 4(%esp), %eax
; VERIFICAȚI-URMĂTOR: movapd %xmm0, (%eax)
; VERIFICARE-URMĂTOR: ret
}

"VERIFICAȚI-URMĂTORUL:„directivele resping intrarea, cu excepția cazului în care există exact o linie nouă între ea
și directiva anterioară. A "VERIFICAȚI-URMĂTORUL:„ nu poate fi prima directivă dintr-un fișier.

VERIFICAȚI-NU: directivă
"VERIFICAȚI-NU:Directiva " este folosită pentru a verifica dacă un șir nu apare între două
meciuri (sau înainte de primul meci, sau după ultimul meci). De exemplu, pentru a verifica asta
o sarcină este îndepărtată printr-o transformare, se poate folosi un test ca acesta:

definește i8 @coerce_offset0(i32 %V, i32* %P) {
stocați i32 %V, i32* %P

%P2 = bitcast i32* %P la i8*
%P3 = getelementptr i8* %P2, i32 2

%A = sarcina i8* %P3
ret i8 %A
; VERIFICAȚI: @coerce_offset0
; VERIFICARE-NU: încărcare
; VERIFICARE: ret i8
}

CHECK-DAG: directivă
Dacă este necesar să se potrivească șirurile care nu apar într-o ordine strict secvențială,
"CHECK-DAG:" ar putea fi folosit pentru a le verifica între două meciuri (sau înainte de primul meci,
sau după ultimul meci). De exemplu, clang emite global vtable în ordine inversă. Folosind
CHECK-DAG:, putem păstra verificările în ordinea firească:

// RUN: %clang_cc1 %s -emit-llvm -o - | Verificați fișierul %s

struct Foo { virtual void method(); };
Foo f; // emit vtable
// CHECK-DAG: @_ZTV3Foo =

struct Bar { virtual void method(); };
Ghimpe;
// CHECK-DAG: @_ZTV3Bar =

VERIFICAȚI-NU: directivele ar putea fi amestecate cu CHECK-DAG: directive pentru a exclude șiruri între
împrejurimile CHECK-DAG: directive. Ca urmare, împrejurimile CHECK-DAG: instrucțiuni
nu poate fi reordonat, adică toate aparițiile se potrivesc CHECK-DAG: înainte VERIFICAȚI-NU: nu trebuie să
rămâne în urmă cu potrivirea ocurențelor CHECK-DAG: după VERIFICAȚI-NU:. De exemplu,

; CHECK-DAG: ÎNAINTE
; VERIFICAȚI-NU: NU
; CHECK-DAG: DUPĂ

Acest caz va respinge șirurile de intrare unde INAINTE DE apare după DUPA.

Cu variabilele capturate, CHECK-DAG: este capabil să se potrivească ordinelor topologice valide ale unui DAG
cu muchii de la definirea unei variabile până la utilizarea acesteia. Este util, de exemplu, atunci când dvs
cazurile de testare trebuie să se potrivească cu diferite secvențe de ieșire din programatorul de instrucțiuni. Pentru
exemplu,

; CHECK-DAG: adăugați [[REG1:r[0-9]+]], r1, r2
; CHECK-DAG: adăugați [[REG2:r[0-9]+]], r3, r4
; VERIFICAȚI: mul r5, [[REG1]], [[REG2]]

În acest caz, orice ordine a celor doi adăuga vor fi permise instrucțiuni.

Dacă definiți și folosind variabile în același CHECK-DAG: bloc, fiți conștient de faptul că
regula de definiție se poate potrivi după utilizarea sa.

Deci, de exemplu, codul de mai jos va trece:

; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
; CHECK-DAG: vmov.32 [[REG2]][1]
vmov.32 d0[1]
vmov.32 d0[0]

În timp ce acest alt cod, nu va:

; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
; CHECK-DAG: vmov.32 [[REG2]][1]
vmov.32 d1[1]
vmov.32 d0[0]

Deși acest lucru poate fi foarte util, este și periculos, deoarece în cazul registrului
secvență, trebuie să aveți o ordine puternică (citiți înainte de a scrie, copiați înainte de utilizare etc.). Dacă
definiția pe care o caută testul nu se potrivește (din cauza unei erori în compilator), aceasta
se pot potrivi mai departe de utilizare și masca bug-urile reale.

În aceste cazuri, pentru a aplica ordinul, utilizați o directivă non-DAG între blocurile DAG.

Etichetă de verificare: directivă
Uneori într-un fișier care conține mai multe teste împărțite în blocuri logice, unul sau mai multe
VERIFICA: directivele pot reuși din neatenție prin potrivirea liniilor într-un bloc ulterior. În timp ce an
de obicei, eroarea va fi generată în cele din urmă, verificarea marcată ca fiind cauza erorii poate să nu fie
are de fapt orice legătură cu sursa reală a problemei.

Pentru a produce mesaje de eroare mai bune în aceste cazuri, „Etichetă de verificare:„directiva poate
fi folosit. Este tratat identic cu un normal VERIFICA directivă, cu excepția faptului că FileCheck o face
o presupunere suplimentară că o linie potrivită de directivă nu poate fi, de asemenea, potrivită cu
orice alt control prezent în potrivire-nume fișier; acesta este destinat a fi utilizat pentru linii
care conțin etichete sau alți identificatori unici. Conceptual, prezența lui ETICHETA DE VERIFICARE
împarte fluxul de intrare în blocuri separate, fiecare dintre acestea fiind procesat independent,
prevenirea a VERIFICA: directivă într-un bloc care se potrivește cu o linie din alt bloc. De exemplu,

definește %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
intrare:
; CHECK-LABEL: C_ctor_base:
; VERIFICAȚI: mov [[SAVETHIS:r[0-9]+]], r0
; VERIFICARE: bl A_ctor_base
; VERIFICAȚI: mov r0, [[SAVETHIS]]
%0 = bitcast %struct.C* %this to %struct.A*
%call = apel de coadă %struct.A* @A_ctor_base(%struct.A* %0)
%1 = bitcast %struct.C* %this to %struct.B*
%call2 = apel de coadă %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
ret %struct.C* %this
}

definește %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
intrare:
; CHECK-LABEL: D_ctor_base:

Utilizarea Etichetă de verificare: directive în acest caz asigură că cele trei VERIFICA: instrucțiuni
acceptă numai linii corespunzătoare corpului @C_ctor_base funcția, chiar dacă
modelele se potrivesc cu liniile găsite mai târziu în fișier. În plus, dacă unul dintre acești trei VERIFICA:
directivele eșuează, FileCheck se va recupera continuând la următorul bloc, permițând multiple
eșecurile testelor să fie detectate într-o singură invocare.

Nu există nicio cerință ca Etichetă de verificare: directivele conțin șiruri care corespund cu
etichete sintactice reale într-un limbaj sursă sau de ieșire: pur și simplu trebuie să se potrivească unic cu a
o singură linie din fișierul care se verifică.

Etichetă de verificare: directivele nu pot conține definiții sau utilizări variabile.

FileCheck Model De potrivire Sintaxă
"VERIFICA:"Şi"VERIFICAȚI-NU:" ambele directive au un model care să se potrivească. Pentru cele mai multe utilizări ale
FileCheck, potrivirea șirurilor fixe este perfect suficientă. Pentru unele lucruri, mai mult
se dorește o formă flexibilă de potrivire. Pentru a sprijini acest lucru, FileCheck vă permite să specificați
expresii regulate în șiruri de caractere potrivite, înconjurate de acolade duble: {{yourregex}}.
Deoarece dorim să folosim potrivirea șirurilor fixe pentru majoritatea a ceea ce facem, FileCheck are
a fost conceput pentru a sprijini amestecarea și potrivirea corzilor fixe cu obișnuit
expresii. Acest lucru vă permite să scrieți astfel de lucruri:

; VERIFICAȚI: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}

În acest caz, orice offset din registrul ESP va fi permis și orice registru xmm va fi permis
fie permisă.

Deoarece expresiile regulate sunt închise cu acolade duble, ele sunt distincte vizual,
și nu trebuie să utilizați caractere de escape în acoladele duble, așa cum ați face în C.
În cazul rar în care doriți să potriviți acolade duble în mod explicit din intrare, puteți
foloseste ceva urat de genul {{[{][{]}} ca tiparul tău.

FileCheck Variabile
Este adesea util să potriviți un model și apoi să verificați dacă acesta apare din nou mai târziu în
fişier. Pentru testele de codegen, acest lucru poate fi util pentru a permite orice registru, dar verificați asta
registrul este folosit în mod constant ulterior. Pentru a face acest lucru, FileCheck permite variabilelor numite să fie
definite și substituite în tipare. Iată un exemplu simplu:

; VERIFICARE: test5:
; VERIFICAȚI: acum [[REGISTER:%[az]+]]
; VERIFICAȚI: și {{.*}}[[ÎNREGISTRARE]]

Prima linie de verificare se potrivește cu o expresie regex %[az]+ și îl capturează în variabilă ÎNREGISTRARE.
A doua linie verifică că orice se află în ÎNREGISTRARE apare mai târziu în fișier după an
"și W". FileCheck referințele variabilelor sunt întotdeauna conținute în [[ ]] perechi, iar lor
numele pot fi formate cu regex [a-zA-Z][a-zA-Z0-9]*. Dacă două puncte urmează după nume,
atunci este o definiție a variabilei; altfel, este o utilizare.

FileCheck variabilele pot fi definite de mai multe ori, iar utilizările primesc întotdeauna cea mai recentă valoare.
Variabilele pot fi, de asemenea, utilizate ulterior pe aceeași linie pe care au fost definite. De exemplu:

; VERIFICAȚI: op [[REG:r[0-9]+]], [[REG]]

Poate fi util dacă doriți operanzii lui op să fie același registru și nu-ți pasă
exact ce registru este.

FileCheck Expresii
Uneori este necesar să se verifice rezultatul care se referă la numerele de linie ale fișierului de potrivire,
de exemplu, la testarea diagnosticelor compilatorului. Aceasta introduce o anumită fragilitate a meciului
structura fișierului, ca „VERIFICA:" liniile conțin numere absolute de rând în același fișier, care
trebuie actualizate ori de câte ori numerele de rând se schimbă din cauza adăugării sau ștergerii textului.

Pentru a susține acest caz, FileCheck permite utilizarea [[@LINIA]], [[@LINE+ ]],
[[@LINIA- ]] expresii în tipare. Aceste expresii se extind la un număr de
linia în care se află un model (cu un decalaj întreg opțional).

În acest fel, modelele de potrivire pot fi plasate lângă liniile de test relevante și pot include linia relativă
numere de referință, de exemplu:

// VERIFICAȚI: test.cpp:[[@LINE+4]]:6: eroare: așteptat ';' după declarator de nivel superior
// VERIFICAȚI-URMĂTOR: {{^int a}}
// VERIFICAȚI-URMĂTOR: {{^ \^}}
// VERIFICAȚI-URMĂTOR: {{^ ;}}
int a

Utilizați FileCheck-3.6 online folosind serviciile onworks.net