FileCheck-3.6 - Dalam Talian di Awan

JADUAL:

NAMA

FileCheck - Pengesah fail padanan corak fleksibel

SINOPSIS

Semakan Fail padanan-nama fail [--check-prefix=XXX] [--ketat-ruang putih]

DESCRIPTION

Semakan Fail membaca dua fail (satu daripada input standard, dan satu dinyatakan pada baris arahan)
dan menggunakan satu untuk mengesahkan yang lain. Tingkah laku ini amat berguna untuk testsuite,
yang ingin mengesahkan bahawa output beberapa alat (cth llc) mengandungi yang dijangkakan
maklumat (contohnya, movsd dari esp atau apa sahaja yang menarik). Ini serupa
untuk menggunakan grep, tetapi ia dioptimumkan untuk memadankan berbilang input berbeza dalam satu fail dalam a
susunan tertentu.

. padanan-nama fail fail menentukan fail yang mengandungi corak untuk dipadankan. Fail
untuk mengesahkan dibaca daripada input standard melainkan jika --input-file pilihan digunakan.

PILIHAN

-membantu Cetak ringkasan pilihan baris arahan.

--semak-awalan awalan
FileCheck mencari kandungan padanan-nama fail untuk corak padan. Oleh
lalai, corak ini diawali dengan "SEMAK:". Jika anda ingin menggunakan a
awalan yang berbeza (cth kerana fail input yang sama sedang menyemak berbilang yang berbeza
alat atau pilihan), yang --semak-awalan hujah membenarkan anda untuk menentukan satu atau lebih
awalan untuk dipadankan. Awalan berbilang berguna untuk ujian yang mungkin berubah
pilihan larian yang berbeza, tetapi kebanyakan baris kekal sama.

--input-file nama fail
Fail untuk diperiksa (lalai kepada stdin).

--ketat-ruang putih
Secara lalai, FileCheck mengkanonikalkan input ruang putih mendatar (ruang dan tab)
yang menyebabkan ia mengabaikan perbezaan ini (ruang akan sepadan dengan tab). The
--ketat-ruang putih hujah melumpuhkan tingkah laku ini. Urutan akhir baris ialah
dikanonikalkan kepada gaya UNIX \n dalam semua mod.

--semak-tidak-tersirat corak semak
Menambah semakan negatif tersirat untuk corak yang ditentukan antara semakan positif.
Pilihan itu membolehkan menulis ujian yang lebih ketat tanpa memasukkannya SEMAK-TIDAKs.

Sebagai contoh, "--semak-tidak-tersirat amaran:" boleh berguna apabila menguji diagnostik
mesej daripada alatan yang tidak mempunyai pilihan yang serupa dengan dilafaz -sahkan. Dengan ini
pilihan FileCheck akan mengesahkan bahawa input tidak mengandungi amaran yang tidak dilindungi oleh
mana-mana SEMAK: corak.

-turun
Tunjukkan nombor versi program ini.

EXIT STATUS

If Semakan Fail mengesahkan bahawa fail sepadan dengan kandungan yang dijangkakan, ia keluar dengan 0.
Jika tidak, jika tidak, atau jika ralat berlaku, ia akan keluar dengan nilai bukan sifar.

TUTORIAL

FileCheck biasanya digunakan daripada ujian regresi LLVM, yang digunakan pada baris RUN
ujian itu. Contoh mudah menggunakan FileCheck dari baris RUN kelihatan seperti ini:

; RUN: llvm-as < %s | llc -march=x86-64 | Semak Fail %s

Sintaks ini mengatakan untuk menyalurkan fail semasa ("%s") ke dalam llvm-as, paip itu ke dalam llc, Maka
paip keluaran daripada llc ke dalam Semakan Fail. Ini bermakna FileCheck akan mengesahkannya
input standard (output llc) terhadap argumen nama fail yang ditentukan (asal .ll
fail ditentukan oleh "%s"). Untuk melihat cara ini berfungsi, mari lihat bahagian yang lain .ll fail
(selepas baris RUN):

define void @sub1(i32* %p, i32 %v) {
kemasukan:
; SEMAK: sub1:
; SEMAK: subl
%0 = panggilan ekor i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
batal ret
}

define void @inc4(i64* %p) {
kemasukan:
; SEMAK: inc4:
; SEMAK: incq
%0 = panggilan ekor i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
batal ret
}

Di sini anda boleh melihat beberapa "SEMAK:" baris yang dinyatakan dalam ulasan. Sekarang anda boleh melihat bagaimana fail
disalurkan ke dalam llvm-as, Maka llc, dan output kod mesin ialah apa yang kami sahkan.
FileCheck menyemak output kod mesin untuk mengesahkan bahawa ia sepadan dengan apa yang "SEMAK:"garisan
nyatakan.

Sintaks "SEMAK:" baris adalah sangat mudah: ia adalah rentetan tetap yang mesti berlaku dalam
pesanan. FileCheck lalai untuk mengabaikan perbezaan ruang putih mendatar (cth ruang ialah
dibenarkan untuk memadankan tab) tetapi sebaliknya, kandungan "SEMAK:" talian diperlukan untuk
padankan sesuatu dalam fail ujian dengan tepat.

Satu perkara yang menarik tentang FileCheck (berbanding dengan grep) ialah ia membenarkan penggabungan kes ujian
bersama-sama ke dalam kumpulan logik. Sebagai contoh, kerana ujian di atas sedang menyemak untuk
"sub1:"Dan"inc4:" label, ia tidak akan sepadan melainkan terdapat "subl" di antara mereka
label. Jika ia wujud di tempat lain dalam fail, itu tidak akan dikira: "grep subl"
sepadan jika "subl" wujud di mana-mana dalam fail.

. Semakan Fail -semak-awalan pilihan
Semakan Fail -semak-awalan pilihan membenarkan berbilang konfigurasi ujian untuk dipacu daripada
1 .ll fail. Ini berguna dalam banyak keadaan, contohnya, menguji berbeza
varian seni bina dengan llc. Berikut ialah contoh mudah:

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

takrifkan <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) nounwind {
%tmp1 = unsur sisipan <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
}

Dalam kes ini, kami sedang menguji bahawa kami mendapat penjanaan kod yang dijangkakan dengan kedua-dua 32-bit dan
Penjanaan kod 64-bit.

. SEMAK-SETERUSNYA: arahan
Kadangkala anda ingin memadankan baris dan ingin mengesahkan bahawa perlawanan berlaku tepat
baris berturut-turut tanpa garis lain di antaranya. Dalam kes ini, anda boleh menggunakan "SEMAK:"
dan "SEMAK-SETERUSNYA:" arahan untuk menyatakan ini. Jika anda menetapkan awalan semak tersuai,
hanya guna"-SETERUSNYA:". Contohnya, sesuatu seperti ini berfungsi seperti yang anda jangkakan:

define void @t2(<2 x double>* %r, <2 x double>* %A, double %B) {
%tmp3 = muatkan <2 x ganda>* %A, sejajarkan 16
%tmp7 = insertelement <2 x double> undef, double %B, i32 0
%tmp9 = shufflevector <2 x ganda> %tmp3,
<2 x ganda> %tmp7,
<2 x i32> < i32 0, i32 2 >
simpan <2 x double> %tmp9, <2 x double>* %r, sejajarkan 16
batal ret

; SEMAK: t2:
; SEMAK: movl 8(%esp), %eax
; SEMAK-SETERUSNYA: movapd (%eax), %xmm0
; SEMAK-SETERUSNYA: movhpd 12(%esp), %xmm0
; SEMAK-SETERUSNYA: movl 4(%esp), %eax
; SEMAK-SETERUSNYA: movapd %xmm0, (%eax)
; SEMAK-SETERUSNYA: ret
}

"SEMAK-SETERUSNYA:" arahan menolak input melainkan terdapat betul-betul satu baris baharu di antaranya
dan arahan sebelumnya. A"SEMAK-SETERUSNYA:" tidak boleh menjadi arahan pertama dalam fail.

. SEMAK-TIDAK: arahan
The "SEMAK-TIDAK:" Arahan digunakan untuk mengesahkan bahawa rentetan tidak berlaku antara dua
perlawanan (atau sebelum perlawanan pertama, atau selepas perlawanan terakhir). Sebagai contoh, untuk mengesahkan itu
beban dikeluarkan melalui transformasi, ujian seperti ini boleh digunakan:

takrifkan i8 @coerce_offset0(i32 %V, i32* %P) {
simpan i32 %V, i32* %P

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

%A = muat i8* %P3
ret i8 %A
; SEMAK: @coerce_offset0
; SEMAK-TIDAK: memuatkan
; SEMAK: ret i8
}

. SEMAK-DAG: arahan
Jika perlu untuk memadankan rentetan yang tidak berlaku dalam susunan berurutan,
"SEMAK-DAG:" boleh digunakan untuk mengesahkannya antara dua perlawanan (atau sebelum perlawanan pertama,
atau selepas perlawanan terakhir). Sebagai contoh, dentang memancarkan global vtable dalam susunan terbalik. menggunakan
SEMAK-DAG:, kita boleh menyimpan cek dalam susunan semula jadi:

// RUN: %clang_cc1 %s -emit-llvm -o - | Semak Fail %s

struct Foo { kaedah kekosongan maya(); };
Foo f; // memancarkan vtable
// CHECK-DAG: @_ZTV3Foo =

struct Bar { kaedah kekosongan maya(); };
Bar b;
// CHECK-DAG: @_ZTV3Bar =

SEMAK-TIDAK: arahan boleh dicampur dengan SEMAK-DAG: arahan untuk mengecualikan rentetan antara
persekitarannya SEMAK-DAG: arahan. Akibatnya, persekitaran SEMAK-DAG: arahan
tidak boleh disusun semula, iaitu semua kejadian sepadan SEMAK-DAG: sebelum SEMAK-TIDAK: bukan kemestian
ketinggalan di belakang padanan kejadian SEMAK-DAG: selepas SEMAK-TIDAK:. Sebagai contoh,

; SEMAK-DAG: SEBELUM
; SEMAK-TIDAK: TIDAK
; CHECK-DAG: SELEPAS

Kes ini akan menolak rentetan input di mana SEBELUM berlaku selepas SELEPAS.

Dengan pembolehubah yang ditangkap, SEMAK-DAG: dapat memadankan susunan topologi yang sah bagi DAG
dengan tepi daripada definisi pembolehubah kepada penggunaannya. Ia berguna, contohnya, apabila anda
kes ujian perlu memadankan urutan output yang berbeza daripada penjadual arahan. Untuk
contohnya,

; CHECK-DAG: tambah [[REG1:r[0-9]+]], r1, r2
; CHECK-DAG: tambah [[REG2:r[0-9]+]], r3, r4
; SEMAK: mul r5, [[REG1]], [[REG2]]

Dalam kes ini, mana-mana perintah daripada dua itu menambah arahan akan dibenarkan.

Jika anda mentakrifkan and menggunakan pembolehubah dalam yang sama SEMAK-DAG: blok, sedar bahawa
peraturan definisi boleh dipadankan selepas kegunaannya.

Jadi, sebagai contoh, kod di bawah akan lulus:

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

Walaupun kod lain ini, tidak akan:

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

Walaupun ini boleh menjadi sangat berguna, ia juga berbahaya, kerana dalam kes daftar
urutan, anda mesti mempunyai susunan yang kuat (baca sebelum menulis, salin sebelum digunakan, dll). Sekiranya
definisi ujian anda cari tidak sepadan (kerana pepijat dalam pengkompil), ia
mungkin sepadan dengan lebih jauh daripada penggunaan, dan menyembunyikan pepijat sebenar.

Dalam kes tersebut, untuk menguatkuasakan perintah itu, gunakan arahan bukan DAG antara blok DAG.

. SEMAK-LABEL: arahan
Kadangkala dalam fail yang mengandungi berbilang ujian dibahagikan kepada blok logik, satu atau lebih
SEMAK: arahan mungkin berjaya secara tidak sengaja dengan memadankan baris dalam blok kemudian. Manakala an
ralat biasanya akhirnya akan dijana, semakan ditandai sebagai menyebabkan ralat mungkin tidak
sebenarnya mempunyai sebarang hubungan dengan punca sebenar masalah.

Untuk menghasilkan mesej ralat yang lebih baik dalam kes ini, "SEMAK-LABEL:"arahan boleh
digunakan. Ia diperlakukan sama seperti biasa CHECK arahan kecuali yang dibuat oleh FileCheck
andaian tambahan bahawa baris yang dipadankan dengan arahan tidak juga boleh dipadankan dengan
sebarang daftar masuk lain padanan-nama fail; ini bertujuan untuk digunakan untuk garisan
mengandungi label atau pengecam unik lain. Secara konsep, kehadiran SEMAK-LABEL
membahagikan aliran input kepada blok berasingan, setiap satunya diproses secara bebas,
mencegah a SEMAK: arahan dalam satu blok yang sepadan dengan garisan dalam blok lain. Sebagai contoh,

takrifkan %struct.C* @C_ctor_base(%struct.C* %ini, i32 %x) {
kemasukan:
; SEMAK-LABEL: C_ctor_base:
; SEMAK: mov [[SAVETHIS:r[0-9]+]], r0
; SEMAK: bl A_ctor_base
; SEMAK: mov r0, [[SAVETHIS]]
%0 = bitcast %struct.C* %ini kepada %struct.A*
%panggilan = panggilan ekor %struct.A* @A_ctor_base(%struct.A* %0)
%1 = bitcast %struct.C* %ini kepada %struct.B*
%call2 = tail call %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
ret %struct.C* %ini
}

takrifkan %struct.D* @D_ctor_base(%struct.D* %ini, i32 %x) {
kemasukan:
; SEMAK-LABEL: D_ctor_base:

Penggunaan SEMAK-LABEL: arahan dalam kes ini memastikan bahawa ketiga-tiga SEMAK: arahan
hanya menerima garisan yang sepadan dengan badan @C_ctor_base berfungsi, walaupun jika
corak sepadan dengan baris yang ditemui kemudian dalam fail. Tambahan pula, jika salah satu daripada tiga ini SEMAK:
arahan gagal, FileCheck akan pulih dengan meneruskan ke blok seterusnya, membenarkan berbilang
kegagalan ujian untuk dikesan dalam satu doa.

Tidak ada syarat itu SEMAK-LABEL: arahan mengandungi rentetan yang sepadan dengan
label sintaksis sebenar dalam bahasa sumber atau output: mereka mestilah padan secara unik dengan a
satu baris dalam fail yang sedang disahkan.

SEMAK-LABEL: arahan tidak boleh mengandungi definisi atau kegunaan yang berubah-ubah.

Semakan Fail corak Pemadanan Syntax
The "SEMAK:"Dan"SEMAK-TIDAK:" arahan kedua-duanya mengambil corak untuk dipadankan. Untuk kebanyakan kegunaan
FileCheck, padanan rentetan tetap sudah memadai. Untuk beberapa perkara, lebih
bentuk pemadanan yang fleksibel dikehendaki. Untuk menyokong ini, FileCheck membenarkan anda untuk menentukan
ungkapan biasa dalam rentetan yang sepadan, dikelilingi oleh pendakap berganda: {{yourregex}}.
Oleh kerana kami ingin menggunakan padanan rentetan tetap untuk kebanyakan perkara yang kami lakukan, FileCheck mempunyai
telah direka bentuk untuk menyokong pencampuran dan pemadanan rentetan tetap dengan pemadanan biasa
ungkapan. Ini membolehkan anda menulis perkara seperti ini:

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

Dalam kes ini, sebarang offset daripada daftar ESP akan dibenarkan, dan mana-mana daftar xmm akan dibenarkan
dibenarkan.

Oleh kerana ungkapan biasa disertakan dengan pendakap berganda, ia jelas secara visual,
dan anda tidak perlu menggunakan aksara melarikan diri dalam pendakap berganda seperti yang anda lakukan dalam C.
Dalam kes yang jarang berlaku yang anda mahu memadankan pendakap berganda secara eksplisit daripada input, anda boleh
menggunakan sesuatu yang hodoh seperti {{[{][{]}} sebagai corak anda.

Semakan Fail Pembolehubah
Selalunya berguna untuk memadankan corak dan kemudian mengesahkan bahawa ia berlaku semula kemudian dalam
fail. Untuk ujian codegen, ini berguna untuk membenarkan mana-mana daftar, tetapi sahkan bahawa itu
daftar digunakan secara konsisten kemudian. Untuk membuat ini, Semakan Fail membenarkan pembolehubah yang dinamakan
ditakrifkan dan digantikan kepada corak. Berikut adalah contoh mudah:

; SEMAK: ujian5:
; SEMAK: sekarang [[DAFTAR:%[az]+]]
; SEMAK: dan {{.*}}[[DAFTAR]]

Baris semakan pertama sepadan dengan regex %[az]+ dan menangkapnya ke dalam pembolehubah DAFTAR.
Baris kedua mengesahkan bahawa apa sahaja yang ada dalam DAFTAR berlaku kemudian dalam fail selepas an
"danw". Semakan Fail rujukan pembolehubah sentiasa terkandung dalam [[ ]] pasangan, dan mereka
nama boleh dibentuk dengan regex [a-zA-Z][a-zA-Z0-9]*. Jika tanda titik bertindih mengikut nama,
maka ia adalah definisi pembolehubah; jika tidak, ia adalah satu kegunaan.

Semakan Fail pembolehubah boleh ditakrifkan beberapa kali, dan penggunaan sentiasa mendapat nilai terkini.
Pembolehubah juga boleh digunakan kemudian pada baris yang sama yang ditakrifkan. Sebagai contoh:

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

Boleh berguna jika anda mahukan operan op untuk menjadi daftar yang sama, dan tidak peduli
betul-betul daftar yang mana.

Semakan Fail Ungkapan
Kadangkala terdapat keperluan untuk mengesahkan output yang merujuk nombor baris fail padanan,
cth semasa menguji diagnostik pengkompil. Ini memperkenalkan kerapuhan perlawanan tertentu
struktur fail, sebagai "SEMAK:" baris mengandungi nombor baris mutlak dalam fail yang sama, yang
perlu dikemas kini apabila nombor baris berubah disebabkan penambahan atau pemadaman teks.

Untuk menyokong kes ini, FileCheck membenarkan penggunaan [[@LINE]], [[@LINE+ ]],
[[@LINE- ]] ungkapan dalam corak. Ungkapan ini berkembang kepada beberapa
baris di mana corak terletak (dengan ofset integer pilihan).

Dengan cara ini corak padanan boleh diletakkan berhampiran garisan ujian yang berkaitan dan termasuk garis relatif
rujukan nombor, contohnya:

// SEMAK: test.cpp:[[@LINE+4]]:6: ralat: dijangka ';' selepas pengisytihar peringkat atasan
// SEMAK-SETERUSNYA: {{^int a}}
// SEMAK-SETERUSNYA: {{^ \^}}
// SEMAK-SETERUSNYA: {{^ ;}}
int a

Gunakan FileCheck-3.6 dalam talian menggunakan perkhidmatan onworks.net