FileCheck-3.6 - Online in de cloud

PROGRAMMA:

NAAM

FileCheck - Flexibele bestandsverificatie voor patroonovereenkomst

KORTE INHOUD

Bestands controle match-bestandsnaam [--check-voorvoegsel=XXX] [--strikte-witruimte]

PRODUCTBESCHRIJVING

Bestands controle leest twee bestanden (één van standaardinvoer en één gespecificeerd op de opdrachtregel)
en gebruikt de ene om de andere te verifiëren. Dit gedrag is vooral handig voor de testsuite,
die wil verifiëren dat de uitvoer van een tool (bijv llc) bevat de verwachte
informatie (bijvoorbeeld een movsd van esp of wat dan ook interessant is). Dit is vergelijkbaar
het gebruik grep, maar het is geoptimaliseerd voor het matchen van meerdere verschillende invoer in één bestand in a
specifieke bestelling.

De match-bestandsnaam file specificeert het bestand dat de patronen bevat die moeten overeenkomen. Het bestand
om te verifiëren wordt gelezen van standaardinvoer, tenzij de --Invoer bestand optie wordt gebruikt.

OPTIES

-Help Druk een samenvatting van de opdrachtregelopties af.

--check-voorvoegsel voorvoegsel
FileCheck doorzoekt de inhoud van match-bestandsnaam voor patronen die bij elkaar passen. Door
standaard worden deze patronen voorafgegaan door "CONTROLEREN:". Als u een . wilt gebruiken
verschillende prefix (bijv. omdat hetzelfde invoerbestand meerdere verschillende aanvinkt)
gereedschap of opties), de --check-voorvoegsel argument stelt u in staat om een ​​of meer
voorvoegsels overeenkomen. Meerdere voorvoegsels zijn handig voor tests die kunnen veranderen voor
verschillende uitvoeringsopties, maar de meeste regels blijven hetzelfde.

--Invoer bestand bestandsnaam
Bestand om te controleren (standaard ingesteld op stdin).

--strikte-witruimte
Standaard canonicaliseert FileCheck invoer horizontale witruimte (spaties en tabbladen)
waardoor deze verschillen worden genegeerd (een spatie komt overeen met een tabblad). De
--strikte-witruimte argument schakelt dit gedrag uit. End-of-line sequenties zijn:
gecanoniseerd naar UNIX-stijl \n in alle standen.

--impliciet-vinkje-niet ruitpatroon
Voegt impliciete negatieve controles toe voor de gespecificeerde patronen tussen positieve controles.
Met de optie kunnen strengere tests worden geschreven zonder ze vol te proppen met CONTROLEER-NIETs.

Bijvoorbeeld, "--impliciet-vinkje-niet waarschuwing:" kan handig zijn bij het testen van diagnose
berichten van tools die geen optie hebben die lijkt op kletteren -verifiëren. Hiermee
optie FileCheck zal controleren of invoer geen waarschuwingen bevat die niet worden gedekt door
elke CONTROLEREN: patronen.

-versie
Toon het versienummer van dit programma.

EXIT STATUS

If Bestands controle verifieert of het bestand overeenkomt met de verwachte inhoud, wordt afgesloten met 0.
Anders, als dat niet het geval is, of als er een fout optreedt, wordt het afgesloten met een waarde die niet nul is.

TUTORIAL

FileCheck wordt meestal gebruikt voor LLVM-regressietests, en wordt aangeroepen op de RUN-regel van
de test. Een eenvoudig voorbeeld van het gebruik van FileCheck vanaf een RUN-regel ziet er als volgt uit:

; RUN: llvm-as < %s | llc -maart=x86-64 | Bestandscontrole %s

Deze syntaxis zegt dat het huidige bestand moet worden doorgesluisd ("%s") naar binnen llvm-as, pijp dat in llcdan
pijp de output van llc in Bestands controle. Dit betekent dat FileCheck zijn
standaardinvoer (de llc-uitvoer) tegen het opgegeven bestandsnaamargument (de originele .NS
bestand gespecificeerd door "%s"). Om te zien hoe dit werkt, laten we eens kijken naar de rest van de .NS filet
(na de RUN-regel):

definieer leegte @sub1(i32* %p, i32 %v) {
entry:
; CONTROLEER: onder1:
; CONTROLEER: subl
%0 = staartaanroep i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
ret leegte
}

definieer leegte @inc4(i64* %p) {
entry:
; CONTROLEER: inc4:
; CHECK: incl
%0 = staartaanroep i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
ret leegte
}

Hier zie je wat "CONTROLEREN:" regels gespecificeerd in opmerkingen. Nu kunt u zien hoe het bestand
wordt doorgesluisd naar llvm-asdan llc, en de output van de machinecode is wat we verifiëren.
FileCheck controleert de uitvoer van de machinecode om te controleren of deze overeenkomt met wat de "CONTROLEREN:" lijnen
specificeren.

De syntaxis van de "CONTROLEREN:" regels is heel eenvoudig: het zijn vaste tekenreeksen die moeten voorkomen in
volgorde. FileCheck negeert standaard horizontale witruimteverschillen (bijv. een spatie is
mogen overeenkomen met een tabblad), maar verder is de inhoud van de "CONTROLEREN:" regel is vereist om
exact overeenkomen met iets in het testbestand.

Een leuk ding over FileCheck (vergeleken met grep) is dat het het samenvoegen van testgevallen mogelijk maakt
samen in logische groepen. Bijvoorbeeld, omdat de test hierboven controleert op de
"onder1:"En"meerder 4:" labels, het komt niet overeen tenzij er een " issubliem" daartussenin
etiketten. Als het ergens anders in het bestand zou staan, zou dat niet meetellen: "grep subliem"
komt overeen als "subliem" staat overal in het bestand.

De Bestands controle -check-voorvoegsel optie
De Bestandscontrole -check-voorvoegsel optie maakt het mogelijk om meerdere testconfiguraties aan te sturen vanuit
een .NS het dossier. Dit is in veel omstandigheden handig, bijvoorbeeld bij het testen van verschillende
architectonische varianten met llc. Hier is een eenvoudig voorbeeld:

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

definieer <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) zelfstandig naamwoordwind {
%tmp1 = invoegelement <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
}

In dit geval testen we of we de verwachte codegeneratie krijgen met zowel 32-bits als
64-bits codegeneratie.

De CONTROLEER-VOLGENDE: Richtlijnen
Soms wil je lijnen matchen en wil je controleren of de matches precies plaatsvinden
opeenvolgende regels zonder andere regels ertussen. In dit geval kunt u "CONTROLEREN:"
en "CONTROLEER-VOLGENDE:" instructies om dit op te geven. Als u een aangepast controlevoorvoegsel hebt opgegeven,
gebruik gewoon "-DE VOLGENDE:". Iets als dit werkt bijvoorbeeld zoals je zou verwachten:

definieer leegte @t2(<2 x dubbel>* %r, <2 x dubbel>* %A, dubbel %B) {
%tmp3 = belasting <2 x dubbel>* %A, uitlijnen 16
%tmp7 = invoegelement <2 x dubbel> undef, dubbel %B, i32 0
%tmp9 = shufflevector <2 x dubbel> %tmp3,
<2 x dubbel> %tmp7,
<2 x i32> < i32 0, i32 2 >
opslaan <2 x dubbel> %tmp9, <2 x dubbel>* %r, uitlijnen 16
ret leegte

; CONTROLEER: t2:
; CONTROLEREN: movl 8(%esp), %eax
; CHECK-VOLGENDE: movapd (%eax), %xmm0
; CONTROLEER VOLGENDE: movhpd 12(%esp), %xmm0
; CHECK-VOLGENDE: movl 4(%esp), %eax
; CHECK-VOLGENDE: movapd %xmm0, (%eax)
; CONTROLEER-VOLGENDE: ret
}

"CONTROLEER-VOLGENDE:" richtlijnen verwerpen de invoer tenzij er precies één nieuwe regel tussen staat
en de vorige richtlijn. EEN "CONTROLEER-VOLGENDE:" kan niet de eerste richtlijn in een bestand zijn.

De CONTROLEER-NIET: Richtlijnen
de "CONTROLEER-NIET:" richtlijn wordt gebruikt om te controleren of een string niet voorkomt tussen twee
wedstrijden (of voor de eerste wedstrijd, of na de laatste wedstrijd). Om bijvoorbeeld te verifiëren dat
een belasting wordt verwijderd door een transformatie, een test als deze kan worden gebruikt:

definieer i8 @coerce_offset0(i32 %V, i32* %P) {
i32 %V opslaan, i32* %P

%P2 = bitcast i32* %P naar i8*
%P3 = haalelementptr i8* %P2, i32 2

%A = belasting i8* %P3
ret i8 %A
; CONTROLEER: @coerce_offset0
; CONTROLEER-NIET: laden
; CONTROLEER: ret i8
}

De CONTROLE-DAG: Richtlijnen
Als het nodig is om strings te matchen die niet in een strikt opeenvolgende volgorde voorkomen,
"CONTROLE-DAG:" kan worden gebruikt om ze te verifiëren tussen twee wedstrijden (of vóór de eerste wedstrijd,
of na de laatste wedstrijd). Clang zendt bijvoorbeeld vtable globals in omgekeerde volgorde uit. Gebruik makend van
CONTROLE-DAG:, kunnen we de cheques in de natuurlijke volgorde houden:

// RUN: %clang_cc1 %s -emit-llvm -o - | Bestandscontrole %s

struct Foo { virtuele void methode (); };
Foo f; // zend vtable uit
// CHECK-DAG: @_ZTV3Foo =

struct Bar { virtuele void-methode (); };
staaf b;
// CONTROLEDAG: @_ZTV3Bar =

CONTROLEER-NIET: richtlijnen kunnen worden gemengd met CONTROLE-DAG: richtlijnen om strings tussen . uit te sluiten
de omliggende CONTROLE-DAG: richtlijnen. Hierdoor is de omgeving CONTROLE-DAG: richtlijnen
kan niet opnieuw worden gerangschikt, dwz alle gebeurtenissen komen overeen CONTROLE-DAG: vaardigheden CONTROLEER-NIET: niet mogen
achterblijven bij het matchen van voorvallen CONTROLE-DAG: na CONTROLEER-NIET:. Bijvoorbeeld,

; CHECK-DAG: VOORDAT
; CONTROLEER-NIET: NIET
; CHECK-DAG: NA

In dit geval worden invoerreeksen afgewezen waarbij: VOOR treedt op na NA.

Met vastgelegde variabelen, CONTROLE-DAG: is in staat om geldige topologische ordeningen van een DAG . te matchen
met randen van de definitie van een variabele tot het gebruik ervan. Het is handig, bijv. wanneer uw
testgevallen moeten overeenkomen met verschillende uitvoersequenties van de instructieplanner. Voor
voorbeeld,

; CHECK-DAG: voeg [[REG1:r[0-9]+]], r1, r2 . toe
; CHECK-DAG: voeg [[REG2:r[0-9]+]], r3, r4 . toe
; CONTROLEER: mul r5, [[REG1]], [[REG2]]

In dit geval elke volgorde van die twee toevoegen instructies zijn toegestaan.

Als je definieert en variabelen gebruiken in dezelfde CONTROLE-DAG: blok, houd er rekening mee dat de
definitieregel kan overeenkomen na het gebruik ervan.

Dus, bijvoorbeeld, de onderstaande code zal passeren:

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

Hoewel deze andere code niet:

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

Hoewel dit erg handig kan zijn, is het ook gevaarlijk, omdat in het geval van register
volgorde, moet u een sterke volgorde hebben (lezen voor schrijven, kopiëren voor gebruik, enz.). Als de
definitie waar uw test naar zoekt komt niet overeen (vanwege een bug in de compiler), het
kan verder weg van het gebruik overeenkomen en echte bugs maskeren.

Gebruik in die gevallen om het bevel af te dwingen een niet-DAG-richtlijn tussen DAG-blokken.

De CONTROLE-ETIKET: Richtlijnen
Soms in een bestand met meerdere tests verdeeld in logische blokken, een of meer
CONTROLEREN: richtlijnen kunnen onbedoeld slagen door regels in een later blok te matchen. terwijl een
fout zal meestal uiteindelijk worden gegenereerd, de cheque die is gemarkeerd als de oorzaak van de fout, is mogelijk niet
daadwerkelijk enige relatie hebben met de werkelijke oorzaak van het probleem.

Om in deze gevallen betere foutmeldingen te produceren, wordt de "CONTROLE-ETIKET:" richtlijn kan
worden gebruikt. Het wordt op dezelfde manier behandeld als een normaal BEKIJK richtlijn behalve dat FileCheck maakt
een aanvullende veronderstelling dat een regel die overeenkomt met de richtlijn niet ook kan worden geëvenaard door
elke andere check aanwezig in match-bestandsnaam; dit is bedoeld om te worden gebruikt voor lijnen
met labels of andere unieke identificatiecodes. Conceptueel is de aanwezigheid van CHECK-LABEL
verdeelt de invoerstroom in afzonderlijke blokken, die elk afzonderlijk worden verwerkt,
voorkomen van een CONTROLEREN: richtlijn in het ene blok die overeenkomt met een regel in een ander blok. Bijvoorbeeld,

definieer %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
entry:
; CHECK-LABEL: C_ctor_base:
; CONTROLEER: mov [[SAVETHIS:r[0-9]+]], r0
; CONTROLEER: bl A_ctor_base
; CONTROLEER: mov r0, [[OPSLAAN]]
%0 = bitcast %struct.C* %this naar %struct.A*
%call = staartaanroep %struct.A* @A_ctor_base(%struct.A* %0)
%1 = bitcast %struct.C* %this naar %struct.B*
%call2 = staartaanroep %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
ret %struct.C* %dit
}

definieer %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
entry:
; CHECK-LABEL: D_ctor_base:

Het gebruik van CONTROLE-ETIKET: richtlijnen zorgen er in dit geval voor dat de drie CONTROLEREN: richtlijnen
accepteer alleen regels die overeenkomen met de hoofdtekst van de @C_ctor_base functie, zelfs als de
patronen komen overeen met lijnen die later in het bestand worden gevonden. Bovendien, als een van deze drie CONTROLEREN:
richtlijnen mislukken, zal FileCheck herstellen door door te gaan naar het volgende blok, waardoor meerdere
testfouten worden gedetecteerd in een enkele aanroep.

Er is geen vereiste dat CONTROLE-ETIKET: richtlijnen bevatten tekenreeksen die overeenkomen met
daadwerkelijke syntactische labels in een bron- of uitvoertaal: ze moeten eenvoudig uniek overeenkomen met a
enkele regel in het bestand dat wordt geverifieerd.

CONTROLE-ETIKET: richtlijnen kunnen geen variabele definities of toepassingen bevatten.

Bestands controle Patronen Bijpassende Syntaxis
de "CONTROLEREN:"En"CONTROLEER-NIET:" richtlijnen hebben beide een patroon dat overeenkomt. Voor de meeste toepassingen van
FileCheck, vaste string-matching is perfect voldoende. Voor sommige dingen een meer
flexibele vorm van matching is gewenst. Om dit te ondersteunen, kunt u met FileCheck specificeren:
reguliere expressies in overeenkomende strings, omgeven door dubbele accolades: {{yourregex}}.
Omdat we voor het grootste deel van wat we doen vaste tekenreeksen willen gebruiken, heeft FileCheck:
is ontworpen om het mixen en matchen van vaste strings te ondersteunen met regular
uitdrukkingen. Dit stelt je in staat om dingen als deze te schrijven:

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

In dit geval is elke offset van het ESP-register toegestaan ​​en elk xmm-register
toegestaan.

Omdat reguliere expressies tussen dubbele accolades staan, zijn ze visueel te onderscheiden,
en je hoeft geen escape-tekens te gebruiken binnen de dubbele accolades zoals je zou doen in C.
In het zeldzame geval dat u dubbele accolades expliciet uit de invoer wilt matchen, kunt u:
gebruik iets lelijks zoals {{[{][{]}} als jouw patroon.

Bestands controle Variabelen
Het is vaak handig om een ​​patroon te matchen en vervolgens te verifiëren dat het later in de
het dossier. Voor codegen-tests kan dit handig zijn om elk register toe te staan, maar controleer of dat
register wordt later consequent gebruikt. Om dit te doen, Bestands controle staat toe dat benoemde variabelen zijn
gedefinieerd en gesubstitueerd in patronen. Hier is een eenvoudig voorbeeld:

; CONTROLEER: test5:
; CONTROLEER: niet [[REGISTER:%[az]+]]
; CONTROLEER: andw {{.*}}[[REGISTER]]

De eerste controleregel komt overeen met een regex %[az]+ en legt het vast in de variabele REGISTREER U.
De tweede regel verifieert dat wat er ook is in REGISTREER U komt later in het bestand voor na een
"en W". Bestands controle variabele verwijzingen zijn altijd opgenomen in [[ ]] paren, en hun
namen kunnen worden gevormd met de regex [a-zA-Z][a-zA-Z0-9]*. Als er een dubbele punt achter de naam staat,
dan is het een definitie van de variabele; anders is het een gebruik.

Bestands controle variabelen kunnen meerdere keren worden gedefinieerd en gebruik krijgt altijd de laatste waarde.
Variabelen kunnen ook later worden gebruikt op dezelfde regel waarop ze zijn gedefinieerd. Bijvoorbeeld:

; CONTROLEER: op [[REG:r[0-9]+]], [[REG]]

Kan handig zijn als je de operanden van wilt op om hetzelfde register te zijn, en het maakt niet uit
om welk register het precies gaat.

Bestands controle Uitdrukkingen
Soms is het nodig om de uitvoer te verifiëren die verwijst naar regelnummers van het matchbestand,
bijv. bij het testen van compilerdiagnostiek. Dit introduceert een zekere kwetsbaarheid van de wedstrijd
bestandsstructuur, als "CONTROLEREN:" regels bevatten absolute regelnummers in hetzelfde bestand, wat
moeten worden bijgewerkt wanneer regelnummers veranderen als gevolg van teksttoevoeging of -verwijdering.

Om dit geval te ondersteunen, staat FileCheck het gebruik van [[@LIJN]], [[@LINE+ ]],
[[@LIJN- ]] uitdrukkingen in patronen. Deze uitdrukkingen breiden zich uit tot een aantal van de
lijn waar een patroon zich bevindt (met een optionele integer-offset).

Op deze manier kunnen matchpatronen in de buurt van de relevante testlijnen worden geplaatst en een relatieve lijn bevatten
nummerverwijzingen, bijvoorbeeld:

// CHECK: test.cpp:[[@LINE+4]]:6: fout: verwacht ';' na aangever op het hoogste niveau
// CONTROLEER-VOLGENDE: {{^int a}}
// CONTROLEER-VOLGENDE: {{^ \^}}
// CONTROLEER-VOLGENDE: {{^ ;}}
int een

Gebruik FileCheck-3.6 online met onworks.net-services