FileCheck-3.8 - מקוון בענן

תָכְנִית:

שֵׁם

FileCheck - אימות קבצים גמיש להתאמת תבניות

תַקצִיר

בדיקת קבצים שם-קובץ-התאמה [--קידומת-בדיקה=XXX] [--strict-whitespace]

תיאור

בדיקת קבצים קורא שני קבצים (אחד מקלט סטנדרטי, ואחד שצוין בשורת הפקודה)
ומשתמש באחד כדי לאמת את השני. התנהגות זו שימושית במיוחד עבור חבילת הבדיקות,
אשר רוצה לוודא שהפלט של כלי כלשהו (למשל llc) מכיל את הצפוי
מידע (לדוגמה, movsd מ-esp או כל דבר אחר שמעניין). זה דומה
לשימוש grep, אבל הוא מותאם במיוחד להתאמת מספר קלטים שונים בקובץ אחד ב-
סדר ספציפי.

השמיים שם-קובץ-התאמה קובץ מציין את הקובץ שמכיל את התבניות התואמות. הקובץ
כדי לאמת נקרא מקלט סטנדרטי אלא אם כן --קובץ קלט נעשה שימוש באופציה.

אפשרויות

עזרה הדפס סיכום של אפשרויות שורת הפקודה.

--קידומת-בדיקה קידומת
FileCheck מחפש את התוכן של שם-קובץ-התאמה לתבניות שיתאימו. על ידי
ברירת מחדל, תבניות אלו מקודמות ב-"חשבון:אם תרצו להשתמש ב-
קידומת שונה (למשל, מכיוון שאותו קובץ קלט בודק מספר קובץ קלט שונים
כלי או אפשרויות), ה --קידומת-בדיקה ארגומנט מאפשר לך לציין אחד או יותר
קידומות תואמות. קידומות מרובות שימושיות עבור בדיקות שעשויות להשתנות עבור
אפשרויות ריצה שונות, אבל רוב הקווים נשארים זהים.

--קובץ קלט שם הקובץ
קובץ לבדיקה (ברירת מחדל היא stdin).

--strict-whitespace
כברירת מחדל, FileCheck הופך רווחים אופקיים לקלט (רווחים וטאבים) לקנוניים.
מה שגורם לו להתעלם מההבדלים הללו (רווח יתאים לטאב).
--strict-whitespace הארגומנט מבטל התנהגות זו. רצפי סוף שורה הם
קנוניזציה בסגנון יוניקס \n בכל המצבים.

--implicit-check-not דפוס משבצות
מוסיף בדיקות שליליות מרומזות עבור הדפוסים שצוינו בין בדיקות חיוביות.
האפשרות מאפשרת כתיבת מבחנים מחמירים יותר מבלי למלא אותם ב... לא לבדוקs.

לדוגמה, "--implicit-check-not אַזהָרָה:"יכול להיות שימושי בעת בדיקות אבחון
הודעות מכלים שאין להם אפשרות דומה ל- מקשקש -תאשר. עם זה
האפשרות FileCheck תוודא שהקלט אינו מכיל אזהרות שאינן מכוסות על ידי
כל חשבון: דפוסי.

-הפך
הצג את מספר הגרסה של תוכנית זו.

יְצִיאָה סטָטוּס

If בדיקת קבצים מאמת שהקובץ תואם את התוכן הצפוי, הוא מסתיים עם 0.
אחרת, אם לא, או אם מתרחשת שגיאה, הוא יסתיים עם ערך שאינו אפס.

הדרכה

FileCheck משמש בדרך כלל מבדיקות רגרסיה של LLVM, כשהוא מופעל בשורת RUN של
הבדיקה. דוגמה פשוטה לשימוש ב-FileCheck משורת RUN נראית כך:

; RUN: llvm-as < %s | llc -march=x86-64 | בדיקת קבצים %s

תחביר זה אומר להעביר את הקובץ הנוכחי ("%s") לתוך llvm-as, להכניס את זה לתוך llc, לאחר מכן
צינור הפלט של llc אל תוך בדיקת קבציםמשמעות הדבר היא ש-FileCheck יאמת את
קלט סטנדרטי (פלט llc) כנגד ארגומנט שם הקובץ שצוין (המקורי .ll
קובץ שצוין על ידי "%s"). כדי לראות איך זה עובד, בואו נסתכל על שאר .ll פילה
(אחרי שורת RUN):

הגדר חלל @sub1(i32* %p, i32 %v) {
כְּנִיסָה:
; בדיקה: תת-קבוצה 1:
; בדיקה: תת-שכבתי
%0 = קריאה ל- tail i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
חלל ריק
}

הגדר חלל @inc4(i64* %p) {
כְּנִיסָה:
; בדיקה: inc4:
בדיקה: כולל
%0 = קריאה ל- tail i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
חלל ריק
}

כאן תוכלו לראות כמה "חשבון:"שורות שצוינו בהערות. כעת תוכלו לראות כיצד הקובץ
מוכנס לתוך llvm-as, לאחר מכן llc, ופלט קוד המכונה הוא מה שאנחנו מאמתים.
FileCheck בודק את פלט קוד המכונה כדי לוודא שהוא תואם את מה ש-"חשבון:"קווים
לפרט.

התחביר של ה"חשבון:"שורות הן פשוטות מאוד: הן מחרוזות קבועות שחייבות להופיע ב
סדר. ברירת המחדל של FileCheck היא להתעלם מהבדלי רווחים אופקיים (לדוגמה, רווח הוא
מותר להתאים לטאב) אבל אחרת, התוכן של "חשבון:"יש צורך בשורה כדי
להתאים בדיוק למשהו בקובץ הבדיקה.

דבר נחמד אחד ב-FileCheck (בהשוואה ל-grep) הוא שהוא מאפשר מיזוג מקרי בדיקה.
יחד לקבוצות לוגיות. לדוגמה, מכיוון שהבדיקה לעיל בודקת את
"תת-קבוצה 1:"ו"inc4:"תוויות, זה לא יתאים אלא אם כן יש"סאבלי"בין אלה
תוויות. אם זה היה קיים במקום אחר בקובץ, זה לא היה נחשב: "grep סאבלי"
תואם אם "סאבלי"קיים בכל מקום בקובץ.

השמיים בדיקת קבצים קידומת -check אוֹפְּצִיָה
בדיקת הקבצים קידומת -check האפשרות מאפשרת הפעלה של מספר תצורות בדיקה מ
אחד .ll קובץ. זה שימושי בנסיבות רבות, לדוגמה, בדיקת מגוון
וריאנטים אדריכליים עם llcהנה דוגמה פשוטה:

; 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

הגדר <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp)
%tmp1 = insertelement <4 x i32>; %tmp, i32 %s, i32 1
רזולוציה <4 x i32> %tmp1
; X32: פינים rd_1:
; X32: פינים $1, 4(%esp), %xmm0

; X64: פינים rd_1:
; X64: פינים $1, %edi, %xmm0
}

במקרה זה, אנו בודקים שאנו מקבלים את יצירת הקוד הצפויה הן עם 32 סיביות והן עם
יצירת קוד של 64 סיביות.

השמיים בדיקה הבאה: הוראה
לפעמים אתה רוצה להתאים קווים ולוודא שהתאמות מתרחשות בדיוק
שורות רצופות ללא שורות נוספות ביניהן. במקרה זה, ניתן להשתמש ב-"חשבון:"
ובדיקה הבאה:"הוראות כדי לציין זאת. אם ציינת קידומת בדיקה מותאמת אישית,
פשוט להשתמש ב"-הַבָּא:". לדוגמה, משהו כזה עובד כצפוי:

הגדר חלל @t2(<2 x כפול>* %r, <2 x כפול>* %A, כפול %B) {
%tmp3 = טען <2 x כפול>* %A, יישור 16
%tmp7 = insertelement <2 x double> undef, double %B, i32 0
%tmp9 = וקטור ערבוב <2 x כפול> %tmp3,
<2 כפול> %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)
; בדיקה-הבא: ret
}

"בדיקה הבאה:"הוראות דוחות את הקלט אלא אם כן יש בדיוק שורה חדשה אחת ביניהם"
וההנחיה הקודמת. א "בדיקה הבאה:"לא יכולה להיות ההנחיה הראשונה בקובץ.

השמיים בדיקה-אותו דבר: הוראה
לפעמים אתה רוצה להתאים קווים ולוודא שהתאמות מתרחשות באותו
שורה כמו ההתאמה הקודמת. במקרה זה, ניתן להשתמש ב-"חשבון:"ו"בדיקה-אותו דבר:"
הנחיות כדי לציין זאת. אם ציינת קידומת בדיקה מותאמת אישית, פשוט השתמש
"-אוֹתוֹ:".

"בדיקה-אותו דבר:"עוצמתי במיוחד בשילוב עם"לא לבדוק:" (מתואר בהמשך).

לדוגמה, הפעולות הבאות פועלות כפי שניתן היה לצפות:

!0 = !DILocation(שורה: 5, היקף: !1, inlinedAt: !2)

; בדיקה: !DILocation(שורה: 5,
; בדיקה-לא: עמודה:
; בדיקה-אותו: היקף: ![[היקף:[0-9]+]]

"בדיקה-אותו דבר:"הוראות דוחות את הקלט אם יש שורות חדשות בינו לבין ה-"
הנחיה קודמת. א "בדיקה-אותו דבר:"לא יכולה להיות ההנחיה הראשונה בקובץ.

השמיים לא לבדוק: הוראה
ה "לא לבדוק:ההנחיה "משמשת כדי לוודא שאין מחרוזת בין שניים
משחקים (או לפני המשחק הראשון, או אחרי המשחק האחרון). לדוגמה, כדי לוודא ש
כאשר עומס מוסר על ידי טרנספורמציה, ניתן להשתמש בבדיקה כזו:

הגדר את i8 @coerce_offset0(i32 %V, i32* %P) {
אחסון i32 %V, i32* %P

%P2 = ביטקאסט i32* %P ל-i8*
%P3 = getelementptr i8* %P2, i32 2

%A = עומס i8* %P3
רט i8 %A
; בדיקה: @coerce_offset0
; בדיקה-לא: טעינה
; בדיקה: ret i8
}

השמיים בדיקה-יום: הוראה
אם יש צורך להתאים מחרוזות שאינן מופיעות בסדר עוקב לחלוטין,
"בדיקה-יום:"יכול לשמש כדי לאמת אותם בין שני משחקים (או לפני המשחק הראשון,
או אחרי המשחק האחרון). לדוגמה, clang פולט פונקציות גלובליות של vtable בסדר הפוך. שימוש
בדיקה-יום:, נוכל לשמור על הבדיקות בסדר הטבעי:

// הפעלה: %clang_cc1 %s -emit-llvm -o - | בדיקת קבצים %s

struct Foo { שיטת void וירטואלי (); };
Foo f; // פליטת vtable
// הזמנה מראש: @_ZTV3Foo =

struct Bar { שיטת חלל וירטואלי (); };
בר ב;
// CHECK-DAG: @_ZTV3Bar =

לא לבדוק: ניתן לערבב הנחיות עם בדיקה-יום: הוראות להחרגת מחרוזות בין
הסובב בדיקה-יום: הנחיות. כתוצאה מכך, הסביבה בדיקה-יום: הנחיות
לא ניתן לסדר מחדש, כלומר כל המופעים תואמים בדיקה-יום: לפני לא לבדוק: אסור לי
התאמת מופעים מאחור בדיקה-יום: לאחר לא לבדוק:. לדוגמה,

יום בדיקה: לפני
; בדיקה-לא: לא
; יום בדיקה: לאחר

מקרה זה ידחה מחרוזות קלט כאשר לפני מתרחש לאחר לאחר.

עם משתנים שנלכדו, בדיקה-יום: מסוגל להתאים סדרים טופולוגיים תקפים של DAG
עם קצוות מהגדרת משתנה ועד לשימוש בו. זה שימושי, למשל, כאשר שלך
מקרי בדיקה צריכים להתאים לרצפי פלט שונים ממתזמן ההוראות.
דוגמא,

; CHECK-DAG: הוסף [[REG1:r[0-9]+]], r1, r2
; CHECK-DAG: הוסף [[REG2:r[0-9]+]], r3, r4
; בדיקה: mul r5, [[REG1]], [[REG2]]

במקרה זה, כל סדר מבין שני אלה להוסיף הוראות יהיו מותרות.

אם אתה מגדיר ו באמצעות משתנים באותו בדיקה-יום: בלוק, שימו לב ש-
כלל ההגדרה יכול להתאים לאחר השימוש של זה.

כך, לדוגמה, הקוד הבא יעבור:

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

בעוד שקוד אחר זה לא יעשה זאת:

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

אמנם זה יכול להיות מאוד שימושי, אבל זה גם מסוכן, כי במקרה של רישום
רצף, עליך להיות בעל סדר ברור (לקרוא לפני כתיבה, להעתיק לפני שימוש וכו'). אם ה
ההגדרה שהבדיקה שלך מחפשת אינה תואמת (בגלל באג בקומפיילר), היא
עשוי להתאים רחוק יותר מהשימוש, ולהסתיר באגים אמיתיים.

במקרים אלה, כדי לאכוף את ההוראה, השתמש בהוראת שאינה DAG בין בלוקי DAG.

השמיים תווית בדיקה: הוראה
לפעמים בקובץ המכיל מספר בדיקות המחולקות לבלוקים לוגיים, אחד או יותר
חשבון: הוראות עלולות להצליח בטעות על ידי התאמת שורות בבלוק מאוחר יותר. בעוד ש
בדרך כלל תיווצר שגיאה בסופו של דבר, ייתכן שהבדיקה שסומנה כגורמת לשגיאה לא תיווצר
אין להם קשר כלשהו למקור הבעיה בפועל.

על מנת לייצר הודעות שגיאה טובות יותר במקרים אלה, ה-"תווית בדיקה:"ההנחיה יכולה
לשימוש. הוא מטופל באופן זהה לרגיל לבדוק ההנחיה פרט לכך ש-FileCheck יוצר
הנחה נוספת ששורה שתואמת להנחיה לא יכולה להיות תואמת גם על ידי
כל צ'ק אחר הקיים ב שם-קובץ-התאמה; זה מיועד לשימוש עבור קווים
המכילים תוויות או מזהים ייחודיים אחרים. מבחינה מושגית, נוכחות של תווית בדיקה
מחלק את זרם הקלט לבלוקים נפרדים, שכל אחד מהם מעובד באופן עצמאי,
מניעת חשבון: הוראה בבלוק אחד תואמת שורה בבלוק אחר. לדוגמה,

הגדר %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
כְּנִיסָה:
; תווית בדיקה: בסיס_C_ctor:
; בדיקה: mov [[SAVETHIS:r[0-9]+]], r0
; בדיקה: בסיס A_ctor
; בדיקה: mov r0, [[שמור זאת]]
%0 = ביטקאסט %struct.C* %this ל- %struct.A*
%call = קריאה זנבית %struct.A* @A_ctor_base(%struct.A* %0)
%1 = ביטקאסט %struct.C* %this ל- %struct.B*
%call2 = קריאה אחורית %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
שמור %struct.C* %this
}

הגדר %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
כְּנִיסָה:
תווית בדיקה: בסיס_דקטור:

השימוש של תווית בדיקה: ההנחיות במקרה זה מבטיחות ששלושת חשבון: הנחיות
קבל רק שורות התואמות לגוף ה- @C_ctor_base פונקציה, גם אם ה-
תבניות תואמות לקווים שנמצאו בהמשך הקובץ. יתר על כן, אם אחת משלושת אלה חשבון:
הנחיות נכשלות, FileCheck יתאושש על ידי המשך לבלוק הבא, מה שיאפשר מספר רב של
כשלי בדיקה שיזוהו בקריאה אחת.

אין דרישה ש תווית בדיקה: הנחיות מכילות מחרוזות התואמות ל-
תוויות תחביריות ממשיות בשפת מקור או פלט: הן חייבות פשוט להתאים באופן ייחודי ל
שורה בודדת בקובץ המאומת.

תווית בדיקה: הנחיות אינן יכולות להכיל הגדרות או שימושים של משתנים.

בדיקת קבצים תבנית תואם תחביר
כל הנחיות FileCheck מקבלות תבנית תואמת. עבור רוב השימושים של FileCheck, קבוע
התאמת מחרוזות מספיקה לחלוטין. עבור דברים מסוימים, צורה גמישה יותר של
התאמה רצויה. כדי לתמוך בכך, FileCheck מאפשר לך לציין ביטויים רגולריים
במחרוזות תואמות, מוקפות בסוגריים כפולים: {{yourregex}}כי אנחנו רוצים להשתמש
התאמת מחרוזות קבועה עבור רוב מה שאנחנו עושים, FileCheck תוכנן לתמוך
ערבוב והתאמה של התאמת מחרוזות קבועה עם ביטויים רגולריים. זה מאפשר לך
כתוב דברים כאלה:

; בדיקה: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}

במקרה זה, כל היסט מאוגר ESP יותר, וכל אוגר xmm יעשה זאת.
להיות מותר.

מכיוון שביטויים רגולריים מוקפים בסוגריים כפולים, הם שונים מבחינה ויזואלית,
ואתה לא צריך להשתמש בתווי בריחה בתוך הסוגריים הכפולים כמו שהיית עושה ב-C.
במקרה הנדיר שתרצו להתאים סוגריים כפולים במפורש מהקלט, תוכלו
להשתמש במשהו מכוער כמו {{[{][{]}} כדוגמתך.

בדיקת קבצים משתנים
לעתים קרובות זה שימושי להתאים דפוס ולאחר מכן לוודא שהוא מתרחש שוב בהמשך
קובץ. עבור בדיקות קוד-יצירתיות, זה יכול להיות שימושי כדי לאפשר כל רישום, אך ודא ש
רישום משמש באופן עקבי בהמשך. לשם כך, בדיקת קבצים מאפשר שימוש במשתנים בעלי שם
מוגדרים ומוחלפים בתבניות. הנה דוגמה פשוטה:

בדיקה: בדיקה 5:
; בדיקה: לא [[הרשמה:%[az]+]]
; בדיקה: andw {{.*}}[[הרשמה]]

שורת הבדיקה הראשונה תואמת לביטוי רגולרי %[az]+ ולוכד אותו לתוך המשתנה להירשם.
השורה השנייה מאמתת שכל מה שנמצא בפנים להירשם מתרחש בהמשך הקובץ לאחר
"אנדו". בדיקת קבצים הפניות למשתנים תמיד כלולות ב [[ ]] זוגות, ושלהם
ניתן ליצור שמות בעזרת ביטוי רגולרי [א-ז-א][א-ז-א-ת-0-9]*אם נקודתיים מופיעים אחרי השם,
אז זוהי הגדרה של המשתנה; אחרת, זהו שימוש.

בדיקת קבצים ניתן להגדיר משתנים מספר פעמים, ושימושים תמיד מקבלים את הערך העדכני ביותר.
ניתן להשתמש במשתנים גם מאוחר יותר באותה שורה בה הוגדרו. לדוגמה:

; בדיקה: הפעלה [[REG:r[0-9]+]], [[REG]]

יכול להיות שימושי אם אתה רוצה את האופרנדים של op להיות אותו רישום, ולא אכפת לי
בדיוק באיזה רישום מדובר.

בדיקת קבצים ביטויים
לפעמים יש צורך לאמת פלט שמפנה למספרי שורות של קובץ ההתאמה,
לדוגמה בעת בדיקת אבחון מהדר. זה יוצר שבריריות מסוימת של ההתאמה.
מבנה הקובץ, כמו "חשבון:"שורות מכילות מספרי שורות מוחלטים באותו קובץ, אשר
יש לעדכן בכל פעם שמספרי שורות משתנים עקב הוספה או מחיקה של טקסט.

כדי לתמוך בטענה זו, FileCheck מאפשר שימוש [[@קַו]], [[@LINE+ ]],
[[@קַו- ]] ביטויים בתבניות. ביטויים אלה מתרחבים למספר מה
קו שבו נמצאת תבנית (עם היסט שלם אופציונלי).

בדרך זו ניתן למקם דפוסי התאמה ליד קווי הבדיקה הרלוונטיים ולכלול קווים יחסיים
מספרי הפניות, לדוגמה:

// בדיקה: test.cpp:[[@LINE+4]]:6: שגיאה: צפוי ';' לאחר הצהרתו ברמה העליונה
// בדיקה הבאה: {{^int a}}
// בדיקה הבאה: {{^ \^}}
// בדיקה הבאה: {{^ ;}}
בתוך א

השתמש ב-FileCheck-3.8 באופן מקוון באמצעות שירותי onworks.net