FileCheck-3.6 - ക്ലൗഡിൽ ഓൺലൈനായി

പട്ടിക:

NAME

FileCheck - ഫ്ലെക്സിബിൾ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ ഫയൽ വെരിഫയർ

സിനോപ്സിസ്

ഫയൽ ചെക്ക് പൊരുത്തം-ഫയലിന്റെ പേര് [--check-prefix=XXX] [--സ്ട്രിക്റ്റ്-വെറ്റ്സ്പേസ്]

വിവരണം

ഫയൽ ചെക്ക് രണ്ട് ഫയലുകൾ വായിക്കുന്നു (ഒന്ന് സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന്, ഒന്ന് കമാൻഡ് ലൈനിൽ വ്യക്തമാക്കിയത്)
മറ്റൊന്ന് പരിശോധിക്കാൻ ഒന്ന് ഉപയോഗിക്കുന്നു. ടെസ്റ്റ് സ്യൂട്ടിന് ഈ സ്വഭാവം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്,
ഏതെങ്കിലുമൊരു ടൂളിന്റെ ഔട്ട്പുട്ട് പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നു (ഉദാ llc) പ്രതീക്ഷിക്കുന്നത് അടങ്ങിയിരിക്കുന്നു
വിവരങ്ങൾ (ഉദാഹരണത്തിന്, esp-ൽ നിന്നുള്ള ഒരു movsd അല്ലെങ്കിൽ രസകരമായത്). ഇത് സമാനമാണ്
ഉപയോഗിക്കുന്നതിന് grep, എന്നാൽ ഒരു ഫയലിൽ ഒന്നിലധികം വ്യത്യസ്ത ഇൻപുട്ടുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന് ഇത് ഒപ്റ്റിമൈസ് ചെയ്തിരിക്കുന്നു
നിർദ്ദിഷ്ട ക്രമം.

ദി പൊരുത്തം-ഫയലിന്റെ പേര് പൊരുത്തപ്പെടുത്താനുള്ള പാറ്റേണുകൾ അടങ്ങുന്ന ഫയൽ ഫയൽ വ്യക്തമാക്കുന്നു. ഫയല്
സ്ഥിരീകരിക്കുക എന്നത് സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് വായിക്കുന്നില്ലെങ്കിൽ --ഇൻപുട്ട്-ഫയൽ ഓപ്ഷൻ ഉപയോഗിക്കുന്നു.

ഓപ്ഷനുകൾ

-ഹെൽപ്പ് കമാൻഡ് ലൈൻ ഓപ്ഷനുകളുടെ ഒരു സംഗ്രഹം പ്രിന്റ് ചെയ്യുക.

--ചെക്ക്-പ്രിഫിക്സ് പ്രിഫിക്‌സ്
ഫയൽചെക്ക് ഇതിന്റെ ഉള്ളടക്കങ്ങൾ തിരയുന്നു പൊരുത്തം-ഫയലിന്റെ പേര് പാറ്റേണുകൾ പൊരുത്തപ്പെടുന്നതിന്. എഴുതിയത്
സ്ഥിരസ്ഥിതിയായി, ഈ പാറ്റേണുകൾ "" എന്ന പ്രിഫിക്‌സ് ചെയ്‌തിരിക്കുന്നുചെക്ക്:". നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ a
വ്യത്യസ്ത പ്രിഫിക്‌സ് (ഉദാ. ഒരേ ഇൻപുട്ട് ഫയൽ ഒന്നിലധികം വ്യത്യസ്‌തങ്ങൾ പരിശോധിക്കുന്നതിനാൽ
ഉപകരണം അല്ലെങ്കിൽ ഓപ്ഷനുകൾ), the --ചെക്ക്-പ്രിഫിക്സ് ഒന്നോ അതിലധികമോ വ്യക്തമാക്കാൻ ആർഗ്യുമെന്റ് നിങ്ങളെ അനുവദിക്കുന്നു
പൊരുത്തപ്പെടുന്ന പ്രിഫിക്സുകൾ. ഒന്നിലധികം പ്രിഫിക്സുകൾ മാറിയേക്കാവുന്ന ടെസ്റ്റുകൾക്ക് ഉപയോഗപ്രദമാണ്
വ്യത്യസ്‌ത റൺ ഓപ്‌ഷനുകൾ, പക്ഷേ മിക്ക ലൈനുകളും അതേപടി തുടരുന്നു.

--ഇൻപുട്ട്-ഫയൽ ഫയലിന്റെ പേര്
പരിശോധിക്കാനുള്ള ഫയൽ (സ്റ്റഡിനിലേക്കുള്ള സ്ഥിരസ്ഥിതി).

--സ്ട്രിക്റ്റ്-വെറ്റ്സ്പേസ്
സ്ഥിരസ്ഥിതിയായി, FileCheck ഇൻപുട്ട് തിരശ്ചീന വൈറ്റ്‌സ്‌പെയ്‌സ് (സ്‌പെയ്‌സുകളും ടാബുകളും) കാനോനികലൈസ് ചെയ്യുന്നു
ഈ വ്യത്യാസങ്ങൾ അവഗണിക്കാൻ ഇത് കാരണമാകുന്നു (ഒരു സ്പെയ്സ് ഒരു ടാബുമായി പൊരുത്തപ്പെടും). ദി
--സ്ട്രിക്റ്റ്-വെറ്റ്സ്പേസ് വാദം ഈ സ്വഭാവത്തെ പ്രവർത്തനരഹിതമാക്കുന്നു. എൻഡ്-ഓഫ്-ലൈൻ സീക്വൻസുകളാണ്
UNIX-ശൈലിയിലേക്ക് കാനോനിക്കലൈസ് ചെയ്തു \n എല്ലാ മോഡുകളിലും.

--വ്യക്തമായ പരിശോധന-അല്ല ചെക്ക്-പാറ്റേൺ
പോസിറ്റീവ് ചെക്കുകൾക്കിടയിൽ നിർദ്ദിഷ്ട പാറ്റേണുകൾക്കായി പരോക്ഷമായ നെഗറ്റീവ് ചെക്കുകൾ ചേർക്കുന്നു.
സ്റ്റഫ് ചെയ്യാതെ തന്നെ കർശനമായ ടെസ്റ്റുകൾ എഴുതാൻ ഓപ്ഷൻ അനുവദിക്കുന്നു പരിശോധിക്കുക-അല്ലs.

ഉദാഹരണത്തിന്, "--വ്യക്തമായ പരിശോധന-അല്ല മുന്നറിയിപ്പ്:"ഡയഗ്നോസ്റ്റിക് പരിശോധിക്കുമ്പോൾ ഉപയോഗപ്രദമാകും
സമാനമായ ഒരു ഓപ്ഷൻ ഇല്ലാത്ത ടൂളുകളിൽ നിന്നുള്ള സന്ദേശങ്ങൾ ക്ലോംഗ് - പരിശോധിച്ചുറപ്പിക്കുക. ഇതിനോടൊപ്പം
ഇൻപുട്ടിൽ ഉൾപ്പെടാത്ത മുന്നറിയിപ്പുകൾ അടങ്ങിയിട്ടില്ലെന്ന് FileCheck ഓപ്ഷൻ പരിശോധിക്കും
എന്തെങ്കിലും ചെക്ക്: പാറ്റേണുകൾ.

-പതിപ്പ്
ഈ പ്രോഗ്രാമിന്റെ പതിപ്പ് നമ്പർ കാണിക്കുക.

പുറത്ത് പദവി

If ഫയൽ ചെക്ക് പ്രതീക്ഷിച്ച ഉള്ളടക്കങ്ങളുമായി ഫയൽ പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിച്ചുറപ്പിക്കുന്നു, അത് 0-ൽ നിന്ന് പുറത്തുകടക്കുന്നു.
അല്ലെങ്കിൽ, ഇല്ലെങ്കിൽ, അല്ലെങ്കിൽ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, അത് പൂജ്യമല്ലാത്ത മൂല്യത്തിൽ പുറത്തുകടക്കും.

TUTORIAL

ഫയൽചെക്ക് സാധാരണയായി LLVM റിഗ്രഷൻ ടെസ്റ്റുകളിൽ നിന്നാണ് ഉപയോഗിക്കുന്നത്, ഇത് RUN ലൈനിൽ പ്രയോഗിക്കുന്നു.
പരിശോധന. ഒരു RUN ലൈനിൽ നിന്ന് FileCheck ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഉദാഹരണം ഇതുപോലെ കാണപ്പെടുന്നു:

; റൺ: llvm-ആയി < %s | llc -march=x86-64 | ഫയൽ ചെക്ക് %s

ഈ വാക്യഘടന നിലവിലെ ഫയൽ പൈപ്പ് ചെയ്യാൻ പറയുന്നു ("%s") കടന്നു llvm-ആയി, അതിലേക്ക് പൈപ്പ് llcഎന്നിട്ട്
പൈപ്പ് ഔട്ട്പുട്ട് llc കടന്നു ഫയൽ ചെക്ക്. ഇതിനർത്ഥം FileCheck അതിന്റെ സ്ഥിരീകരണം നടത്തുമെന്നാണ്
നിർദ്ദിഷ്ട ഫയൽനാമ ആർഗ്യുമെന്റിന് എതിരായ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് (എൽഎൽസി ഔട്ട്പുട്ട്). .ll
ഫയൽ വ്യക്തമാക്കിയത് "%s").ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നറിയാൻ, ബാക്കിയുള്ളവ നോക്കാം .ll ഫയല്
(RUN ലൈനിന് ശേഷം):

അസാധുത നിർവ്വചിക്കുക @sub1(i32* %p, i32 %v) {
എൻ‌ട്രി:
; പരിശോധിക്കുക: ഉപ1:
; പരിശോധിക്കുക: subl
%0 = ടെയിൽ കോൾ i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
ശൂന്യത
}

ശൂന്യത നിർവ്വചിക്കുക @inc4(i64* %p) {
എൻ‌ട്രി:
; പരിശോധിക്കുക: inc4:
; പരിശോധിക്കുക: incq
%0 = ടെയിൽ കോൾ i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
ശൂന്യത
}

ചിലത് ഇവിടെ കാണാം"ചെക്ക്:" ലൈനുകൾ കമന്റുകളിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്. ഫയൽ എങ്ങനെയെന്ന് ഇപ്പോൾ നിങ്ങൾക്ക് കാണാം
പൈപ്പ് ആണ് llvm-ആയിഎന്നിട്ട് llc, കൂടാതെ മെഷീൻ കോഡ് ഔട്ട്പുട്ടാണ് ഞങ്ങൾ പരിശോധിക്കുന്നത്.
"" എന്നതിനോട് പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഫയൽ ചെക്ക് മെഷീൻ കോഡ് ഔട്ട്പുട്ട് പരിശോധിക്കുന്നു.ചെക്ക്:" ലൈനുകൾ
വ്യക്തമാക്കുക.

" എന്നതിന്റെ വാക്യഘടനചെക്ക്:വരികൾ വളരെ ലളിതമാണ്: അവ സംഭവിക്കേണ്ട നിശ്ചിത സ്ട്രിംഗുകളാണ്
ഓർഡർ. തിരശ്ചീന വൈറ്റ്‌സ്‌പേസ് വ്യത്യാസങ്ങൾ അവഗണിക്കുന്നതിന് ഫയൽചെക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു (ഉദാ.
ഒരു ടാബ് പൊരുത്തപ്പെടുത്താൻ അനുവദിച്ചിരിക്കുന്നു) എന്നാൽ, "ഇതിന്റെ ഉള്ളടക്കംചെക്ക്:"വരി ആവശ്യമാണ്
ടെസ്റ്റ് ഫയലിലെ ചില കാര്യങ്ങൾ കൃത്യമായി പൊരുത്തപ്പെടുത്തുക.

FileCheck-നെക്കുറിച്ചുള്ള ഒരു നല്ല കാര്യം (ഗ്രെപ്പുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ) ഇത് ടെസ്റ്റ് കേസുകൾ ലയിപ്പിക്കാൻ അനുവദിക്കുന്നു എന്നതാണ്
ഒരുമിച്ച് ലോജിക്കൽ ഗ്രൂപ്പുകളായി. ഉദാഹരണത്തിന്, മുകളിലെ ടെസ്റ്റ് പരിശോധിക്കുന്നതിനാൽ
"ഉപ1:" ഒപ്പം "inc4:"ലേബലുകൾ, ഒരു ഇല്ലെങ്കിൽ അത് പൊരുത്തപ്പെടില്ല"subl"അവരുടെ ഇടയിൽ
ലേബലുകൾ. ഫയലിൽ മറ്റെവിടെയെങ്കിലും ഇത് നിലവിലുണ്ടെങ്കിൽ, അത് കണക്കാക്കില്ല: "grep subl"
എങ്കിൽ പൊരുത്തപ്പെടുന്നു "subl" ഫയലിൽ എവിടെയും നിലവിലുണ്ട്.

ദി ഫയൽ ചെക്ക് - ചെക്ക്-പ്രിഫിക്സ് ഓപ്ഷൻ
ഫയൽ ചെക്ക് - ചെക്ക്-പ്രിഫിക്സ് ഒന്നിലധികം ടെസ്റ്റ് കോൺഫിഗറേഷനുകളിൽ നിന്ന് ഡ്രൈവ് ചെയ്യാൻ ഓപ്ഷൻ അനുവദിക്കുന്നു
ഒന്ന് .ll ഫയൽ. ഇത് പല സാഹചര്യങ്ങളിലും ഉപയോഗപ്രദമാണ്, ഉദാഹരണത്തിന്, വ്യത്യസ്തമായ പരിശോധന
കൂടെ വാസ്തുവിദ്യാ വകഭേദങ്ങൾ llc. ഒരു ലളിതമായ ഉദാഹരണം ഇതാ:

; റൺ: llvm-ആയി < %s | llc -mtriple=i686-apple-darwin9 -mattr=sse41 \
; റൺ: | FileCheck %s -check-prefix=X32
; റൺ: llvm-ആയി < %s | llc -mtriple=x86_64-apple-darwin9 -mattr=sse41 \
; റൺ: | FileCheck %s -check-prefix=X64

നിർവ്വചിക്കുക <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) നോൺവൈൻഡ് {
%tmp1 = തിരുകൽ <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
}

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ 32-ബിറ്റ് കൂടാതെ പ്രതീക്ഷിക്കുന്ന കോഡ് ജനറേഷൻ ലഭിക്കുമെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു
64-ബിറ്റ് കോഡ് ജനറേഷൻ.

ദി അടുത്തത് പരിശോധിക്കുക: നിർദേശം
ചിലപ്പോൾ നിങ്ങൾ ലൈനുകൾ പൊരുത്തപ്പെടുത്താൻ ആഗ്രഹിക്കുകയും പൊരുത്തങ്ങൾ കൃത്യമായി നടക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കാൻ ആഗ്രഹിക്കുകയും ചെയ്യും
അവയ്ക്കിടയിൽ മറ്റ് വരികളില്ലാത്ത തുടർച്ചയായ വരികൾ. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം "ചെക്ക്:"
ഒപ്പം "അടുത്തത് പരിശോധിക്കുക:" ഇത് വ്യക്തമാക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ. നിങ്ങൾ ഒരു ഇഷ്‌ടാനുസൃത ചെക്ക് പ്രിഫിക്‌സ് വ്യക്തമാക്കിയാൽ,
വെറുതെ ഉപയോഗിക്കുക"-അടുത്തത്:". ഉദാഹരണത്തിന്, ഇതുപോലുള്ള ഒന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് പോലെ പ്രവർത്തിക്കുന്നു:

അസാധുവായ @t2 (<2 x ഇരട്ട>* %r, <2 x ഇരട്ട>* %A, ഇരട്ടി %B) {
%tmp3 = ലോഡ് <2 x ഇരട്ടി>* %A, 16 അലൈൻ ചെയ്യുക
%tmp7 = ഉൾപ്പെടുത്തൽ <2 x ഇരട്ട> undef, ഇരട്ട %B, i32 0
%tmp9 = ഷഫിൾവെക്റ്റർ <2 x ഇരട്ട> %tmp3,
<2 x ഇരട്ടി> %tmp7,
<2 x i32> < i32 0, i32 2 >
സംഭരിക്കുക <2 x ഇരട്ട> %tmp9, <2 x ഇരട്ട>* %r, 16 അലൈൻ ചെയ്യുക
ശൂന്യത

; പരിശോധിക്കുക: t2:
; പരിശോധിക്കുക: movl 8(%esp), %eax
; അടുത്തത് പരിശോധിക്കുക: movapd (%eax), %xmm0
; അടുത്തത് പരിശോധിക്കുക: movhpd 12(%esp), %xmm0
; അടുത്തത് പരിശോധിക്കുക: movl 4(%esp), %eax
; അടുത്തത് പരിശോധിക്കുക: movapd %xmm0, (%eax)
; ചെക്ക്-അടുത്തത്: റിട്ട
}

"അടുത്തത് പരിശോധിക്കുക:"ഇൻപുട്ടിനുമിടയിൽ കൃത്യമായി ഒരു പുതിയ ലൈൻ ഇല്ലെങ്കിൽ നിർദ്ദേശങ്ങൾ നിരസിക്കുന്നു
മുൻ നിർദ്ദേശവും. എ"അടുത്തത് പരിശോധിക്കുക:" ഒരു ഫയലിലെ ആദ്യ നിർദ്ദേശമാകാൻ കഴിയില്ല.

ദി പരിശോധിക്കരുത്: നിർദേശം
"പരിശോധിക്കരുത്:"രണ്ടിനുമിടയിൽ ഒരു സ്ട്രിംഗ് സംഭവിക്കുന്നില്ലെന്ന് പരിശോധിക്കാൻ നിർദ്ദേശം ഉപയോഗിക്കുന്നു
മത്സരങ്ങൾ (അല്ലെങ്കിൽ ആദ്യ മത്സരത്തിന് മുമ്പോ അവസാന മത്സരത്തിന് ശേഷമോ). ഉദാഹരണത്തിന്, അത് പരിശോധിക്കാൻ
ഒരു പരിവർത്തനത്തിലൂടെ ഒരു ലോഡ് നീക്കംചെയ്യുന്നു, ഇതുപോലുള്ള ഒരു പരിശോധന ഉപയോഗിക്കാം:

i8 നിർവ്വചിക്കുക @coerce_offset0(i32 %V, i32* %P) {
i32 %V, i32* %P സംഭരിക്കുക

%P2 = ബിറ്റ്കാസ്റ്റ് i32* %P മുതൽ i8* വരെ
%P3 = getelementptr i8* %P2, i32 2

%A = ലോഡ് i8* %P3
ret i8 %A
; പരിശോധിക്കുക: @coerce_offset0
; പരിശോധിക്കുക-അല്ല: ലോഡ്
; പരിശോധിക്കുക: ret i8
}

ദി ചെക്ക്-ഡാഗ്: നിർദേശം
കർശനമായ ക്രമത്തിൽ സംഭവിക്കാത്ത സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുത്തേണ്ടത് ആവശ്യമാണെങ്കിൽ,
"ചെക്ക്-ഡാഗ്:" രണ്ട് മത്സരങ്ങൾക്കിടയിൽ (അല്ലെങ്കിൽ ആദ്യ മത്സരത്തിന് മുമ്പ്,
അല്ലെങ്കിൽ അവസാന മത്സരത്തിന് ശേഷം). ഉദാഹരണത്തിന്, ക്ലാങ് വിപരീത ക്രമത്തിൽ vtable ഗ്ലോബലുകൾ പുറപ്പെടുവിക്കുന്നു. ഉപയോഗിക്കുന്നത്
ചെക്ക്-ഡാഗ്:, നമുക്ക് ചെക്കുകൾ സ്വാഭാവിക ക്രമത്തിൽ സൂക്ഷിക്കാം:

// റൺ: %clang_cc1 %s -emit-llvm -o - | ഫയൽ ചെക്ക് %s

struct Foo {വെർച്വൽ ശൂന്യ രീതി(); };
ഫൂ എഫ്; // എമിറ്റ് vtable
// ചെക്ക്-ഡാഗ്: @_ZTV3Foo =

struct ബാർ {വെർച്വൽ ശൂന്യ രീതി(); };
ബാർ ബി;
// ചെക്ക്-ഡാഗ്: @_ZTV3Bar =

പരിശോധിക്കരുത്: നിർദ്ദേശങ്ങൾ കലർത്താം ചെക്ക്-ഡാഗ്: തമ്മിലുള്ള സ്ട്രിംഗുകൾ ഒഴിവാക്കാനുള്ള നിർദ്ദേശങ്ങൾ
ചുറ്റുമുള്ളവ ചെക്ക്-ഡാഗ്: നിർദ്ദേശങ്ങൾ. തത്ഫലമായി, ചുറ്റുപാടും ചെക്ക്-ഡാഗ്: നിർദ്ദേശങ്ങൾ
പുനഃക്രമീകരിക്കാൻ കഴിയില്ല, അതായത് എല്ലാ സംഭവങ്ങളും പൊരുത്തപ്പെടുന്നു ചെക്ക്-ഡാഗ്: മുമ്പ് പരിശോധിക്കരുത്: പാടില്ല
സംഭവങ്ങളുടെ പൊരുത്തപ്പെടുത്തലിന് പിന്നിൽ വീഴുക ചെക്ക്-ഡാഗ്: ശേഷം പരിശോധിക്കരുത്:. ഉദാഹരണത്തിന്,

; ചെക്ക്-ഡാഗ്: മുമ്പ്
; പരിശോധിക്കരുത്: അല്ല
; ചെക്ക്-ഡാഗ്: ശേഷം

ഈ കേസ് ഇൻപുട്ട് സ്ട്രിംഗുകൾ നിരസിക്കും മുന്നമേ അതിനുശേഷം സംഭവിക്കുന്നു ശേഷം.

പിടിച്ചെടുത്ത വേരിയബിളുകൾ ഉപയോഗിച്ച്, ചെക്ക്-ഡാഗ്: ഒരു DAG-യുടെ സാധുവായ ടോപ്പോളജിക്കൽ ഓർഡറിംഗുകളുമായി പൊരുത്തപ്പെടാൻ കഴിയും
ഒരു വേരിയബിളിന്റെ നിർവ്വചനം മുതൽ അതിന്റെ ഉപയോഗം വരെയുള്ള അറ്റങ്ങൾ. ഇത് ഉപയോഗപ്രദമാണ്, ഉദാ, നിങ്ങളുടെ
ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളറിൽ നിന്നുള്ള വ്യത്യസ്ത ഔട്ട്പുട്ട് സീക്വൻസുകളുമായി ടെസ്റ്റ് കേസുകൾ പൊരുത്തപ്പെടുത്തേണ്ടതുണ്ട്. വേണ്ടി
ഉദാഹരണത്തിന്,

; ചെക്ക്-ഡാഗ്: [[REG1:r[0-9]+]], r1, r2 ചേർക്കുക
; ചെക്ക്-ഡാഗ്: [[REG2:r[0-9]+]], r3, r4 ചേർക്കുക
; പരിശോധിക്കുക: mul r5, [[REG1]], [[REG2]]

ഈ സാഹചര്യത്തിൽ, ആ രണ്ടിന്റെ ഏതെങ്കിലും ഓർഡർ ചേർക്കുക നിർദ്ദേശങ്ങൾ അനുവദിക്കും.

നിങ്ങൾ നിർവചിക്കുകയാണെങ്കിൽ ഒപ്പം ഒരേ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു ചെക്ക്-ഡാഗ്: തടയുക, അറിഞ്ഞിരിക്കുക
നിർവചന നിയമം പൊരുത്തപ്പെടാൻ കഴിയും ശേഷം അതിന്റെ ഉപയോഗം.

അതിനാൽ, ഉദാഹരണത്തിന്, ചുവടെയുള്ള കോഡ് കടന്നുപോകും:

; ചെക്ക്-ഡാഗ്: vmov.32 [[REG2:d[0-9]+]][0]
; ചെക്ക്-ഡാഗ്: vmov.32 [[REG2]][1]
vmov.32 d0[1]
vmov.32 d0[0]

ഈ മറ്റൊരു കോഡ്, ചെയ്യില്ല:

; ചെക്ക്-ഡാഗ്: vmov.32 [[REG2:d[0-9]+]][0]
; ചെക്ക്-ഡാഗ്: vmov.32 [[REG2]][1]
vmov.32 d1[1]
vmov.32 d0[0]

ഇത് വളരെ ഉപയോഗപ്രദമാകുമെങ്കിലും, ഇത് അപകടകരമാണ്, കാരണം രജിസ്റ്ററിന്റെ കാര്യത്തിൽ
ക്രമം, നിങ്ങൾക്ക് ശക്തമായ ഒരു ഓർഡർ ഉണ്ടായിരിക്കണം (എഴുതുന്നതിന് മുമ്പ് വായിക്കുക, ഉപയോഗിക്കുന്നതിന് മുമ്പ് പകർത്തുക മുതലായവ). എങ്കിൽ
നിങ്ങൾ തിരയുന്ന നിർവചനം പൊരുത്തപ്പെടുന്നില്ല (കംപൈലറിലെ ഒരു ബഗ് കാരണം), അത്
ഉപയോഗത്തിൽ നിന്ന് കൂടുതൽ അകലെ പൊരുത്തപ്പെടുത്തുകയും യഥാർത്ഥ ബഗുകൾ മറയ്ക്കുകയും ചെയ്യാം.

അത്തരം സന്ദർഭങ്ങളിൽ, ഓർഡർ നടപ്പിലാക്കാൻ, DAG-ബ്ലോക്കുകൾക്കിടയിൽ ഒരു നോൺ-DAG നിർദ്ദേശം ഉപയോഗിക്കുക.

ദി ചെക്ക്-ലേബൽ: നിർദേശം
ചിലപ്പോൾ ഒന്നോ അതിലധികമോ ലോജിക്കൽ ബ്ലോക്കുകളായി വിഭജിച്ചിരിക്കുന്ന ഒന്നിലധികം ടെസ്റ്റുകൾ അടങ്ങിയ ഫയലിൽ
ചെക്ക്: പിന്നീടുള്ള ബ്ലോക്കിലെ വരികൾ പൊരുത്തപ്പെടുത്തുന്നതിലൂടെ നിർദ്ദേശങ്ങൾ അശ്രദ്ധമായി വിജയിച്ചേക്കാം. അതേസമയം ഒരു
പിശക് സാധാരണയായി ഒടുവിൽ ജനറേറ്റുചെയ്യും, പിശക് കാരണമായി ചെക്ക് ഫ്ലാഗുചെയ്‌തേക്കില്ല
യഥാർത്ഥത്തിൽ പ്രശ്നത്തിന്റെ യഥാർത്ഥ ഉറവിടവുമായി ഏതെങ്കിലും ബന്ധം വഹിക്കുക.

ഇത്തരം സന്ദർഭങ്ങളിൽ മികച്ച പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നതിന്, "ചെക്ക്-ലേബൽ:"നിർദ്ദേശം കഴിയും
ഉപയോഗിക്കും. ഇത് ഒരു സാധാരണ രീതിക്ക് സമാനമായി പരിഗണിക്കുന്നു പരിശോധിക്കുക ഫയൽചെക്ക് ഉണ്ടാക്കുന്നത് ഒഴികെയുള്ള നിർദ്ദേശം
നിർദ്ദേശവുമായി പൊരുത്തപ്പെടുന്ന ഒരു വരിയും പൊരുത്തപ്പെടുത്താൻ കഴിയില്ല എന്ന ഒരു അധിക അനുമാനം
നിലവിലുള്ള മറ്റേതെങ്കിലും ചെക്ക് ഇൻ പൊരുത്തം-ഫയലിന്റെ പേര്; ഇത് ലൈനുകൾക്കായി ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
ലേബലുകൾ അല്ലെങ്കിൽ മറ്റ് അദ്വിതീയ ഐഡന്റിഫയറുകൾ അടങ്ങിയിരിക്കുന്നു. ആശയപരമായി, സാന്നിധ്യം ചെക്ക്-ലേബൽ
ഇൻപുട്ട് സ്ട്രീമിനെ പ്രത്യേക ബ്ലോക്കുകളായി വിഭജിക്കുന്നു, അവ ഓരോന്നും സ്വതന്ത്രമായി പ്രോസസ്സ് ചെയ്യുന്നു,
തടയുന്നു a ചെക്ക്: ഒരു ബ്ലോക്കിലെ നിർദ്ദേശം മറ്റൊരു ബ്ലോക്കിലെ വരിയുമായി പൊരുത്തപ്പെടുന്നു. ഉദാഹരണത്തിന്,

നിർവചിക്കുക %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
എൻ‌ട്രി:
; ലേബൽ പരിശോധിക്കുക: C_ctor_base:
; പരിശോധിക്കുക: mov [[SAVETHIS:r[0-9]+]], r0
; പരിശോധിക്കുക: b A_ctor_base
; പരിശോധിക്കുക: mov r0, [[SAVETHIS]]
%0 = ബിറ്റ്കാസ്റ്റ് %struct.C* %this to %struct.A*
%കോൾ = ടെയിൽ കോൾ %struct.A* @A_ctor_base(%struct.A* %0)
%1 = ബിറ്റ്കാസ്റ്റ് %struct.C* %this to %struct.B*
%call2 = ടെയിൽ കോൾ %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
ret %struct.C* %ഇത്
}

നിർവചിക്കുക %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
എൻ‌ട്രി:
; ലേബൽ പരിശോധിക്കുക: D_ctor_base:

ഉപയോഗം ചെക്ക്-ലേബൽ: ഈ കേസിലെ നിർദ്ദേശങ്ങൾ മൂന്ന് ഉറപ്പാക്കുന്നു ചെക്ക്: നിർദ്ദേശങ്ങൾ
ശരീരവുമായി ബന്ധപ്പെട്ട വരികൾ മാത്രം സ്വീകരിക്കുക @C_ctor_base ഫംഗ്‌ഷൻ, ആണെങ്കിലും
ഫയലിൽ പിന്നീട് കണ്ടെത്തിയ വരികളുമായി പാറ്റേണുകൾ പൊരുത്തപ്പെടുന്നു. കൂടാതെ, ഈ മൂന്നിൽ ഒന്ന് ആണെങ്കിൽ ചെക്ക്:
നിർദ്ദേശങ്ങൾ പരാജയപ്പെടുന്നു, ഒന്നിലധികം അനുവദിച്ചുകൊണ്ട് അടുത്ത ബ്ലോക്കിലേക്ക് തുടരുന്നതിലൂടെ ഫയൽചെക്ക് വീണ്ടെടുക്കും
ടെസ്റ്റ് പരാജയങ്ങൾ ഒറ്റ അഭ്യർത്ഥനയിൽ കണ്ടെത്തണം.

അതിനൊന്നും നിർബന്ധമില്ല ചെക്ക്-ലേബൽ: നിർദ്ദേശങ്ങളിൽ അനുയോജ്യമായ സ്ട്രിംഗുകൾ അടങ്ങിയിരിക്കുന്നു
ഒരു ഉറവിടത്തിലോ ഔട്ട്‌പുട്ട് ഭാഷയിലോ ഉള്ള യഥാർത്ഥ വാക്യഘടന ലേബലുകൾ: അവ അദ്വിതീയമായി പൊരുത്തപ്പെടണം a
പരിശോധിച്ചുറപ്പിക്കുന്ന ഫയലിലെ ഒറ്റ വരി.

ചെക്ക്-ലേബൽ: നിർദ്ദേശങ്ങളിൽ വേരിയബിൾ നിർവചനങ്ങളോ ഉപയോഗങ്ങളോ അടങ്ങിയിരിക്കരുത്.

ഫയൽ ചെക്ക് മാതൃക പൊരുത്തപ്പെടുന്നു പദവിന്യാസം
"ചെക്ക്:" ഒപ്പം "പരിശോധിക്കരുത്:" നിർദ്ദേശങ്ങൾ രണ്ടും പൊരുത്തപ്പെടുന്നതിന് ഒരു പാറ്റേൺ എടുക്കുന്നു. മിക്ക ഉപയോഗങ്ങൾക്കും
FileCheck, ഫിക്സഡ് സ്ട്രിംഗ് മാച്ചിംഗ് തികച്ചും മതിയാകും. ചില കാര്യങ്ങൾക്ക്, കൂടുതൽ
പൊരുത്തപ്പെടുത്തലിന്റെ വഴക്കമുള്ള രൂപം ആവശ്യമാണ്. ഇത് പിന്തുണയ്ക്കുന്നതിന്, ഫയൽചെക്ക് വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു
ഇരട്ട ബ്രേസുകളാൽ ചുറ്റപ്പെട്ട, പൊരുത്തപ്പെടുന്ന സ്ട്രിംഗുകളിലെ പതിവ് എക്സ്പ്രഷനുകൾ: {{yourregex}}.
ഞങ്ങൾ ചെയ്യുന്ന ഭൂരിഭാഗം കാര്യങ്ങളിലും ഫിക്സഡ് സ്ട്രിംഗ് മാച്ചിംഗ് ഉപയോഗിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നതിനാൽ, ഫയൽചെക്കിന് ഉണ്ട്
റെഗുലർ ഉപയോഗിച്ച് ഫിക്സഡ് സ്ട്രിംഗ് മാച്ചിംഗ് മിക്സിംഗ് ആൻഡ് മാച്ചിംഗ് പിന്തുണയ്ക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്
ഭാവങ്ങൾ. ഇതുപോലുള്ള കാര്യങ്ങൾ എഴുതാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു:

; പരിശോധിക്കുക: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}

ഈ സാഹചര്യത്തിൽ, ESP രജിസ്റ്ററിൽ നിന്നുള്ള ഏത് ഓഫ്സെറ്റും അനുവദിക്കും, കൂടാതെ ഏത് xmm രജിസ്റ്ററും അനുവദിക്കും
അനുവദിക്കും.

പതിവ് പദപ്രയോഗങ്ങൾ ഇരട്ട ബ്രേസുകളാൽ ചുറ്റപ്പെട്ടിരിക്കുന്നതിനാൽ, അവ ദൃശ്യപരമായി വ്യത്യസ്തമാണ്,
കൂടാതെ സിയിൽ ഉള്ളതുപോലെ ഇരട്ട ബ്രേസുകൾക്കുള്ളിൽ നിങ്ങൾ രക്ഷപ്പെടൽ പ്രതീകങ്ങൾ ഉപയോഗിക്കേണ്ടതില്ല.
ഇൻപുട്ടിൽ നിന്ന് ഇരട്ട ബ്രേസുകൾ വ്യക്തമായി പൊരുത്തപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന അപൂർവ സന്ദർഭങ്ങളിൽ, നിങ്ങൾക്ക് കഴിയും
വൃത്തികെട്ട എന്തെങ്കിലും ഉപയോഗിക്കുക {{[{][{]}} നിങ്ങളുടെ മാതൃകയായി.

ഫയൽ ചെക്ക് വേരിയബിളുകൾ
ഒരു പാറ്റേണുമായി പൊരുത്തപ്പെടുത്തുന്നതും പിന്നീട് അത് പിന്നീട് സംഭവിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നതും പലപ്പോഴും ഉപയോഗപ്രദമാണ്
ഫയൽ. കോഡ്ജെൻ ടെസ്റ്റുകൾക്ക്, ഏത് രജിസ്റ്ററും അനുവദിക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാകും, എന്നാൽ അത് പരിശോധിച്ചുറപ്പിക്കുക
രജിസ്റ്റർ പിന്നീട് സ്ഥിരമായി ഉപയോഗിക്കുന്നു. ഇത് ചെയ്യാന്, ഫയൽ ചെക്ക് പേരുള്ള വേരിയബിളുകൾ ആകാൻ അനുവദിക്കുന്നു
പാറ്റേണുകളായി നിർവചിക്കുകയും പകരം വയ്ക്കുകയും ചെയ്തു. ഒരു ലളിതമായ ഉദാഹരണം ഇതാ:

; പരിശോധിക്കുക: test5:
; പരിശോധിക്കുക: ഇപ്പോൾ [[രജിസ്റ്റർ:%[az]+]]
; പരിശോധിക്കുക: andw {{.*}}[[ReGISTER]]

ആദ്യ ചെക്ക് ലൈൻ ഒരു റീജക്സുമായി പൊരുത്തപ്പെടുന്നു %[az]+ അത് വേരിയബിളിലേക്ക് പിടിച്ചെടുക്കുകയും ചെയ്യുന്നു രജിസ്റ്റർ ചെയ്യുക.
രണ്ടാമത്തെ വരി അതിൽ ഉള്ളത് എന്താണെന്ന് സ്ഥിരീകരിക്കുന്നു രജിസ്റ്റർ ചെയ്യുക ഒരു ശേഷം ഫയലിൽ പിന്നീട് സംഭവിക്കുന്നത്
"andw". ഫയൽ ചെക്ക് വേരിയബിൾ റഫറൻസുകൾ എപ്പോഴും അടങ്ങിയിരിക്കുന്നു [[ ]] ജോഡികൾ, അവരുടെ
റീജക്സ് ഉപയോഗിച്ച് പേരുകൾ രൂപീകരിക്കാം [a-zA-Z][a-zA-Z0-9]*. ഒരു കോളൻ പേര് പിന്തുടരുകയാണെങ്കിൽ,
അപ്പോൾ അത് വേരിയബിളിന്റെ ഒരു നിർവചനമാണ്; അല്ലെങ്കിൽ, അത് ഒരു ഉപയോഗമാണ്.

ഫയൽ ചെക്ക് വേരിയബിളുകൾ ഒന്നിലധികം തവണ നിർവചിക്കാം, ഉപയോഗത്തിന് എല്ലായ്പ്പോഴും ഏറ്റവും പുതിയ മൂല്യം ലഭിക്കും.
വേരിയബിളുകൾ നിർവചിച്ച അതേ വരിയിൽ പിന്നീട് ഉപയോഗിക്കാനും കഴിയും. ഉദാഹരണത്തിന്:

; പരിശോധിക്കുക: op [[REG:r[0-9]+]], [[REG]]

ഇതിന്റെ ഓപ്പറണ്ടുകൾ വേണമെങ്കിൽ ഉപയോഗപ്രദമാകും op ഒരേ രജിസ്റ്ററായിരിക്കാൻ, അത് കാര്യമാക്കേണ്ടതില്ല
കൃത്യമായി അത് ഏത് രജിസ്റ്ററാണ്.

ഫയൽ ചെക്ക് ഭാവങ്ങൾ
ചിലപ്പോൾ മാച്ച് ഫയലിന്റെ ലൈൻ നമ്പറുകളെ സൂചിപ്പിക്കുന്ന ഔട്ട്പുട്ട് പരിശോധിക്കേണ്ട ആവശ്യമുണ്ട്,
ഉദാ: കമ്പൈലർ ഡയഗ്നോസ്റ്റിക്സ് പരിശോധിക്കുമ്പോൾ. ഇത് മത്സരത്തിന്റെ ഒരു പ്രത്യേക ദുർബലത അവതരിപ്പിക്കുന്നു
ഫയൽ ഘടന, "ചെക്ക്:"വരികളിൽ ഒരേ ഫയലിൽ സമ്പൂർണ്ണ ലൈൻ നമ്പറുകൾ അടങ്ങിയിരിക്കുന്നു
ടെക്സ്റ്റ് കൂട്ടിച്ചേർക്കലോ ഇല്ലാതാക്കലോ കാരണം ലൈൻ നമ്പറുകൾ മാറുമ്പോഴെല്ലാം അപ്ഡേറ്റ് ചെയ്യണം.

ഈ കേസ് പിന്തുണയ്ക്കാൻ, FileCheck ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു [[@LINE]], [[@LINE+ ]],
[[@LINE- ]] പാറ്റേണുകളിലെ പദപ്രയോഗങ്ങൾ. ഈ പദപ്രയോഗങ്ങൾ പലതിലേക്കും വ്യാപിക്കുന്നു
ഒരു പാറ്റേൺ സ്ഥിതി ചെയ്യുന്ന ലൈൻ (ഒരു ഓപ്ഷണൽ പൂർണ്ണസംഖ്യ ഓഫ്സെറ്റിനൊപ്പം).

ഈ രീതിയിൽ മാച്ച് പാറ്റേണുകൾ പ്രസക്തമായ ടെസ്റ്റ് ലൈനുകൾക്ക് സമീപം സ്ഥാപിക്കുകയും ആപേക്ഷിക ലൈൻ ഉൾപ്പെടുത്തുകയും ചെയ്യാം
നമ്പർ റഫറൻസുകൾ, ഉദാഹരണത്തിന്:

// പരിശോധിക്കുക: test.cpp:[[@LINE+4]]:6: പിശക്: പ്രതീക്ഷിക്കുന്നത് ';' ടോപ്പ് ലെവൽ ഡിക്ലറേറ്ററിന് ശേഷം
// ചെക്ക്-അടുത്തത്: {{^int a}}
// ചെക്ക്-അടുത്തത്: {{^ \^}}
// ചെക്ക്-അടുത്തത്: {{^ ;}}
int a

Onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് FileCheck-3.6 ഓൺലൈനായി ഉപയോഗിക്കുക