FileCheck-3.6 - Онлайн в облаке

ПРОГРАММА:

ИМЯ

FileCheck - Гибкий верификатор файла сопоставления с шаблоном

СИНТАКСИС

ФайлПроверка имя-файла [--check-prefix = XXX] [--строгие пробелы]

ОПИСАНИЕ

ФайлПроверка читает два файла (один из стандартного ввода и один, указанный в командной строке)
и использует одно для проверки другого. Это поведение особенно полезно для набора тестов,
который хочет проверить, что вывод какого-либо инструмента (например, ооо) содержит ожидаемый
информация (например, movsd от esp или что там интересно). Это похоже
на использование GREP, но он оптимизирован для сопоставления нескольких разных входных данных в одном файле в
конкретный заказ.

Ассоциация имя-файла file указывает файл, содержащий шаблоны для сопоставления. Файл
для проверки читается со стандартного ввода, если только - входной файл опция используется.

ДОПОЛНИТЕЛЬНЫЕ УСЛУГИ, НЕ ВКЛЮЧЕННЫЕ В ПАКЕТ

-Помощь Распечатайте сводку параметров командной строки.

--check-префикс префикс
FileCheck ищет содержимое имя-файла для соответствия шаблонам. К
по умолчанию эти шаблоны имеют префикс "ПРОВЕРЯТЬ:". Если вы хотите использовать
другой префикс (например, потому что один и тот же входной файл проверяет несколько разных
инструмент или параметры), --check-префикс аргумент позволяет указать один или несколько
префиксы для соответствия. Множественные префиксы полезны для тестов, которые могут измениться для
разные варианты запуска, но большинство строк остается прежним.

- входной файл имя файла
Файл для проверки (по умолчанию - стандартный ввод).

--строгие пробелы
По умолчанию FileCheck канонизирует вводимые горизонтальные пробелы (пробелы и табуляции)
что заставляет его игнорировать эти различия (пробел соответствует табуляции). В
--строгие пробелы аргумент отключает это поведение. Конечные последовательности
канонизирован в стиле UNIX \n во всех режимах.

--implicit-check-not шаблон проверки
Добавляет неявные отрицательные проверки для указанных шаблонов между положительными проверками.
Опция позволяет писать более строгие тесты, не забивая их ПРОВЕРИТЬ-НЕs.

Например, "--implicit-check-not предупреждение:"может быть полезно при тестировании диагностических
сообщения от инструментов, у которых нет опции, подобной лязг -проверять. С этим
опция FileCheck проверит, что ввод не содержит предупреждений, не охваченных
любой ПРОВЕРЯТЬ: узоры.

-версия
Покажите номер версии этой программы.

ВЫХОД статус

If ФайлПроверка проверяет, соответствует ли файл ожидаемому содержимому, завершается с 0.
В противном случае, если нет или возникнет ошибка, он выйдет с ненулевым значением.

Обучение

FileCheck обычно используется из регрессионных тестов LLVM, вызывая его в строке RUN
тест. Простой пример использования FileCheck из строки RUN выглядит так:

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

Этот синтаксис говорит о передаче текущего файла по конвейеру ("%s") в llvm-как, вставьте это в ооо, то
труба выход ооо в ФайлПроверка. Это означает, что FileCheck будет проверять свое
стандартный ввод (вывод llc) по указанному аргументу имени файла (исходный .ll
файл, указанный в "%s"). Чтобы увидеть, как это работает, давайте посмотрим на остальные .ll файл
(после строки RUN):

определить void @ sub1 (i32 *% p, i32% v) {
запись:
; ПРОВЕРИТЬ: sub1:
; ПРОВЕРИТЬ: subl
% 0 = хвостовой вызов i32 @ llvm.atomic.load.sub.i32.p0i32 (i32 *% p, i32% v)
ret недействителен
}

определить void @ inc4 (i64 *% p) {
запись:
; ПРОВЕРИТЬ: inc4:
; ПРОВЕРИТЬ: incq
% 0 = хвостовой вызов i64 @ llvm.atomic.load.add.i64.p0i64 (i64 *% p, i64 1)
ret недействителен
}

Здесь вы можете увидеть несколько "ПРОВЕРЯТЬ:"строки, указанные в комментариях. Теперь вы можете увидеть, как файл
подключен к llvm-как, то ооо, а вывод машинного кода - это то, что мы проверяем.
FileCheck проверяет вывод машинного кода, чтобы убедиться, что он соответствует "ПРОВЕРЯТЬ:"линии
уточнить.

Синтаксис оператора "ПРОВЕРЯТЬ:"строки очень просты: это фиксированные строки, которые должны встречаться в
порядок. FileCheck по умолчанию игнорирует различия в горизонтальных пробелах (например, пробел
разрешено совпадать с табуляцией), но в противном случае содержимое "ПРОВЕРЯТЬ:"строка требуется для
точно совпадают с чем-то в тестовом файле.

Одна хорошая вещь в FileCheck (по сравнению с grep) заключается в том, что он позволяет объединять тестовые примеры
вместе в логические группы. Например, поскольку приведенный выше тест проверяет наличие
"суб1:, а такжевкл4:"метки, он не будет совпадать, если нет"субл"между этими
этикетки. Если бы он существовал где-то еще в файле, это не учитывалось бы: "GREP субл"
соответствует, если "субл"существует где-нибудь в файле.

Ассоциация ФайлПроверка -check-префикс вариант
FileCheck -check-префикс опция позволяет запускать несколько тестовых конфигураций из
one .ll файл. Это полезно во многих случаях, например, при тестировании различных
архитектурные варианты с ооо. Вот простой пример:

; RUN: llvm-as <% s | llc -mtriple = i686-яблоко-darwin9 -mattr = sse41 \
; ЗАПУСК: | FileCheck% s -check-prefix = X32
; RUN: llvm-as <% s | llc -mtriple = x86_64-яблоко-darwin9 -mattr = sse41 \
; ЗАПУСК: | FileCheck% s -check-prefix = X64

define <4 x i32> @ pinsrd_1 (i32% s, <4 x i32>% tmp) nounwind {
% tmp1 = insertlement <4 x i32>; % tmp, i32% s, i32 1
ret <4 x i32>% tmp1
; X32: контактыrd_1:
; X32: контакты $ 1, 4 (% esp),% xmm0

; X64: контактыrd_1:
; X64: pinsrd $ 1,% edi,% xmm0
}

В этом случае мы проверяем, что получаем ожидаемую генерацию кода как для 32-битных, так и для
Генерация 64-битного кода.

Ассоциация ПРОВЕРИТЬ СЛЕДУЮЩИЙ: Директивы
Иногда вы хотите сопоставить строки и хотите убедиться, что совпадения происходят точно в
последовательные строки без каких-либо других строк между ними. В этом случае вы можете использовать "ПРОВЕРЯТЬ:"
и "ПРОВЕРИТЬ СЛЕДУЮЩИЙ:"директивы, чтобы указать это. Если вы указали настраиваемый префикс проверки,
просто используйте "-СЛЕДУЮЩИЙ:". Например, что-то вроде этого работает, как и следовало ожидать:

define void @ t2 (<2 x double> *% r, <2 x double> *% A, double% B) {
% tmp3 = load <2 x double> *% A, выровнять 16
% tmp7 = insertlement <2 x double> undef, double% B, i32 0
% tmp9 = shufflevector <2 x double>% tmp3,
<2 x двойной>% tmp7,
<2 x i32> <i32 0, i32 2>
store <2 x double>% tmp9, <2 x double> *% r, выровнять 16
ret недействителен

; ПРОВЕРИТЬ: t2:
; ПРОВЕРИТЬ: movl 8 (% esp),% eax
; ПРОВЕРИТЬ СЛЕДУЮЩИЙ: movapd (% eax),% xmm0
; ПРОВЕРИТЬ СЛЕДУЮЩИЙ: movhpd 12 (% esp),% xmm0
; ПРОВЕРИТЬ СЛЕДУЮЩИЙ: movl 4 (% esp),% eax
; ПРОВЕРИТЬ СЛЕДУЮЩИЙ: movapd% xmm0, (% eax)
; ПРОВЕРИТЬ СЛЕДУЮЩИЙ: ret
}

"ПРОВЕРИТЬ СЛЕДУЮЩИЙ:директивы отклоняют ввод, если между ними нет ровно одной новой строки
и предыдущая директива. А "ПРОВЕРИТЬ СЛЕДУЮЩИЙ:"не может быть первой директивой в файле.

Ассоциация ПРОВЕРИТЬ-НЕ: Директивы
"ПРОВЕРИТЬ-НЕ:"директива используется для проверки того, что строка не встречается между двумя
совпадений (либо до первого матча, либо после последнего матча). Например, чтобы убедиться, что
нагрузка снимается преобразованием, можно использовать такой тест:

определить i8 @ coerce_offset0 (i32% V, i32 *% P) {
сохранить i32% V, i32 *% P

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

% A = нагрузка i8 *% P3
ret i8% A
; ПРОВЕРИТЬ: @ coerce_offset0
; ПРОВЕРИТЬ-НЕ: загрузить
; ПРОВЕРИТЬ: ret i8
}

Ассоциация ПРОВЕРКА-ДАГ: Директивы
Если необходимо сопоставить строки, которые не встречаются в строго последовательном порядке,
"ПРОВЕРКА-ДАГ:"можно использовать для проверки их между двумя совпадениями (или перед первым совпадением,
или после последнего матча). Например, clang генерирует глобальные переменные vtable в обратном порядке. С использованием
ПРОВЕРКА-ДАГ:, мы можем хранить чеки в естественном порядке:

// ЗАПУСК:% clang_cc1% s -emit-llvm -o - | FileCheck% s

struct Foo {виртуальный метод void (); };
Foo f; // испускаем vtable
// CHECK-DAG: @ _ZTV3Foo =

struct Bar {виртуальный метод void (); };
Бар b;
// 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_base:
; ПРОВЕРИТЬ: mov [[СОХРАНИТЬ: r [0-9] +]], r0
; ПРОВЕРИТЬ: bl A_ctor_base
; ПРОВЕРИТЬ: mov r0, [[СОХРАНИТЬ]]
% 0 = bitcast% struct.C *% это в% struct.A *
% call = хвостовой вызов% struct.A * @A_ctor_base (% struct.A *% 0)
% 1 = bitcast% struct.C *% это в% 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 функция, даже если
шаблоны соответствуют строкам, найденным позже в файле. Кроме того, если один из этих трех ПРОВЕРЯТЬ:
директивы не работают, FileCheck восстановится, перейдя к следующему блоку, позволяя несколько
сбои тестов должны быть обнаружены за один вызов.

Нет требования, чтобы ПРОВЕРИТЬ ЭТИКЕТКУ: директивы содержат строки, соответствующие
фактические синтаксические метки в исходном или выходном языке: они должны просто однозначно соответствовать
одна строка в проверяемом файле.

ПРОВЕРИТЬ ЭТИКЕТКУ: директивы не могут содержать определения или использования переменных.

ФайлПроверка шаблон Согласование Синтаксис
"ПРОВЕРЯТЬ:, а такжеПРОВЕРИТЬ-НЕ:обе директивы используют шаблон для сопоставления. Для большинства случаев использования
FileCheck, фиксированного соответствия строк вполне достаточно. Для некоторых вещей более
желательна гибкая форма сопоставления. Для поддержки этого FileCheck позволяет указать
регулярные выражения в соответствующих строках, заключенные в двойные фигурные скобки: {{yourregex}}.
Поскольку мы хотим использовать фиксированное сопоставление строк для большей части того, что мы делаем, FileCheck имеет
был разработан для поддержки смешивания и сопоставления фиксированной строки с обычным
выражения. Это позволяет писать такие вещи:

; ПРОВЕРИТЬ: movhpd {{[0-9] +}} (% esp), {{% xmm [0-7]}}

В этом случае любое смещение из регистра ESP будет разрешено, а любой регистр xmm будет
разрешено.

Поскольку регулярные выражения заключены в двойные фигурные скобки, они визуально различимы,
и вам не нужно использовать escape-символы в двойных фигурных скобках, как в C.
В том редком случае, когда вы хотите явно сопоставить двойные фигурные скобки из входных данных, вы можете
использовать что-нибудь уродливое вроде {{[{][{]}} как ваш образец.

ФайлПроверка Переменные
Часто бывает полезно сопоставить шаблон, а затем убедиться, что он повторяется позже в
файл. Для тестов кодогенерации это может быть полезно, чтобы разрешить любую регистрацию, но убедитесь, что
Регистр последовательно используется и позже. Сделать это, ФайлПроверка позволяет именованным переменным быть
определены и подставлены в шаблоны. Вот простой пример:

; ПРОВЕРИТЬ: test5:
; ПРОВЕРИТЬ: notw [[РЕГИСТРАЦИЯ:% [az] +]]
; ПРОВЕРИТЬ: andw {{. *}} [[РЕГИСТРАЦИЯ]]

Первая контрольная строка соответствует регулярному выражению % [az] + и записывает его в переменную РЕГИСТРАЦИЯ.
Вторая строка проверяет, что все, что находится в РЕГИСТРАЦИЯ появляется позже в файле после
"ив". ФайлПроверка ссылки на переменные всегда содержатся в [[ ]] пары, а их
имена могут быть сформированы с помощью регулярного выражения [a-zA-Z] [a-zA-Z0-9] *. Если после имени следует двоеточие,
тогда это определение переменной; в противном случае это использование.

ФайлПроверка переменные можно определять несколько раз, и при использовании всегда получается последнее значение.
Переменные также можно использовать позже в той же строке, в которой они были определены. Например:

; ПРОВЕРКА: op [[REG: r [0-9] +]], [[REG]]

Может быть полезно, если вам нужны операнды op быть в том же регистре, и все равно
какой именно регистр.

ФайлПроверка Expressions
Иногда возникает необходимость проверить вывод, который ссылается на номера строк файла соответствия,
например, при тестировании диагностики компилятора. Это вносит определенную хрупкость матча.
файловая структура, как "ПРОВЕРЯТЬ:"строки содержат абсолютные номера строк в том же файле, что
должны обновляться всякий раз, когда номера строк меняются из-за добавления или удаления текста.

Для поддержки этого случая FileCheck позволяет использовать [[@ЛИНИЯ]], [[@ LINE + ]],
[[@ЛИНИЯ- ]] выражения в узорах. Эти выражения расширяются до ряда
строка, в которой расположен шаблон (с необязательным целочисленным смещением).

Таким образом, шаблоны соответствия могут быть размещены рядом с соответствующими тестовыми линиями и включать относительную линию.
числовые ссылки, например:

// ПРОВЕРКА: test.cpp: [[@ LINE + 4]]: 6: ошибка: ожидается ';' после декларатора верхнего уровня
// ПРОВЕРИТЬ СЛЕДУЮЩИЙ: {{^ int a}}
// ПРОВЕРИТЬ СЛЕДУЮЩИЙ: {{^ \ ^}}
// ПРОВЕРИТЬ СЛЕДУЮЩИЙ: {{^;}}
в

Используйте FileCheck-3.6 онлайн с помощью сервисов onworks.net