-FileCheck - Flexible pattern matching file verifier\r
-===================================================\r
-\r
-.. program:: FileCheck\r
-\r
-SYNOPSIS\r
---------\r
-\r
-:program:`FileCheck` *match-filename* [*--check-prefix=XXX*] [*--strict-whitespace*]\r
-\r
-DESCRIPTION\r
------------\r
-\r
-:program:`FileCheck` reads two files (one from standard input, and one\r
-specified on the command line) and uses one to verify the other. This\r
-behavior is particularly useful for the testsuite, which wants to verify that\r
-the output of some tool (e.g. :program:`llc`) contains the expected information\r
-(for example, a movsd from esp or whatever is interesting). This is similar to\r
-using :program:`grep`, but it is optimized for matching multiple different\r
-inputs in one file in a specific order.\r
-\r
-The ``match-filename`` file specifies the file that contains the patterns to\r
-match. The file to verify is read from standard input unless the\r
-:option:`--input-file` option is used.\r
-\r
-OPTIONS\r
--------\r
-\r
-Options are parsed from the environment variable ``FILECHECK_OPTS``\r
-and from the command line.\r
-\r
-.. option:: -help\r
-\r
- Print a summary of command line options.\r
-\r
-.. option:: --check-prefix prefix\r
-\r
- FileCheck searches the contents of ``match-filename`` for patterns to\r
- match. By default, these patterns are prefixed with "``CHECK:``".\r
- If you'd like to use a different prefix (e.g. because the same input\r
- file is checking multiple different tool or options), the\r
- :option:`--check-prefix` argument allows you to specify one or more\r
- prefixes to match. Multiple prefixes are useful for tests which might\r
- change for different run options, but most lines remain the same.\r
-\r
-.. option:: --check-prefixes prefix1,prefix2,...\r
-\r
- An alias of :option:`--check-prefix` that allows multiple prefixes to be\r
- specified as a comma separated list.\r
-\r
-.. option:: --input-file filename\r
-\r
- File to check (defaults to stdin).\r
-\r
-.. option:: --match-full-lines\r
-\r
- By default, FileCheck allows matches of anywhere on a line. This\r
- option will require all positive matches to cover an entire\r
- line. Leading and trailing whitespace is ignored, unless\r
- :option:`--strict-whitespace` is also specified. (Note: negative\r
- matches from ``CHECK-NOT`` are not affected by this option!)\r
-\r
- Passing this option is equivalent to inserting ``{{^ *}}`` or\r
- ``{{^}}`` before, and ``{{ *$}}`` or ``{{$}}`` after every positive\r
- check pattern.\r
-\r
-.. option:: --strict-whitespace\r
-\r
- By default, FileCheck canonicalizes input horizontal whitespace (spaces and\r
- tabs) which causes it to ignore these differences (a space will match a tab).\r
- The :option:`--strict-whitespace` argument disables this behavior. End-of-line\r
- sequences are canonicalized to UNIX-style ``\n`` in all modes.\r
-\r
-.. option:: --ignore-case\r
-\r
- By default, FileCheck uses case-sensitive matching. This option causes\r
- FileCheck to use case-insensitive matching.\r
-\r
-.. option:: --implicit-check-not check-pattern\r
-\r
- Adds implicit negative checks for the specified patterns between positive\r
- checks. The option allows writing stricter tests without stuffing them with\r
- ``CHECK-NOT``\ s.\r
-\r
- For example, "``--implicit-check-not warning:``" can be useful when testing\r
- diagnostic messages from tools that don't have an option similar to ``clang\r
- -verify``. With this option FileCheck will verify that input does not contain\r
- warnings not covered by any ``CHECK:`` patterns.\r
-\r
-.. option:: --dump-input <mode>\r
-\r
- Dump input to stderr, adding annotations representing currently enabled\r
- diagnostics. Do this either 'always', on 'fail', or 'never'. Specify 'help'\r
- to explain the dump format and quit.\r
-\r
-.. option:: --dump-input-on-failure\r
-\r
- When the check fails, dump all of the original input. This option is\r
- deprecated in favor of `--dump-input=fail`.\r
-\r
-.. option:: --enable-var-scope\r
-\r
- Enables scope for regex variables.\r
-\r
- Variables with names that start with ``$`` are considered global and\r
- remain set throughout the file.\r
-\r
- All other variables get undefined after each encountered ``CHECK-LABEL``.\r
-\r
-.. option:: -D<VAR=VALUE>\r
-\r
- Sets a filecheck pattern variable ``VAR`` with value ``VALUE`` that can be\r
- used in ``CHECK:`` lines.\r
-\r
-.. option:: -D#<NUMVAR>=<NUMERIC EXPRESSION>\r
-\r
- Sets a filecheck numeric variable ``NUMVAR`` to the result of evaluating\r
- ``<NUMERIC EXPRESSION>`` that can be used in ``CHECK:`` lines. See section\r
- ``FileCheck Numeric Variables and Expressions`` for details on supported\r
- numeric expressions.\r
-\r
-.. option:: -version\r
-\r
- Show the version number of this program.\r
-\r
-.. option:: -v\r
-\r
- Print good directive pattern matches. However, if ``-input-dump=fail`` or\r
- ``-input-dump=always``, add those matches as input annotations instead.\r
-\r
-.. option:: -vv\r
-\r
- Print information helpful in diagnosing internal FileCheck issues, such as\r
- discarded overlapping ``CHECK-DAG:`` matches, implicit EOF pattern matches,\r
- and ``CHECK-NOT:`` patterns that do not have matches. Implies ``-v``.\r
- However, if ``-input-dump=fail`` or ``-input-dump=always``, just add that\r
- information as input annotations instead.\r
-\r
-.. option:: --allow-deprecated-dag-overlap\r
-\r
- Enable overlapping among matches in a group of consecutive ``CHECK-DAG:``\r
- directives. This option is deprecated and is only provided for convenience\r
- as old tests are migrated to the new non-overlapping ``CHECK-DAG:``\r
- implementation.\r
-\r
-.. option:: --color\r
-\r
- Use colors in output (autodetected by default).\r
-\r
-EXIT STATUS\r
------------\r
-\r
-If :program:`FileCheck` verifies that the file matches the expected contents,\r
-it exits with 0. Otherwise, if not, or if an error occurs, it will exit with a\r
-non-zero value.\r
-\r
-TUTORIAL\r
---------\r
-\r
-FileCheck is typically used from LLVM regression tests, being invoked on the RUN\r
-line of the test. A simple example of using FileCheck from a RUN line looks\r
-like this:\r
-\r
-.. code-block:: llvm\r
-\r
- ; RUN: llvm-as < %s | llc -march=x86-64 | FileCheck %s\r
-\r
-This syntax says to pipe the current file ("``%s``") into ``llvm-as``, pipe\r
-that into ``llc``, then pipe the output of ``llc`` into ``FileCheck``. This\r
-means that FileCheck will be verifying its standard input (the llc output)\r
-against the filename argument specified (the original ``.ll`` file specified by\r
-"``%s``"). To see how this works, let's look at the rest of the ``.ll`` file\r
-(after the RUN line):\r
-\r
-.. code-block:: llvm\r
-\r
- define void @sub1(i32* %p, i32 %v) {\r
- entry:\r
- ; CHECK: sub1:\r
- ; CHECK: subl\r
- %0 = tail call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)\r
- ret void\r
- }\r
-\r
- define void @inc4(i64* %p) {\r
- entry:\r
- ; CHECK: inc4:\r
- ; CHECK: incq\r
- %0 = tail call i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)\r
- ret void\r
- }\r
-\r
-Here you can see some "``CHECK:``" lines specified in comments. Now you can\r
-see how the file is piped into ``llvm-as``, then ``llc``, and the machine code\r
-output is what we are verifying. FileCheck checks the machine code output to\r
-verify that it matches what the "``CHECK:``" lines specify.\r
-\r
-The syntax of the "``CHECK:``" lines is very simple: they are fixed strings that\r
-must occur in order. FileCheck defaults to ignoring horizontal whitespace\r
-differences (e.g. a space is allowed to match a tab) but otherwise, the contents\r
-of the "``CHECK:``" line is required to match some thing in the test file exactly.\r
-\r
-One nice thing about FileCheck (compared to grep) is that it allows merging\r
-test cases together into logical groups. For example, because the test above\r
-is checking for the "``sub1:``" and "``inc4:``" labels, it will not match\r
-unless there is a "``subl``" in between those labels. If it existed somewhere\r
-else in the file, that would not count: "``grep subl``" matches if "``subl``"\r
-exists anywhere in the file.\r
-\r
-The FileCheck -check-prefix option\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-The FileCheck `-check-prefix` option allows multiple test\r
-configurations to be driven from one `.ll` file. This is useful in many\r
-circumstances, for example, testing different architectural variants with\r
-:program:`llc`. Here's a simple example:\r
-\r
-.. code-block:: llvm\r
-\r
- ; RUN: llvm-as < %s | llc -mtriple=i686-apple-darwin9 -mattr=sse41 \\r
- ; RUN: | FileCheck %s -check-prefix=X32\r
- ; RUN: llvm-as < %s | llc -mtriple=x86_64-apple-darwin9 -mattr=sse41 \\r
- ; RUN: | FileCheck %s -check-prefix=X64\r
-\r
- define <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) nounwind {\r
- %tmp1 = insertelement <4 x i32>; %tmp, i32 %s, i32 1\r
- ret <4 x i32> %tmp1\r
- ; X32: pinsrd_1:\r
- ; X32: pinsrd $1, 4(%esp), %xmm0\r
-\r
- ; X64: pinsrd_1:\r
- ; X64: pinsrd $1, %edi, %xmm0\r
- }\r
-\r
-In this case, we're testing that we get the expected code generation with\r
-both 32-bit and 64-bit code generation.\r
-\r
-The "CHECK-NEXT:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-Sometimes you want to match lines and would like to verify that matches\r
-happen on exactly consecutive lines with no other lines in between them. In\r
-this case, you can use "``CHECK:``" and "``CHECK-NEXT:``" directives to specify\r
-this. If you specified a custom check prefix, just use "``<PREFIX>-NEXT:``".\r
-For example, something like this works as you'd expect:\r
-\r
-.. code-block:: llvm\r
-\r
- define void @t2(<2 x double>* %r, <2 x double>* %A, double %B) {\r
- %tmp3 = load <2 x double>* %A, align 16\r
- %tmp7 = insertelement <2 x double> undef, double %B, i32 0\r
- %tmp9 = shufflevector <2 x double> %tmp3,\r
- <2 x double> %tmp7,\r
- <2 x i32> < i32 0, i32 2 >\r
- store <2 x double> %tmp9, <2 x double>* %r, align 16\r
- ret void\r
-\r
- ; CHECK: t2:\r
- ; CHECK: movl 8(%esp), %eax\r
- ; CHECK-NEXT: movapd (%eax), %xmm0\r
- ; CHECK-NEXT: movhpd 12(%esp), %xmm0\r
- ; CHECK-NEXT: movl 4(%esp), %eax\r
- ; CHECK-NEXT: movapd %xmm0, (%eax)\r
- ; CHECK-NEXT: ret\r
- }\r
-\r
-"``CHECK-NEXT:``" directives reject the input unless there is exactly one\r
-newline between it and the previous directive. A "``CHECK-NEXT:``" cannot be\r
-the first directive in a file.\r
-\r
-The "CHECK-SAME:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-Sometimes you want to match lines and would like to verify that matches happen\r
-on the same line as the previous match. In this case, you can use "``CHECK:``"\r
-and "``CHECK-SAME:``" directives to specify this. If you specified a custom\r
-check prefix, just use "``<PREFIX>-SAME:``".\r
-\r
-"``CHECK-SAME:``" is particularly powerful in conjunction with "``CHECK-NOT:``"\r
-(described below).\r
-\r
-For example, the following works like you'd expect:\r
-\r
-.. code-block:: llvm\r
-\r
- !0 = !DILocation(line: 5, scope: !1, inlinedAt: !2)\r
-\r
- ; CHECK: !DILocation(line: 5,\r
- ; CHECK-NOT: column:\r
- ; CHECK-SAME: scope: ![[SCOPE:[0-9]+]]\r
-\r
-"``CHECK-SAME:``" directives reject the input if there are any newlines between\r
-it and the previous directive. A "``CHECK-SAME:``" cannot be the first\r
-directive in a file.\r
-\r
-The "CHECK-EMPTY:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-If you need to check that the next line has nothing on it, not even whitespace,\r
-you can use the "``CHECK-EMPTY:``" directive.\r
-\r
-.. code-block:: llvm\r
-\r
- declare void @foo()\r
-\r
- declare void @bar()\r
- ; CHECK: foo\r
- ; CHECK-EMPTY:\r
- ; CHECK-NEXT: bar\r
-\r
-Just like "``CHECK-NEXT:``" the directive will fail if there is more than one\r
-newline before it finds the next blank line, and it cannot be the first\r
-directive in a file.\r
-\r
-The "CHECK-NOT:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-The "``CHECK-NOT:``" directive is used to verify that a string doesn't occur\r
-between two matches (or before the first match, or after the last match). For\r
-example, to verify that a load is removed by a transformation, a test like this\r
-can be used:\r
-\r
-.. code-block:: llvm\r
-\r
- define i8 @coerce_offset0(i32 %V, i32* %P) {\r
- store i32 %V, i32* %P\r
-\r
- %P2 = bitcast i32* %P to i8*\r
- %P3 = getelementptr i8* %P2, i32 2\r
-\r
- %A = load i8* %P3\r
- ret i8 %A\r
- ; CHECK: @coerce_offset0\r
- ; CHECK-NOT: load\r
- ; CHECK: ret i8\r
- }\r
-\r
-The "CHECK-COUNT:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-If you need to match multiple lines with the same pattern over and over again\r
-you can repeat a plain ``CHECK:`` as many times as needed. If that looks too\r
-boring you can instead use a counted check "``CHECK-COUNT-<num>:``", where\r
-``<num>`` is a positive decimal number. It will match the pattern exactly\r
-``<num>`` times, no more and no less. If you specified a custom check prefix,\r
-just use "``<PREFIX>-COUNT-<num>:``" for the same effect.\r
-Here is a simple example:\r
-\r
-.. code-block:: text\r
-\r
- Loop at depth 1\r
- Loop at depth 1\r
- Loop at depth 1\r
- Loop at depth 1\r
- Loop at depth 2\r
- Loop at depth 3\r
-\r
- ; CHECK-COUNT-6: Loop at depth {{[0-9]+}}\r
- ; CHECK-NOT: Loop at depth {{[0-9]+}}\r
-\r
-The "CHECK-DAG:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-If it's necessary to match strings that don't occur in a strictly sequential\r
-order, "``CHECK-DAG:``" could be used to verify them between two matches (or\r
-before the first match, or after the last match). For example, clang emits\r
-vtable globals in reverse order. Using ``CHECK-DAG:``, we can keep the checks\r
-in the natural order:\r
-\r
-.. code-block:: c++\r
-\r
- // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s\r
-\r
- struct Foo { virtual void method(); };\r
- Foo f; // emit vtable\r
- // CHECK-DAG: @_ZTV3Foo =\r
-\r
- struct Bar { virtual void method(); };\r
- Bar b;\r
- // CHECK-DAG: @_ZTV3Bar =\r
-\r
-``CHECK-NOT:`` directives could be mixed with ``CHECK-DAG:`` directives to\r
-exclude strings between the surrounding ``CHECK-DAG:`` directives. As a result,\r
-the surrounding ``CHECK-DAG:`` directives cannot be reordered, i.e. all\r
-occurrences matching ``CHECK-DAG:`` before ``CHECK-NOT:`` must not fall behind\r
-occurrences matching ``CHECK-DAG:`` after ``CHECK-NOT:``. For example,\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK-DAG: BEFORE\r
- ; CHECK-NOT: NOT\r
- ; CHECK-DAG: AFTER\r
-\r
-This case will reject input strings where ``BEFORE`` occurs after ``AFTER``.\r
-\r
-With captured variables, ``CHECK-DAG:`` is able to match valid topological\r
-orderings of a DAG with edges from the definition of a variable to its use.\r
-It's useful, e.g., when your test cases need to match different output\r
-sequences from the instruction scheduler. For example,\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK-DAG: add [[REG1:r[0-9]+]], r1, r2\r
- ; CHECK-DAG: add [[REG2:r[0-9]+]], r3, r4\r
- ; CHECK: mul r5, [[REG1]], [[REG2]]\r
-\r
-In this case, any order of that two ``add`` instructions will be allowed.\r
-\r
-If you are defining `and` using variables in the same ``CHECK-DAG:`` block,\r
-be aware that the definition rule can match `after` its use.\r
-\r
-So, for instance, the code below will pass:\r
-\r
-.. code-block:: text\r
-\r
- ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]\r
- ; CHECK-DAG: vmov.32 [[REG2]][1]\r
- vmov.32 d0[1]\r
- vmov.32 d0[0]\r
-\r
-While this other code, will not:\r
-\r
-.. code-block:: text\r
-\r
- ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]\r
- ; CHECK-DAG: vmov.32 [[REG2]][1]\r
- vmov.32 d1[1]\r
- vmov.32 d0[0]\r
-\r
-While this can be very useful, it's also dangerous, because in the case of\r
-register sequence, you must have a strong order (read before write, copy before\r
-use, etc). If the definition your test is looking for doesn't match (because\r
-of a bug in the compiler), it may match further away from the use, and mask\r
-real bugs away.\r
-\r
-In those cases, to enforce the order, use a non-DAG directive between DAG-blocks.\r
-\r
-A ``CHECK-DAG:`` directive skips matches that overlap the matches of any\r
-preceding ``CHECK-DAG:`` directives in the same ``CHECK-DAG:`` block. Not only\r
-is this non-overlapping behavior consistent with other directives, but it's\r
-also necessary to handle sets of non-unique strings or patterns. For example,\r
-the following directives look for unordered log entries for two tasks in a\r
-parallel program, such as the OpenMP runtime:\r
-\r
-.. code-block:: text\r
-\r
- // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin\r
- // CHECK-DAG: [[THREAD_ID]]: task_end\r
- //\r
- // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin\r
- // CHECK-DAG: [[THREAD_ID]]: task_end\r
-\r
-The second pair of directives is guaranteed not to match the same log entries\r
-as the first pair even though the patterns are identical and even if the text\r
-of the log entries is identical because the thread ID manages to be reused.\r
-\r
-The "CHECK-LABEL:" directive\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-Sometimes in a file containing multiple tests divided into logical blocks, one\r
-or more ``CHECK:`` directives may inadvertently succeed by matching lines in a\r
-later block. While an error will usually eventually be generated, the check\r
-flagged as causing the error may not actually bear any relationship to the\r
-actual source of the problem.\r
-\r
-In order to produce better error messages in these cases, the "``CHECK-LABEL:``"\r
-directive can be used. It is treated identically to a normal ``CHECK``\r
-directive except that FileCheck makes an additional assumption that a line\r
-matched by the directive cannot also be matched by any other check present in\r
-``match-filename``; this is intended to be used for lines containing labels or\r
-other unique identifiers. Conceptually, the presence of ``CHECK-LABEL`` divides\r
-the input stream into separate blocks, each of which is processed independently,\r
-preventing a ``CHECK:`` directive in one block matching a line in another block.\r
-If ``--enable-var-scope`` is in effect, all local variables are cleared at the\r
-beginning of the block.\r
-\r
-For example,\r
-\r
-.. code-block:: llvm\r
-\r
- define %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {\r
- entry:\r
- ; CHECK-LABEL: C_ctor_base:\r
- ; CHECK: mov [[SAVETHIS:r[0-9]+]], r0\r
- ; CHECK: bl A_ctor_base\r
- ; CHECK: mov r0, [[SAVETHIS]]\r
- %0 = bitcast %struct.C* %this to %struct.A*\r
- %call = tail call %struct.A* @A_ctor_base(%struct.A* %0)\r
- %1 = bitcast %struct.C* %this to %struct.B*\r
- %call2 = tail call %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)\r
- ret %struct.C* %this\r
- }\r
-\r
- define %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {\r
- entry:\r
- ; CHECK-LABEL: D_ctor_base:\r
-\r
-The use of ``CHECK-LABEL:`` directives in this case ensures that the three\r
-``CHECK:`` directives only accept lines corresponding to the body of the\r
-``@C_ctor_base`` function, even if the patterns match lines found later in\r
-the file. Furthermore, if one of these three ``CHECK:`` directives fail,\r
-FileCheck will recover by continuing to the next block, allowing multiple test\r
-failures to be detected in a single invocation.\r
-\r
-There is no requirement that ``CHECK-LABEL:`` directives contain strings that\r
-correspond to actual syntactic labels in a source or output language: they must\r
-simply uniquely match a single line in the file being verified.\r
-\r
-``CHECK-LABEL:`` directives cannot contain variable definitions or uses.\r
-\r
-FileCheck Regex Matching Syntax\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-All FileCheck directives take a pattern to match.\r
-For most uses of FileCheck, fixed string matching is perfectly sufficient. For\r
-some things, a more flexible form of matching is desired. To support this,\r
-FileCheck allows you to specify regular expressions in matching strings,\r
-surrounded by double braces: ``{{yourregex}}``. FileCheck implements a POSIX\r
-regular expression matcher; it supports Extended POSIX regular expressions\r
-(ERE). Because we want to use fixed string matching for a majority of what we\r
-do, FileCheck has been designed to support mixing and matching fixed string\r
-matching with regular expressions. This allows you to write things like this:\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}\r
-\r
-In this case, any offset from the ESP register will be allowed, and any xmm\r
-register will be allowed.\r
-\r
-Because regular expressions are enclosed with double braces, they are\r
-visually distinct, and you don't need to use escape characters within the double\r
-braces like you would in C. In the rare case that you want to match double\r
-braces explicitly from the input, you can use something ugly like\r
-``{{[}][}]}}`` as your pattern. Or if you are using the repetition count\r
-syntax, for example ``[[:xdigit:]]{8}`` to match exactly 8 hex digits, you\r
-would need to add parentheses like this ``{{([[:xdigit:]]{8})}}`` to avoid\r
-confusion with FileCheck's closing double-brace.\r
-\r
-FileCheck String Substitution Blocks\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-It is often useful to match a pattern and then verify that it occurs again\r
-later in the file. For codegen tests, this can be useful to allow any\r
-register, but verify that that register is used consistently later. To do\r
-this, :program:`FileCheck` supports string substitution blocks that allow\r
-string variables to be defined and substituted into patterns. Here is a simple\r
-example:\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK: test5:\r
- ; CHECK: notw [[REGISTER:%[a-z]+]]\r
- ; CHECK: andw {{.*}}[[REGISTER]]\r
-\r
-The first check line matches a regex ``%[a-z]+`` and captures it into the\r
-string variable ``REGISTER``. The second line verifies that whatever is in\r
-``REGISTER`` occurs later in the file after an "``andw``". :program:`FileCheck`\r
-string substitution blocks are always contained in ``[[ ]]`` pairs, and string\r
-variable names can be formed with the regex ``[a-zA-Z_][a-zA-Z0-9_]*``. If a\r
-colon follows the name, then it is a definition of the variable; otherwise, it\r
-is a substitution.\r
-\r
-:program:`FileCheck` variables can be defined multiple times, and substitutions\r
-always get the latest value. Variables can also be substituted later on the\r
-same line they were defined on. For example:\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK: op [[REG:r[0-9]+]], [[REG]]\r
-\r
-Can be useful if you want the operands of ``op`` to be the same register,\r
-and don't care exactly which register it is.\r
-\r
-If ``--enable-var-scope`` is in effect, variables with names that\r
-start with ``$`` are considered to be global. All others variables are\r
-local. All local variables get undefined at the beginning of each\r
-CHECK-LABEL block. Global variables are not affected by CHECK-LABEL.\r
-This makes it easier to ensure that individual tests are not affected\r
-by variables set in preceding tests.\r
-\r
-FileCheck Numeric Substitution Blocks\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-:program:`FileCheck` also supports numeric substitution blocks that allow\r
-defining numeric variables and checking for numeric values that satisfy a\r
-numeric expression constraint based on those variables via a numeric\r
-substitution. This allows ``CHECK:`` directives to verify a numeric relation\r
-between two numbers, such as the need for consecutive registers to be used.\r
-\r
-The syntax to define a numeric variable is ``[[#<NUMVAR>:]]`` where\r
-``<NUMVAR>`` is the name of the numeric variable to define to the matching\r
-value.\r
-\r
-For example:\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK: mov r[[#REG:]], 42\r
-\r
-would match ``mov r5, 42`` and set ``REG`` to the value ``5``.\r
-\r
-The syntax of a numeric substitution is ``[[#<expr>]]`` where ``<expr>`` is an\r
-expression. An expression is recursively defined as:\r
-\r
-* a numeric operand, or\r
-* an expression followed by an operator and a numeric operand.\r
-\r
-A numeric operand is a previously defined numeric variable, or an integer\r
-literal. The supported operators are ``+`` and ``-``. Spaces are accepted\r
-before, after and between any of these elements.\r
-\r
-For example:\r
-\r
-.. code-block:: llvm\r
-\r
- ; CHECK: load r[[#REG:]], [r0]\r
- ; CHECK: load r[[#REG+1]], [r1]\r
-\r
-The above example would match the text:\r
-\r
-.. code-block:: gas\r
-\r
- load r5, [r0]\r
- load r6, [r1]\r
-\r
-but would not match the text:\r
-\r
-.. code-block:: gas\r
-\r
- load r5, [r0]\r
- load r7, [r1]\r
-\r
-due to ``7`` being unequal to ``5 + 1``.\r
-\r
-The syntax also supports an empty expression, equivalent to writing {{[0-9]+}},\r
-for cases where the input must contain a numeric value but the value itself\r
-does not matter:\r
-\r
-.. code-block:: gas\r
-\r
- ; CHECK-NOT: mov r0, r[[#]]\r
-\r
-to check that a value is synthesized rather than moved around.\r
-\r
-A numeric variable can also be defined to the result of a numeric expression,\r
-in which case the numeric expression is checked and if verified the variable is\r
-assigned to the value. The unified syntax for both defining numeric variables\r
-and checking a numeric expression is thus ``[[#<NUMVAR>: <expr>]]`` with each\r
-element as described previously.\r
-\r
-The ``--enable-var-scope`` option has the same effect on numeric variables as\r
-on string variables.\r
-\r
-Important note: In its current implementation, an expression cannot use a\r
-numeric variable defined earlier in the same CHECK directive.\r
-\r
-FileCheck Pseudo Numeric Variables\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-Sometimes there's a need to verify output that contains line numbers of the\r
-match file, e.g. when testing compiler diagnostics. This introduces a certain\r
-fragility of the match file structure, as "``CHECK:``" lines contain absolute\r
-line numbers in the same file, which have to be updated whenever line numbers\r
-change due to text addition or deletion.\r
-\r
-To support this case, FileCheck expressions understand the ``@LINE`` pseudo\r
-numeric variable which evaluates to the line number of the CHECK pattern where\r
-it is found.\r
-\r
-This way match patterns can be put near the relevant test lines and include\r
-relative line number references, for example:\r
-\r
-.. code-block:: c++\r
-\r
- // CHECK: test.cpp:[[# @LINE + 4]]:6: error: expected ';' after top level declarator\r
- // CHECK-NEXT: {{^int a}}\r
- // CHECK-NEXT: {{^ \^}}\r
- // CHECK-NEXT: {{^ ;}}\r
- int a\r
-\r
-To support legacy uses of ``@LINE`` as a special string variable,\r
-:program:`FileCheck` also accepts the following uses of ``@LINE`` with string\r
-substitution block syntax: ``[[@LINE]]``, ``[[@LINE+<offset>]]`` and\r
-``[[@LINE-<offset>]]`` without any spaces inside the brackets and where\r
-``offset`` is an integer.\r
-\r
-Matching Newline Characters\r
-~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
-\r
-To match newline characters in regular expressions the character class\r
-``[[:space:]]`` can be used. For example, the following pattern:\r
-\r
-.. code-block:: c++\r
-\r
- // CHECK: DW_AT_location [DW_FORM_sec_offset] ([[DLOC:0x[0-9a-f]+]]){{[[:space:]].*}}"intd"\r
-\r
-matches output of the form (from llvm-dwarfdump):\r
-\r
-.. code-block:: text\r
-\r
- DW_AT_location [DW_FORM_sec_offset] (0x00000233)\r
- DW_AT_name [DW_FORM_strp] ( .debug_str[0x000000c9] = "intd")\r
-\r
-letting us set the :program:`FileCheck` variable ``DLOC`` to the desired value \r
-``0x00000233``, extracted from the line immediately preceding "``intd``".\r
+FileCheck - Flexible pattern matching file verifier
+===================================================
+
+.. program:: FileCheck
+
+SYNOPSIS
+--------
+
+:program:`FileCheck` *match-filename* [*--check-prefix=XXX*] [*--strict-whitespace*]
+
+DESCRIPTION
+-----------
+
+:program:`FileCheck` reads two files (one from standard input, and one
+specified on the command line) and uses one to verify the other. This
+behavior is particularly useful for the testsuite, which wants to verify that
+the output of some tool (e.g. :program:`llc`) contains the expected information
+(for example, a movsd from esp or whatever is interesting). This is similar to
+using :program:`grep`, but it is optimized for matching multiple different
+inputs in one file in a specific order.
+
+The ``match-filename`` file specifies the file that contains the patterns to
+match. The file to verify is read from standard input unless the
+:option:`--input-file` option is used.
+
+OPTIONS
+-------
+
+Options are parsed from the environment variable ``FILECHECK_OPTS``
+and from the command line.
+
+.. option:: -help
+
+ Print a summary of command line options.
+
+.. option:: --check-prefix prefix
+
+ FileCheck searches the contents of ``match-filename`` for patterns to
+ match. By default, these patterns are prefixed with "``CHECK:``".
+ If you'd like to use a different prefix (e.g. because the same input
+ file is checking multiple different tool or options), the
+ :option:`--check-prefix` argument allows you to specify one or more
+ prefixes to match. Multiple prefixes are useful for tests which might
+ change for different run options, but most lines remain the same.
+
+.. option:: --check-prefixes prefix1,prefix2,...
+
+ An alias of :option:`--check-prefix` that allows multiple prefixes to be
+ specified as a comma separated list.
+
+.. option:: --input-file filename
+
+ File to check (defaults to stdin).
+
+.. option:: --match-full-lines
+
+ By default, FileCheck allows matches of anywhere on a line. This
+ option will require all positive matches to cover an entire
+ line. Leading and trailing whitespace is ignored, unless
+ :option:`--strict-whitespace` is also specified. (Note: negative
+ matches from ``CHECK-NOT`` are not affected by this option!)
+
+ Passing this option is equivalent to inserting ``{{^ *}}`` or
+ ``{{^}}`` before, and ``{{ *$}}`` or ``{{$}}`` after every positive
+ check pattern.
+
+.. option:: --strict-whitespace
+
+ By default, FileCheck canonicalizes input horizontal whitespace (spaces and
+ tabs) which causes it to ignore these differences (a space will match a tab).
+ The :option:`--strict-whitespace` argument disables this behavior. End-of-line
+ sequences are canonicalized to UNIX-style ``\n`` in all modes.
+
+.. option:: --implicit-check-not check-pattern
+
+ Adds implicit negative checks for the specified patterns between positive
+ checks. The option allows writing stricter tests without stuffing them with
+ ``CHECK-NOT``\ s.
+
+ For example, "``--implicit-check-not warning:``" can be useful when testing
+ diagnostic messages from tools that don't have an option similar to ``clang
+ -verify``. With this option FileCheck will verify that input does not contain
+ warnings not covered by any ``CHECK:`` patterns.
+
+.. option:: --dump-input <mode>
+
+ Dump input to stderr, adding annotations representing currently enabled
+ diagnostics. Do this either 'always', on 'fail', or 'never'. Specify 'help'
+ to explain the dump format and quit.
+
+.. option:: --dump-input-on-failure
+
+ When the check fails, dump all of the original input. This option is
+ deprecated in favor of `--dump-input=fail`.
+
+.. option:: --enable-var-scope
+
+ Enables scope for regex variables.
+
+ Variables with names that start with ``$`` are considered global and
+ remain set throughout the file.
+
+ All other variables get undefined after each encountered ``CHECK-LABEL``.
+
+.. option:: -D<VAR=VALUE>
+
+ Sets a filecheck pattern variable ``VAR`` with value ``VALUE`` that can be
+ used in ``CHECK:`` lines.
+
+.. option:: -D#<NUMVAR>=<NUMERIC EXPRESSION>
+
+ Sets a filecheck numeric variable ``NUMVAR`` to the result of evaluating
+ ``<NUMERIC EXPRESSION>`` that can be used in ``CHECK:`` lines. See section
+ ``FileCheck Numeric Variables and Expressions`` for details on supported
+ numeric expressions.
+
+.. option:: -version
+
+ Show the version number of this program.
+
+.. option:: -v
+
+ Print good directive pattern matches. However, if ``-input-dump=fail`` or
+ ``-input-dump=always``, add those matches as input annotations instead.
+
+.. option:: -vv
+
+ Print information helpful in diagnosing internal FileCheck issues, such as
+ discarded overlapping ``CHECK-DAG:`` matches, implicit EOF pattern matches,
+ and ``CHECK-NOT:`` patterns that do not have matches. Implies ``-v``.
+ However, if ``-input-dump=fail`` or ``-input-dump=always``, just add that
+ information as input annotations instead.
+
+.. option:: --allow-deprecated-dag-overlap
+
+ Enable overlapping among matches in a group of consecutive ``CHECK-DAG:``
+ directives. This option is deprecated and is only provided for convenience
+ as old tests are migrated to the new non-overlapping ``CHECK-DAG:``
+ implementation.
+
+.. option:: --color
+
+ Use colors in output (autodetected by default).
+
+EXIT STATUS
+-----------
+
+If :program:`FileCheck` verifies that the file matches the expected contents,
+it exits with 0. Otherwise, if not, or if an error occurs, it will exit with a
+non-zero value.
+
+TUTORIAL
+--------
+
+FileCheck is typically used from LLVM regression tests, being invoked on the RUN
+line of the test. A simple example of using FileCheck from a RUN line looks
+like this:
+
+.. code-block:: llvm
+
+ ; RUN: llvm-as < %s | llc -march=x86-64 | FileCheck %s
+
+This syntax says to pipe the current file ("``%s``") into ``llvm-as``, pipe
+that into ``llc``, then pipe the output of ``llc`` into ``FileCheck``. This
+means that FileCheck will be verifying its standard input (the llc output)
+against the filename argument specified (the original ``.ll`` file specified by
+"``%s``"). To see how this works, let's look at the rest of the ``.ll`` file
+(after the RUN line):
+
+.. code-block:: llvm
+
+ define void @sub1(i32* %p, i32 %v) {
+ entry:
+ ; CHECK: sub1:
+ ; CHECK: subl
+ %0 = tail call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
+ ret void
+ }
+
+ define void @inc4(i64* %p) {
+ entry:
+ ; CHECK: inc4:
+ ; CHECK: incq
+ %0 = tail call i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
+ ret void
+ }
+
+Here you can see some "``CHECK:``" lines specified in comments. Now you can
+see how the file is piped into ``llvm-as``, then ``llc``, and the machine code
+output is what we are verifying. FileCheck checks the machine code output to
+verify that it matches what the "``CHECK:``" lines specify.
+
+The syntax of the "``CHECK:``" lines is very simple: they are fixed strings that
+must occur in order. FileCheck defaults to ignoring horizontal whitespace
+differences (e.g. a space is allowed to match a tab) but otherwise, the contents
+of the "``CHECK:``" line is required to match some thing in the test file exactly.
+
+One nice thing about FileCheck (compared to grep) is that it allows merging
+test cases together into logical groups. For example, because the test above
+is checking for the "``sub1:``" and "``inc4:``" labels, it will not match
+unless there is a "``subl``" in between those labels. If it existed somewhere
+else in the file, that would not count: "``grep subl``" matches if "``subl``"
+exists anywhere in the file.
+
+The FileCheck -check-prefix option
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The FileCheck `-check-prefix` option allows multiple test
+configurations to be driven from one `.ll` file. This is useful in many
+circumstances, for example, testing different architectural variants with
+:program:`llc`. Here's a simple example:
+
+.. code-block:: llvm
+
+ ; 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
+
+ define <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) nounwind {
+ %tmp1 = insertelement <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 this case, we're testing that we get the expected code generation with
+both 32-bit and 64-bit code generation.
+
+The "CHECK-NEXT:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes you want to match lines and would like to verify that matches
+happen on exactly consecutive lines with no other lines in between them. In
+this case, you can use "``CHECK:``" and "``CHECK-NEXT:``" directives to specify
+this. If you specified a custom check prefix, just use "``<PREFIX>-NEXT:``".
+For example, something like this works as you'd expect:
+
+.. code-block:: llvm
+
+ define void @t2(<2 x double>* %r, <2 x double>* %A, double %B) {
+ %tmp3 = load <2 x double>* %A, align 16
+ %tmp7 = insertelement <2 x double> undef, double %B, i32 0
+ %tmp9 = shufflevector <2 x double> %tmp3,
+ <2 x double> %tmp7,
+ <2 x i32> < i32 0, i32 2 >
+ store <2 x double> %tmp9, <2 x double>* %r, align 16
+ ret void
+
+ ; CHECK: t2:
+ ; CHECK: movl 8(%esp), %eax
+ ; CHECK-NEXT: movapd (%eax), %xmm0
+ ; CHECK-NEXT: movhpd 12(%esp), %xmm0
+ ; CHECK-NEXT: movl 4(%esp), %eax
+ ; CHECK-NEXT: movapd %xmm0, (%eax)
+ ; CHECK-NEXT: ret
+ }
+
+"``CHECK-NEXT:``" directives reject the input unless there is exactly one
+newline between it and the previous directive. A "``CHECK-NEXT:``" cannot be
+the first directive in a file.
+
+The "CHECK-SAME:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes you want to match lines and would like to verify that matches happen
+on the same line as the previous match. In this case, you can use "``CHECK:``"
+and "``CHECK-SAME:``" directives to specify this. If you specified a custom
+check prefix, just use "``<PREFIX>-SAME:``".
+
+"``CHECK-SAME:``" is particularly powerful in conjunction with "``CHECK-NOT:``"
+(described below).
+
+For example, the following works like you'd expect:
+
+.. code-block:: llvm
+
+ !0 = !DILocation(line: 5, scope: !1, inlinedAt: !2)
+
+ ; CHECK: !DILocation(line: 5,
+ ; CHECK-NOT: column:
+ ; CHECK-SAME: scope: ![[SCOPE:[0-9]+]]
+
+"``CHECK-SAME:``" directives reject the input if there are any newlines between
+it and the previous directive. A "``CHECK-SAME:``" cannot be the first
+directive in a file.
+
+The "CHECK-EMPTY:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you need to check that the next line has nothing on it, not even whitespace,
+you can use the "``CHECK-EMPTY:``" directive.
+
+.. code-block:: llvm
+
+ declare void @foo()
+
+ declare void @bar()
+ ; CHECK: foo
+ ; CHECK-EMPTY:
+ ; CHECK-NEXT: bar
+
+Just like "``CHECK-NEXT:``" the directive will fail if there is more than one
+newline before it finds the next blank line, and it cannot be the first
+directive in a file.
+
+The "CHECK-NOT:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The "``CHECK-NOT:``" directive is used to verify that a string doesn't occur
+between two matches (or before the first match, or after the last match). For
+example, to verify that a load is removed by a transformation, a test like this
+can be used:
+
+.. code-block:: llvm
+
+ define i8 @coerce_offset0(i32 %V, i32* %P) {
+ store i32 %V, i32* %P
+
+ %P2 = bitcast i32* %P to i8*
+ %P3 = getelementptr i8* %P2, i32 2
+
+ %A = load i8* %P3
+ ret i8 %A
+ ; CHECK: @coerce_offset0
+ ; CHECK-NOT: load
+ ; CHECK: ret i8
+ }
+
+The "CHECK-COUNT:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you need to match multiple lines with the same pattern over and over again
+you can repeat a plain ``CHECK:`` as many times as needed. If that looks too
+boring you can instead use a counted check "``CHECK-COUNT-<num>:``", where
+``<num>`` is a positive decimal number. It will match the pattern exactly
+``<num>`` times, no more and no less. If you specified a custom check prefix,
+just use "``<PREFIX>-COUNT-<num>:``" for the same effect.
+Here is a simple example:
+
+.. code-block:: text
+
+ Loop at depth 1
+ Loop at depth 1
+ Loop at depth 1
+ Loop at depth 1
+ Loop at depth 2
+ Loop at depth 3
+
+ ; CHECK-COUNT-6: Loop at depth {{[0-9]+}}
+ ; CHECK-NOT: Loop at depth {{[0-9]+}}
+
+The "CHECK-DAG:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If it's necessary to match strings that don't occur in a strictly sequential
+order, "``CHECK-DAG:``" could be used to verify them between two matches (or
+before the first match, or after the last match). For example, clang emits
+vtable globals in reverse order. Using ``CHECK-DAG:``, we can keep the checks
+in the natural order:
+
+.. code-block:: c++
+
+ // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+ struct Foo { virtual void method(); };
+ Foo f; // emit vtable
+ // CHECK-DAG: @_ZTV3Foo =
+
+ struct Bar { virtual void method(); };
+ Bar b;
+ // CHECK-DAG: @_ZTV3Bar =
+
+``CHECK-NOT:`` directives could be mixed with ``CHECK-DAG:`` directives to
+exclude strings between the surrounding ``CHECK-DAG:`` directives. As a result,
+the surrounding ``CHECK-DAG:`` directives cannot be reordered, i.e. all
+occurrences matching ``CHECK-DAG:`` before ``CHECK-NOT:`` must not fall behind
+occurrences matching ``CHECK-DAG:`` after ``CHECK-NOT:``. For example,
+
+.. code-block:: llvm
+
+ ; CHECK-DAG: BEFORE
+ ; CHECK-NOT: NOT
+ ; CHECK-DAG: AFTER
+
+This case will reject input strings where ``BEFORE`` occurs after ``AFTER``.
+
+With captured variables, ``CHECK-DAG:`` is able to match valid topological
+orderings of a DAG with edges from the definition of a variable to its use.
+It's useful, e.g., when your test cases need to match different output
+sequences from the instruction scheduler. For example,
+
+.. code-block:: llvm
+
+ ; CHECK-DAG: add [[REG1:r[0-9]+]], r1, r2
+ ; CHECK-DAG: add [[REG2:r[0-9]+]], r3, r4
+ ; CHECK: mul r5, [[REG1]], [[REG2]]
+
+In this case, any order of that two ``add`` instructions will be allowed.
+
+If you are defining `and` using variables in the same ``CHECK-DAG:`` block,
+be aware that the definition rule can match `after` its use.
+
+So, for instance, the code below will pass:
+
+.. code-block:: text
+
+ ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
+ ; CHECK-DAG: vmov.32 [[REG2]][1]
+ vmov.32 d0[1]
+ vmov.32 d0[0]
+
+While this other code, will not:
+
+.. code-block:: text
+
+ ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
+ ; CHECK-DAG: vmov.32 [[REG2]][1]
+ vmov.32 d1[1]
+ vmov.32 d0[0]
+
+While this can be very useful, it's also dangerous, because in the case of
+register sequence, you must have a strong order (read before write, copy before
+use, etc). If the definition your test is looking for doesn't match (because
+of a bug in the compiler), it may match further away from the use, and mask
+real bugs away.
+
+In those cases, to enforce the order, use a non-DAG directive between DAG-blocks.
+
+A ``CHECK-DAG:`` directive skips matches that overlap the matches of any
+preceding ``CHECK-DAG:`` directives in the same ``CHECK-DAG:`` block. Not only
+is this non-overlapping behavior consistent with other directives, but it's
+also necessary to handle sets of non-unique strings or patterns. For example,
+the following directives look for unordered log entries for two tasks in a
+parallel program, such as the OpenMP runtime:
+
+.. code-block:: text
+
+ // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin
+ // CHECK-DAG: [[THREAD_ID]]: task_end
+ //
+ // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin
+ // CHECK-DAG: [[THREAD_ID]]: task_end
+
+The second pair of directives is guaranteed not to match the same log entries
+as the first pair even though the patterns are identical and even if the text
+of the log entries is identical because the thread ID manages to be reused.
+
+The "CHECK-LABEL:" directive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes in a file containing multiple tests divided into logical blocks, one
+or more ``CHECK:`` directives may inadvertently succeed by matching lines in a
+later block. While an error will usually eventually be generated, the check
+flagged as causing the error may not actually bear any relationship to the
+actual source of the problem.
+
+In order to produce better error messages in these cases, the "``CHECK-LABEL:``"
+directive can be used. It is treated identically to a normal ``CHECK``
+directive except that FileCheck makes an additional assumption that a line
+matched by the directive cannot also be matched by any other check present in
+``match-filename``; this is intended to be used for lines containing labels or
+other unique identifiers. Conceptually, the presence of ``CHECK-LABEL`` divides
+the input stream into separate blocks, each of which is processed independently,
+preventing a ``CHECK:`` directive in one block matching a line in another block.
+If ``--enable-var-scope`` is in effect, all local variables are cleared at the
+beginning of the block.
+
+For example,
+
+.. code-block:: llvm
+
+ define %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
+ entry:
+ ; CHECK-LABEL: C_ctor_base:
+ ; CHECK: mov [[SAVETHIS:r[0-9]+]], r0
+ ; CHECK: bl A_ctor_base
+ ; CHECK: mov r0, [[SAVETHIS]]
+ %0 = bitcast %struct.C* %this to %struct.A*
+ %call = tail call %struct.A* @A_ctor_base(%struct.A* %0)
+ %1 = bitcast %struct.C* %this to %struct.B*
+ %call2 = tail call %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
+ ret %struct.C* %this
+ }
+
+ define %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
+ entry:
+ ; CHECK-LABEL: D_ctor_base:
+
+The use of ``CHECK-LABEL:`` directives in this case ensures that the three
+``CHECK:`` directives only accept lines corresponding to the body of the
+``@C_ctor_base`` function, even if the patterns match lines found later in
+the file. Furthermore, if one of these three ``CHECK:`` directives fail,
+FileCheck will recover by continuing to the next block, allowing multiple test
+failures to be detected in a single invocation.
+
+There is no requirement that ``CHECK-LABEL:`` directives contain strings that
+correspond to actual syntactic labels in a source or output language: they must
+simply uniquely match a single line in the file being verified.
+
+``CHECK-LABEL:`` directives cannot contain variable definitions or uses.
+
+FileCheck Regex Matching Syntax
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+All FileCheck directives take a pattern to match.
+For most uses of FileCheck, fixed string matching is perfectly sufficient. For
+some things, a more flexible form of matching is desired. To support this,
+FileCheck allows you to specify regular expressions in matching strings,
+surrounded by double braces: ``{{yourregex}}``. FileCheck implements a POSIX
+regular expression matcher; it supports Extended POSIX regular expressions
+(ERE). Because we want to use fixed string matching for a majority of what we
+do, FileCheck has been designed to support mixing and matching fixed string
+matching with regular expressions. This allows you to write things like this:
+
+.. code-block:: llvm
+
+ ; CHECK: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}
+
+In this case, any offset from the ESP register will be allowed, and any xmm
+register will be allowed.
+
+Because regular expressions are enclosed with double braces, they are
+visually distinct, and you don't need to use escape characters within the double
+braces like you would in C. In the rare case that you want to match double
+braces explicitly from the input, you can use something ugly like
+``{{[}][}]}}`` as your pattern. Or if you are using the repetition count
+syntax, for example ``[[:xdigit:]]{8}`` to match exactly 8 hex digits, you
+would need to add parentheses like this ``{{([[:xdigit:]]{8})}}`` to avoid
+confusion with FileCheck's closing double-brace.
+
+FileCheck String Substitution Blocks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is often useful to match a pattern and then verify that it occurs again
+later in the file. For codegen tests, this can be useful to allow any
+register, but verify that that register is used consistently later. To do
+this, :program:`FileCheck` supports string substitution blocks that allow
+string variables to be defined and substituted into patterns. Here is a simple
+example:
+
+.. code-block:: llvm
+
+ ; CHECK: test5:
+ ; CHECK: notw [[REGISTER:%[a-z]+]]
+ ; CHECK: andw {{.*}}[[REGISTER]]
+
+The first check line matches a regex ``%[a-z]+`` and captures it into the
+string variable ``REGISTER``. The second line verifies that whatever is in
+``REGISTER`` occurs later in the file after an "``andw``". :program:`FileCheck`
+string substitution blocks are always contained in ``[[ ]]`` pairs, and string
+variable names can be formed with the regex ``[a-zA-Z_][a-zA-Z0-9_]*``. If a
+colon follows the name, then it is a definition of the variable; otherwise, it
+is a substitution.
+
+:program:`FileCheck` variables can be defined multiple times, and substitutions
+always get the latest value. Variables can also be substituted later on the
+same line they were defined on. For example:
+
+.. code-block:: llvm
+
+ ; CHECK: op [[REG:r[0-9]+]], [[REG]]
+
+Can be useful if you want the operands of ``op`` to be the same register,
+and don't care exactly which register it is.
+
+If ``--enable-var-scope`` is in effect, variables with names that
+start with ``$`` are considered to be global. All others variables are
+local. All local variables get undefined at the beginning of each
+CHECK-LABEL block. Global variables are not affected by CHECK-LABEL.
+This makes it easier to ensure that individual tests are not affected
+by variables set in preceding tests.
+
+FileCheck Numeric Substitution Blocks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+:program:`FileCheck` also supports numeric substitution blocks that allow
+defining numeric variables and checking for numeric values that satisfy a
+numeric expression constraint based on those variables via a numeric
+substitution. This allows ``CHECK:`` directives to verify a numeric relation
+between two numbers, such as the need for consecutive registers to be used.
+
+The syntax to define a numeric variable is ``[[#<NUMVAR>:]]`` where
+``<NUMVAR>`` is the name of the numeric variable to define to the matching
+value.
+
+For example:
+
+.. code-block:: llvm
+
+ ; CHECK: mov r[[#REG:]], 42
+
+would match ``mov r5, 42`` and set ``REG`` to the value ``5``.
+
+The syntax of a numeric substitution is ``[[#<expr>]]`` where ``<expr>`` is an
+expression. An expression is recursively defined as:
+
+* a numeric operand, or
+* an expression followed by an operator and a numeric operand.
+
+A numeric operand is a previously defined numeric variable, or an integer
+literal. The supported operators are ``+`` and ``-``. Spaces are accepted
+before, after and between any of these elements.
+
+For example:
+
+.. code-block:: llvm
+
+ ; CHECK: load r[[#REG:]], [r0]
+ ; CHECK: load r[[#REG+1]], [r1]
+
+The above example would match the text:
+
+.. code-block:: gas
+
+ load r5, [r0]
+ load r6, [r1]
+
+but would not match the text:
+
+.. code-block:: gas
+
+ load r5, [r0]
+ load r7, [r1]
+
+due to ``7`` being unequal to ``5 + 1``.
+
+The syntax also supports an empty expression, equivalent to writing {{[0-9]+}},
+for cases where the input must contain a numeric value but the value itself
+does not matter:
+
+.. code-block:: gas
+
+ ; CHECK-NOT: mov r0, r[[#]]
+
+to check that a value is synthesized rather than moved around.
+
+A numeric variable can also be defined to the result of a numeric expression,
+in which case the numeric expression is checked and if verified the variable is
+assigned to the value. The unified syntax for both defining numeric variables
+and checking a numeric expression is thus ``[[#<NUMVAR>: <expr>]]`` with each
+element as described previously.
+
+The ``--enable-var-scope`` option has the same effect on numeric variables as
+on string variables.
+
+Important note: In its current implementation, an expression cannot use a
+numeric variable defined earlier in the same CHECK directive.
+
+FileCheck Pseudo Numeric Variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes there's a need to verify output that contains line numbers of the
+match file, e.g. when testing compiler diagnostics. This introduces a certain
+fragility of the match file structure, as "``CHECK:``" lines contain absolute
+line numbers in the same file, which have to be updated whenever line numbers
+change due to text addition or deletion.
+
+To support this case, FileCheck expressions understand the ``@LINE`` pseudo
+numeric variable which evaluates to the line number of the CHECK pattern where
+it is found.
+
+This way match patterns can be put near the relevant test lines and include
+relative line number references, for example:
+
+.. code-block:: c++
+
+ // CHECK: test.cpp:[[# @LINE + 4]]:6: error: expected ';' after top level declarator
+ // CHECK-NEXT: {{^int a}}
+ // CHECK-NEXT: {{^ \^}}
+ // CHECK-NEXT: {{^ ;}}
+ int a
+
+To support legacy uses of ``@LINE`` as a special string variable,
+:program:`FileCheck` also accepts the following uses of ``@LINE`` with string
+substitution block syntax: ``[[@LINE]]``, ``[[@LINE+<offset>]]`` and
+``[[@LINE-<offset>]]`` without any spaces inside the brackets and where
+``offset`` is an integer.
+
+Matching Newline Characters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To match newline characters in regular expressions the character class
+``[[:space:]]`` can be used. For example, the following pattern:
+
+.. code-block:: c++
+
+ // CHECK: DW_AT_location [DW_FORM_sec_offset] ([[DLOC:0x[0-9a-f]+]]){{[[:space:]].*}}"intd"
+
+matches output of the form (from llvm-dwarfdump):
+
+.. code-block:: text
+
+ DW_AT_location [DW_FORM_sec_offset] (0x00000233)
+ DW_AT_name [DW_FORM_strp] ( .debug_str[0x000000c9] = "intd")
+
+letting us set the :program:`FileCheck` variable ``DLOC`` to the desired value
+``0x00000233``, extracted from the line immediately preceding "``intd``".
-//==-- llvm/Support/FileCheck.h ---------------------------*- C++ -*-==//\r
-//\r
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.\r
-// See https://llvm.org/LICENSE.txt for license information.\r
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\r
-//\r
-//===----------------------------------------------------------------------===//\r
-//\r
-/// \file This file has some utilities to use FileCheck as an API\r
-//\r
-//===----------------------------------------------------------------------===//\r
-\r
-#ifndef LLVM_SUPPORT_FILECHECK_H\r
-#define LLVM_SUPPORT_FILECHECK_H\r
-\r
-#include "llvm/ADT/StringRef.h"\r
-#include "llvm/Support/MemoryBuffer.h"\r
-#include "llvm/Support/Regex.h"\r
-#include "llvm/Support/SourceMgr.h"\r
-#include <string>\r
-#include <vector>\r
-\r
-namespace llvm {\r
-\r
-/// Contains info about various FileCheck options.\r
-struct FileCheckRequest {\r
- std::vector<std::string> CheckPrefixes;\r
- bool NoCanonicalizeWhiteSpace = false;\r
- std::vector<std::string> ImplicitCheckNot;\r
- std::vector<std::string> GlobalDefines;\r
- bool AllowEmptyInput = false;\r
- bool MatchFullLines = false;\r
- bool IgnoreCase = false;\r
- bool EnableVarScope = false;\r
- bool AllowDeprecatedDagOverlap = false;\r
- bool Verbose = false;\r
- bool VerboseVerbose = false;\r
-};\r
-\r
-//===----------------------------------------------------------------------===//\r
-// Summary of a FileCheck diagnostic.\r
-//===----------------------------------------------------------------------===//\r
-\r
-namespace Check {\r
-\r
-enum FileCheckKind {\r
- CheckNone = 0,\r
- CheckPlain,\r
- CheckNext,\r
- CheckSame,\r
- CheckNot,\r
- CheckDAG,\r
- CheckLabel,\r
- CheckEmpty,\r
-\r
- /// Indicates the pattern only matches the end of file. This is used for\r
- /// trailing CHECK-NOTs.\r
- CheckEOF,\r
-\r
- /// Marks when parsing found a -NOT check combined with another CHECK suffix.\r
- CheckBadNot,\r
-\r
- /// Marks when parsing found a -COUNT directive with invalid count value.\r
- CheckBadCount\r
-};\r
-\r
-class FileCheckType {\r
- FileCheckKind Kind;\r
- int Count; ///< optional Count for some checks\r
-\r
-public:\r
- FileCheckType(FileCheckKind Kind = CheckNone) : Kind(Kind), Count(1) {}\r
- FileCheckType(const FileCheckType &) = default;\r
-\r
- operator FileCheckKind() const { return Kind; }\r
-\r
- int getCount() const { return Count; }\r
- FileCheckType &setCount(int C);\r
-\r
- // \returns a description of \p Prefix.\r
- std::string getDescription(StringRef Prefix) const;\r
-};\r
-} // namespace Check\r
-\r
-struct FileCheckDiag {\r
- /// What is the FileCheck directive for this diagnostic?\r
- Check::FileCheckType CheckTy;\r
- /// Where is the FileCheck directive for this diagnostic?\r
- unsigned CheckLine, CheckCol;\r
- /// What type of match result does this diagnostic describe?\r
- ///\r
- /// A directive's supplied pattern is said to be either expected or excluded\r
- /// depending on whether the pattern must have or must not have a match in\r
- /// order for the directive to succeed. For example, a CHECK directive's\r
- /// pattern is expected, and a CHECK-NOT directive's pattern is excluded.\r
- /// All match result types whose names end with "Excluded" are for excluded\r
- /// patterns, and all others are for expected patterns.\r
- ///\r
- /// There might be more than one match result for a single pattern. For\r
- /// example, there might be several discarded matches\r
- /// (MatchFoundButDiscarded) before either a good match\r
- /// (MatchFoundAndExpected) or a failure to match (MatchNoneButExpected),\r
- /// and there might be a fuzzy match (MatchFuzzy) after the latter.\r
- enum MatchType {\r
- /// Indicates a good match for an expected pattern.\r
- MatchFoundAndExpected,\r
- /// Indicates a match for an excluded pattern.\r
- MatchFoundButExcluded,\r
- /// Indicates a match for an expected pattern, but the match is on the\r
- /// wrong line.\r
- MatchFoundButWrongLine,\r
- /// Indicates a discarded match for an expected pattern.\r
- MatchFoundButDiscarded,\r
- /// Indicates no match for an excluded pattern.\r
- MatchNoneAndExcluded,\r
- /// Indicates no match for an expected pattern, but this might follow good\r
- /// matches when multiple matches are expected for the pattern, or it might\r
- /// follow discarded matches for the pattern.\r
- MatchNoneButExpected,\r
- /// Indicates a fuzzy match that serves as a suggestion for the next\r
- /// intended match for an expected pattern with too few or no good matches.\r
- MatchFuzzy,\r
- } MatchTy;\r
- /// The search range if MatchTy is MatchNoneAndExcluded or\r
- /// MatchNoneButExpected, or the match range otherwise.\r
- unsigned InputStartLine;\r
- unsigned InputStartCol;\r
- unsigned InputEndLine;\r
- unsigned InputEndCol;\r
- FileCheckDiag(const SourceMgr &SM, const Check::FileCheckType &CheckTy,\r
- SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange);\r
-};\r
-\r
-class FileCheckPatternContext;\r
-struct FileCheckString;\r
-\r
-/// FileCheck class takes the request and exposes various methods that\r
-/// use information from the request.\r
-class FileCheck {\r
- FileCheckRequest Req;\r
- std::unique_ptr<FileCheckPatternContext> PatternContext;\r
- // C++17 TODO: make this a plain std::vector.\r
- std::unique_ptr<std::vector<FileCheckString>> CheckStrings;\r
-\r
-public:\r
- explicit FileCheck(FileCheckRequest Req);\r
- ~FileCheck();\r
-\r
- // Combines the check prefixes into a single regex so that we can efficiently\r
- // scan for any of the set.\r
- //\r
- // The semantics are that the longest-match wins which matches our regex\r
- // library.\r
- Regex buildCheckPrefixRegex();\r
-\r
- /// Reads the check file from \p Buffer and records the expected strings it\r
- /// contains. Errors are reported against \p SM.\r
- ///\r
- /// Only expected strings whose prefix is one of those listed in \p PrefixRE\r
- /// are recorded. \returns true in case of an error, false otherwise.\r
- bool readCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE);\r
-\r
- bool ValidateCheckPrefixes();\r
-\r
- /// Canonicalizes whitespaces in the file. Line endings are replaced with\r
- /// UNIX-style '\n'.\r
- StringRef CanonicalizeFile(MemoryBuffer &MB,\r
- SmallVectorImpl<char> &OutputBuffer);\r
-\r
- /// Checks the input to FileCheck provided in the \p Buffer against the\r
- /// expected strings read from the check file and record diagnostics emitted\r
- /// in \p Diags. Errors are recorded against \p SM.\r
- ///\r
- /// \returns false if the input fails to satisfy the checks.\r
- bool checkInput(SourceMgr &SM, StringRef Buffer,\r
- std::vector<FileCheckDiag> *Diags = nullptr);\r
-};\r
-\r
-} // namespace llvm\r
-\r
-#endif\r
+//==-- llvm/Support/FileCheck.h ---------------------------*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file This file has some utilities to use FileCheck as an API
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_FILECHECK_H
+#define LLVM_SUPPORT_FILECHECK_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/SourceMgr.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+/// Contains info about various FileCheck options.
+struct FileCheckRequest {
+ std::vector<std::string> CheckPrefixes;
+ bool NoCanonicalizeWhiteSpace = false;
+ std::vector<std::string> ImplicitCheckNot;
+ std::vector<std::string> GlobalDefines;
+ bool AllowEmptyInput = false;
+ bool MatchFullLines = false;
+ bool EnableVarScope = false;
+ bool AllowDeprecatedDagOverlap = false;
+ bool Verbose = false;
+ bool VerboseVerbose = false;
+};
+
+//===----------------------------------------------------------------------===//
+// Summary of a FileCheck diagnostic.
+//===----------------------------------------------------------------------===//
+
+namespace Check {
+
+enum FileCheckKind {
+ CheckNone = 0,
+ CheckPlain,
+ CheckNext,
+ CheckSame,
+ CheckNot,
+ CheckDAG,
+ CheckLabel,
+ CheckEmpty,
+
+ /// Indicates the pattern only matches the end of file. This is used for
+ /// trailing CHECK-NOTs.
+ CheckEOF,
+
+ /// Marks when parsing found a -NOT check combined with another CHECK suffix.
+ CheckBadNot,
+
+ /// Marks when parsing found a -COUNT directive with invalid count value.
+ CheckBadCount
+};
+
+class FileCheckType {
+ FileCheckKind Kind;
+ int Count; ///< optional Count for some checks
+
+public:
+ FileCheckType(FileCheckKind Kind = CheckNone) : Kind(Kind), Count(1) {}
+ FileCheckType(const FileCheckType &) = default;
+
+ operator FileCheckKind() const { return Kind; }
+
+ int getCount() const { return Count; }
+ FileCheckType &setCount(int C);
+
+ // \returns a description of \p Prefix.
+ std::string getDescription(StringRef Prefix) const;
+};
+} // namespace Check
+
+struct FileCheckDiag {
+ /// What is the FileCheck directive for this diagnostic?
+ Check::FileCheckType CheckTy;
+ /// Where is the FileCheck directive for this diagnostic?
+ unsigned CheckLine, CheckCol;
+ /// What type of match result does this diagnostic describe?
+ ///
+ /// A directive's supplied pattern is said to be either expected or excluded
+ /// depending on whether the pattern must have or must not have a match in
+ /// order for the directive to succeed. For example, a CHECK directive's
+ /// pattern is expected, and a CHECK-NOT directive's pattern is excluded.
+ /// All match result types whose names end with "Excluded" are for excluded
+ /// patterns, and all others are for expected patterns.
+ ///
+ /// There might be more than one match result for a single pattern. For
+ /// example, there might be several discarded matches
+ /// (MatchFoundButDiscarded) before either a good match
+ /// (MatchFoundAndExpected) or a failure to match (MatchNoneButExpected),
+ /// and there might be a fuzzy match (MatchFuzzy) after the latter.
+ enum MatchType {
+ /// Indicates a good match for an expected pattern.
+ MatchFoundAndExpected,
+ /// Indicates a match for an excluded pattern.
+ MatchFoundButExcluded,
+ /// Indicates a match for an expected pattern, but the match is on the
+ /// wrong line.
+ MatchFoundButWrongLine,
+ /// Indicates a discarded match for an expected pattern.
+ MatchFoundButDiscarded,
+ /// Indicates no match for an excluded pattern.
+ MatchNoneAndExcluded,
+ /// Indicates no match for an expected pattern, but this might follow good
+ /// matches when multiple matches are expected for the pattern, or it might
+ /// follow discarded matches for the pattern.
+ MatchNoneButExpected,
+ /// Indicates a fuzzy match that serves as a suggestion for the next
+ /// intended match for an expected pattern with too few or no good matches.
+ MatchFuzzy,
+ } MatchTy;
+ /// The search range if MatchTy is MatchNoneAndExcluded or
+ /// MatchNoneButExpected, or the match range otherwise.
+ unsigned InputStartLine;
+ unsigned InputStartCol;
+ unsigned InputEndLine;
+ unsigned InputEndCol;
+ FileCheckDiag(const SourceMgr &SM, const Check::FileCheckType &CheckTy,
+ SMLoc CheckLoc, MatchType MatchTy, SMRange InputRange);
+};
+
+class FileCheckPatternContext;
+struct FileCheckString;
+
+/// FileCheck class takes the request and exposes various methods that
+/// use information from the request.
+class FileCheck {
+ FileCheckRequest Req;
+ std::unique_ptr<FileCheckPatternContext> PatternContext;
+ // C++17 TODO: make this a plain std::vector.
+ std::unique_ptr<std::vector<FileCheckString>> CheckStrings;
+
+public:
+ explicit FileCheck(FileCheckRequest Req);
+ ~FileCheck();
+
+ // Combines the check prefixes into a single regex so that we can efficiently
+ // scan for any of the set.
+ //
+ // The semantics are that the longest-match wins which matches our regex
+ // library.
+ Regex buildCheckPrefixRegex();
+
+ /// Reads the check file from \p Buffer and records the expected strings it
+ /// contains. Errors are reported against \p SM.
+ ///
+ /// Only expected strings whose prefix is one of those listed in \p PrefixRE
+ /// are recorded. \returns true in case of an error, false otherwise.
+ bool readCheckFile(SourceMgr &SM, StringRef Buffer, Regex &PrefixRE);
+
+ bool ValidateCheckPrefixes();
+
+ /// Canonicalizes whitespaces in the file. Line endings are replaced with
+ /// UNIX-style '\n'.
+ StringRef CanonicalizeFile(MemoryBuffer &MB,
+ SmallVectorImpl<char> &OutputBuffer);
+
+ /// Checks the input to FileCheck provided in the \p Buffer against the
+ /// expected strings read from the check file and record diagnostics emitted
+ /// in \p Diags. Errors are recorded against \p SM.
+ ///
+ /// \returns false if the input fails to satisfy the checks.
+ bool checkInput(SourceMgr &SM, StringRef Buffer,
+ std::vector<FileCheckDiag> *Diags = nullptr);
+};
+
+} // namespace llvm
+
+#endif
-//===- FileCheck.cpp - Check that File's Contents match what is expected --===//\r
-//\r
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.\r
-// See https://llvm.org/LICENSE.txt for license information.\r
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\r
-//\r
-//===----------------------------------------------------------------------===//\r
-//\r
-// FileCheck does a line-by line check of a file that validates whether it\r
-// contains the expected content. This is useful for regression tests etc.\r
-//\r
-// This file implements most of the API that will be used by the FileCheck utility\r
-// as well as various unittests.\r
-//===----------------------------------------------------------------------===//\r
-\r
-#include "llvm/Support/FileCheck.h"\r
-#include "FileCheckImpl.h"\r
-#include "llvm/ADT/StringSet.h"\r
-#include "llvm/ADT/Twine.h"\r
-#include "llvm/Support/FormatVariadic.h"\r
-#include <cstdint>\r
-#include <list>\r
-#include <tuple>\r
-#include <utility>\r
-\r
-using namespace llvm;\r
-\r
-Expected<uint64_t> FileCheckNumericVariableUse::eval() const {\r
- Optional<uint64_t> Value = NumericVariable->getValue();\r
- if (Value)\r
- return *Value;\r
-\r
- return make_error<FileCheckUndefVarError>(Name);\r
-}\r
-\r
-Expected<uint64_t> FileCheckASTBinop::eval() const {\r
- Expected<uint64_t> LeftOp = LeftOperand->eval();\r
- Expected<uint64_t> RightOp = RightOperand->eval();\r
-\r
- // Bubble up any error (e.g. undefined variables) in the recursive\r
- // evaluation.\r
- if (!LeftOp || !RightOp) {\r
- Error Err = Error::success();\r
- if (!LeftOp)\r
- Err = joinErrors(std::move(Err), LeftOp.takeError());\r
- if (!RightOp)\r
- Err = joinErrors(std::move(Err), RightOp.takeError());\r
- return std::move(Err);\r
- }\r
-\r
- return EvalBinop(*LeftOp, *RightOp);\r
-}\r
-\r
-Expected<std::string> FileCheckNumericSubstitution::getResult() const {\r
- Expected<uint64_t> EvaluatedValue = ExpressionAST->eval();\r
- if (!EvaluatedValue)\r
- return EvaluatedValue.takeError();\r
- return utostr(*EvaluatedValue);\r
-}\r
-\r
-Expected<std::string> FileCheckStringSubstitution::getResult() const {\r
- // Look up the value and escape it so that we can put it into the regex.\r
- Expected<StringRef> VarVal = Context->getPatternVarValue(FromStr);\r
- if (!VarVal)\r
- return VarVal.takeError();\r
- return Regex::escape(*VarVal);\r
-}\r
-\r
-bool FileCheckPattern::isValidVarNameStart(char C) {\r
- return C == '_' || isalpha(C);\r
-}\r
-\r
-Expected<FileCheckPattern::VariableProperties>\r
-FileCheckPattern::parseVariable(StringRef &Str, const SourceMgr &SM) {\r
- if (Str.empty())\r
- return FileCheckErrorDiagnostic::get(SM, Str, "empty variable name");\r
-\r
- bool ParsedOneChar = false;\r
- unsigned I = 0;\r
- bool IsPseudo = Str[0] == '@';\r
-\r
- // Global vars start with '$'.\r
- if (Str[0] == '$' || IsPseudo)\r
- ++I;\r
-\r
- for (unsigned E = Str.size(); I != E; ++I) {\r
- if (!ParsedOneChar && !isValidVarNameStart(Str[I]))\r
- return FileCheckErrorDiagnostic::get(SM, Str, "invalid variable name");\r
-\r
- // Variable names are composed of alphanumeric characters and underscores.\r
- if (Str[I] != '_' && !isalnum(Str[I]))\r
- break;\r
- ParsedOneChar = true;\r
- }\r
-\r
- StringRef Name = Str.take_front(I);\r
- Str = Str.substr(I);\r
- return VariableProperties {Name, IsPseudo};\r
-}\r
-\r
-// StringRef holding all characters considered as horizontal whitespaces by\r
-// FileCheck input canonicalization.\r
-constexpr StringLiteral SpaceChars = " \t";\r
-\r
-// Parsing helper function that strips the first character in S and returns it.\r
-static char popFront(StringRef &S) {\r
- char C = S.front();\r
- S = S.drop_front();\r
- return C;\r
-}\r
-\r
-char FileCheckUndefVarError::ID = 0;\r
-char FileCheckErrorDiagnostic::ID = 0;\r
-char FileCheckNotFoundError::ID = 0;\r
-\r
-Expected<FileCheckNumericVariable *>\r
-FileCheckPattern::parseNumericVariableDefinition(\r
- StringRef &Expr, FileCheckPatternContext *Context,\r
- Optional<size_t> LineNumber, const SourceMgr &SM) {\r
- Expected<VariableProperties> ParseVarResult = parseVariable(Expr, SM);\r
- if (!ParseVarResult)\r
- return ParseVarResult.takeError();\r
- StringRef Name = ParseVarResult->Name;\r
-\r
- if (ParseVarResult->IsPseudo)\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Name, "definition of pseudo numeric variable unsupported");\r
-\r
- // Detect collisions between string and numeric variables when the latter\r
- // is created later than the former.\r
- if (Context->DefinedVariableTable.find(Name) !=\r
- Context->DefinedVariableTable.end())\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Name, "string variable with name '" + Name + "' already exists");\r
-\r
- Expr = Expr.ltrim(SpaceChars);\r
- if (!Expr.empty())\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Expr, "unexpected characters after numeric variable name");\r
-\r
- FileCheckNumericVariable *DefinedNumericVariable;\r
- auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);\r
- if (VarTableIter != Context->GlobalNumericVariableTable.end())\r
- DefinedNumericVariable = VarTableIter->second;\r
- else\r
- DefinedNumericVariable = Context->makeNumericVariable(Name, LineNumber);\r
-\r
- return DefinedNumericVariable;\r
-}\r
-\r
-Expected<std::unique_ptr<FileCheckNumericVariableUse>>\r
-FileCheckPattern::parseNumericVariableUse(StringRef Name, bool IsPseudo,\r
- Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context,\r
- const SourceMgr &SM) {\r
- if (IsPseudo && !Name.equals("@LINE"))\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Name, "invalid pseudo numeric variable '" + Name + "'");\r
-\r
- // Numeric variable definitions and uses are parsed in the order in which\r
- // they appear in the CHECK patterns. For each definition, the pointer to the\r
- // class instance of the corresponding numeric variable definition is stored\r
- // in GlobalNumericVariableTable in parsePattern. Therefore, if the pointer\r
- // we get below is null, it means no such variable was defined before. When\r
- // that happens, we create a dummy variable so that parsing can continue. All\r
- // uses of undefined variables, whether string or numeric, are then diagnosed\r
- // in printSubstitutions() after failing to match.\r
- auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);\r
- FileCheckNumericVariable *NumericVariable;\r
- if (VarTableIter != Context->GlobalNumericVariableTable.end())\r
- NumericVariable = VarTableIter->second;\r
- else {\r
- NumericVariable = Context->makeNumericVariable(Name);\r
- Context->GlobalNumericVariableTable[Name] = NumericVariable;\r
- }\r
-\r
- Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();\r
- if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Name,\r
- "numeric variable '" + Name +\r
- "' defined earlier in the same CHECK directive");\r
-\r
- return std::make_unique<FileCheckNumericVariableUse>(Name, NumericVariable);\r
-}\r
-\r
-Expected<std::unique_ptr<FileCheckExpressionAST>>\r
-FileCheckPattern::parseNumericOperand(StringRef &Expr, AllowedOperand AO,\r
- Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context,\r
- const SourceMgr &SM) {\r
- if (AO == AllowedOperand::LineVar || AO == AllowedOperand::Any) {\r
- // Try to parse as a numeric variable use.\r
- Expected<FileCheckPattern::VariableProperties> ParseVarResult =\r
- parseVariable(Expr, SM);\r
- if (ParseVarResult)\r
- return parseNumericVariableUse(ParseVarResult->Name,\r
- ParseVarResult->IsPseudo, LineNumber,\r
- Context, SM);\r
- if (AO == AllowedOperand::LineVar)\r
- return ParseVarResult.takeError();\r
- // Ignore the error and retry parsing as a literal.\r
- consumeError(ParseVarResult.takeError());\r
- }\r
-\r
- // Otherwise, parse it as a literal.\r
- uint64_t LiteralValue;\r
- if (!Expr.consumeInteger(/*Radix=*/10, LiteralValue))\r
- return std::make_unique<FileCheckExpressionLiteral>(LiteralValue);\r
-\r
- return FileCheckErrorDiagnostic::get(SM, Expr,\r
- "invalid operand format '" + Expr + "'");\r
-}\r
-\r
-static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {\r
- return LeftOp + RightOp;\r
-}\r
-\r
-static uint64_t sub(uint64_t LeftOp, uint64_t RightOp) {\r
- return LeftOp - RightOp;\r
-}\r
-\r
-Expected<std::unique_ptr<FileCheckExpressionAST>> FileCheckPattern::parseBinop(\r
- StringRef &Expr, std::unique_ptr<FileCheckExpressionAST> LeftOp,\r
- bool IsLegacyLineExpr, Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context, const SourceMgr &SM) {\r
- Expr = Expr.ltrim(SpaceChars);\r
- if (Expr.empty())\r
- return std::move(LeftOp);\r
-\r
- // Check if this is a supported operation and select a function to perform\r
- // it.\r
- SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());\r
- char Operator = popFront(Expr);\r
- binop_eval_t EvalBinop;\r
- switch (Operator) {\r
- case '+':\r
- EvalBinop = add;\r
- break;\r
- case '-':\r
- EvalBinop = sub;\r
- break;\r
- default:\r
- return FileCheckErrorDiagnostic::get(\r
- SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");\r
- }\r
-\r
- // Parse right operand.\r
- Expr = Expr.ltrim(SpaceChars);\r
- if (Expr.empty())\r
- return FileCheckErrorDiagnostic::get(SM, Expr,\r
- "missing operand in expression");\r
- // The second operand in a legacy @LINE expression is always a literal.\r
- AllowedOperand AO =\r
- IsLegacyLineExpr ? AllowedOperand::Literal : AllowedOperand::Any;\r
- Expected<std::unique_ptr<FileCheckExpressionAST>> RightOpResult =\r
- parseNumericOperand(Expr, AO, LineNumber, Context, SM);\r
- if (!RightOpResult)\r
- return RightOpResult;\r
-\r
- Expr = Expr.ltrim(SpaceChars);\r
- return std::make_unique<FileCheckASTBinop>(EvalBinop, std::move(LeftOp),\r
- std::move(*RightOpResult));\r
-}\r
-\r
-Expected<std::unique_ptr<FileCheckExpressionAST>>\r
-FileCheckPattern::parseNumericSubstitutionBlock(\r
- StringRef Expr,\r
- Optional<FileCheckNumericVariable *> &DefinedNumericVariable,\r
- bool IsLegacyLineExpr, Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context, const SourceMgr &SM) {\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST = nullptr;\r
- StringRef DefExpr = StringRef();\r
- DefinedNumericVariable = None;\r
- // Save variable definition expression if any.\r
- size_t DefEnd = Expr.find(':');\r
- if (DefEnd != StringRef::npos) {\r
- DefExpr = Expr.substr(0, DefEnd);\r
- Expr = Expr.substr(DefEnd + 1);\r
- }\r
-\r
- // Parse the expression itself.\r
- Expr = Expr.ltrim(SpaceChars);\r
- if (!Expr.empty()) {\r
- // The first operand in a legacy @LINE expression is always the @LINE\r
- // pseudo variable.\r
- AllowedOperand AO =\r
- IsLegacyLineExpr ? AllowedOperand::LineVar : AllowedOperand::Any;\r
- Expected<std::unique_ptr<FileCheckExpressionAST>> ParseResult =\r
- parseNumericOperand(Expr, AO, LineNumber, Context, SM);\r
- while (ParseResult && !Expr.empty()) {\r
- ParseResult = parseBinop(Expr, std::move(*ParseResult), IsLegacyLineExpr,\r
- LineNumber, Context, SM);\r
- // Legacy @LINE expressions only allow 2 operands.\r
- if (ParseResult && IsLegacyLineExpr && !Expr.empty())\r
- return FileCheckErrorDiagnostic::get(\r
- SM, Expr,\r
- "unexpected characters at end of expression '" + Expr + "'");\r
- }\r
- if (!ParseResult)\r
- return ParseResult;\r
- ExpressionAST = std::move(*ParseResult);\r
- }\r
-\r
- // Parse the numeric variable definition.\r
- if (DefEnd != StringRef::npos) {\r
- DefExpr = DefExpr.ltrim(SpaceChars);\r
- Expected<FileCheckNumericVariable *> ParseResult =\r
- parseNumericVariableDefinition(DefExpr, Context, LineNumber, SM);\r
-\r
- if (!ParseResult)\r
- return ParseResult.takeError();\r
- DefinedNumericVariable = *ParseResult;\r
- }\r
-\r
- return std::move(ExpressionAST);\r
-}\r
-\r
-bool FileCheckPattern::parsePattern(StringRef PatternStr, StringRef Prefix,\r
- SourceMgr &SM,\r
- const FileCheckRequest &Req) {\r
- bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;\r
- IgnoreCase = Req.IgnoreCase;\r
-\r
- PatternLoc = SMLoc::getFromPointer(PatternStr.data());\r
-\r
- if (!(Req.NoCanonicalizeWhiteSpace && Req.MatchFullLines))\r
- // Ignore trailing whitespace.\r
- while (!PatternStr.empty() &&\r
- (PatternStr.back() == ' ' || PatternStr.back() == '\t'))\r
- PatternStr = PatternStr.substr(0, PatternStr.size() - 1);\r
-\r
- // Check that there is something on the line.\r
- if (PatternStr.empty() && CheckTy != Check::CheckEmpty) {\r
- SM.PrintMessage(PatternLoc, SourceMgr::DK_Error,\r
- "found empty check string with prefix '" + Prefix + ":'");\r
- return true;\r
- }\r
-\r
- if (!PatternStr.empty() && CheckTy == Check::CheckEmpty) {\r
- SM.PrintMessage(\r
- PatternLoc, SourceMgr::DK_Error,\r
- "found non-empty check string for empty check with prefix '" + Prefix +\r
- ":'");\r
- return true;\r
- }\r
-\r
- if (CheckTy == Check::CheckEmpty) {\r
- RegExStr = "(\n$)";\r
- return false;\r
- }\r
-\r
- // Check to see if this is a fixed string, or if it has regex pieces.\r
- if (!MatchFullLinesHere &&\r
- (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos &&\r
- PatternStr.find("[[") == StringRef::npos))) {\r
- FixedStr = PatternStr;\r
- return false;\r
- }\r
-\r
- if (MatchFullLinesHere) {\r
- RegExStr += '^';\r
- if (!Req.NoCanonicalizeWhiteSpace)\r
- RegExStr += " *";\r
- }\r
-\r
- // Paren value #0 is for the fully matched string. Any new parenthesized\r
- // values add from there.\r
- unsigned CurParen = 1;\r
-\r
- // Otherwise, there is at least one regex piece. Build up the regex pattern\r
- // by escaping scary characters in fixed strings, building up one big regex.\r
- while (!PatternStr.empty()) {\r
- // RegEx matches.\r
- if (PatternStr.startswith("{{")) {\r
- // This is the start of a regex match. Scan for the }}.\r
- size_t End = PatternStr.find("}}");\r
- if (End == StringRef::npos) {\r
- SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),\r
- SourceMgr::DK_Error,\r
- "found start of regex string with no end '}}'");\r
- return true;\r
- }\r
-\r
- // Enclose {{}} patterns in parens just like [[]] even though we're not\r
- // capturing the result for any purpose. This is required in case the\r
- // expression contains an alternation like: CHECK: abc{{x|z}}def. We\r
- // want this to turn into: "abc(x|z)def" not "abcx|zdef".\r
- RegExStr += '(';\r
- ++CurParen;\r
-\r
- if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM))\r
- return true;\r
- RegExStr += ')';\r
-\r
- PatternStr = PatternStr.substr(End + 2);\r
- continue;\r
- }\r
-\r
- // String and numeric substitution blocks. Pattern substitution blocks come\r
- // in two forms: [[foo:.*]] and [[foo]]. The former matches .* (or some\r
- // other regex) and assigns it to the string variable 'foo'. The latter\r
- // substitutes foo's value. Numeric substitution blocks recognize the same\r
- // form as string ones, but start with a '#' sign after the double\r
- // brackets. They also accept a combined form which sets a numeric variable\r
- // to the evaluation of an expression. Both string and numeric variable\r
- // names must satisfy the regular expression "[a-zA-Z_][0-9a-zA-Z_]*" to be\r
- // valid, as this helps catch some common errors.\r
- if (PatternStr.startswith("[[")) {\r
- StringRef UnparsedPatternStr = PatternStr.substr(2);\r
- // Find the closing bracket pair ending the match. End is going to be an\r
- // offset relative to the beginning of the match string.\r
- size_t End = FindRegexVarEnd(UnparsedPatternStr, SM);\r
- StringRef MatchStr = UnparsedPatternStr.substr(0, End);\r
- bool IsNumBlock = MatchStr.consume_front("#");\r
-\r
- if (End == StringRef::npos) {\r
- SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),\r
- SourceMgr::DK_Error,\r
- "Invalid substitution block, no ]] found");\r
- return true;\r
- }\r
- // Strip the substitution block we are parsing. End points to the start\r
- // of the "]]" closing the expression so account for it in computing the\r
- // index of the first unparsed character.\r
- PatternStr = UnparsedPatternStr.substr(End + 2);\r
-\r
- bool IsDefinition = false;\r
- bool SubstNeeded = false;\r
- // Whether the substitution block is a legacy use of @LINE with string\r
- // substitution block syntax.\r
- bool IsLegacyLineExpr = false;\r
- StringRef DefName;\r
- StringRef SubstStr;\r
- StringRef MatchRegexp;\r
- size_t SubstInsertIdx = RegExStr.size();\r
-\r
- // Parse string variable or legacy @LINE expression.\r
- if (!IsNumBlock) {\r
- size_t VarEndIdx = MatchStr.find(":");\r
- size_t SpacePos = MatchStr.substr(0, VarEndIdx).find_first_of(" \t");\r
- if (SpacePos != StringRef::npos) {\r
- SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data() + SpacePos),\r
- SourceMgr::DK_Error, "unexpected whitespace");\r
- return true;\r
- }\r
-\r
- // Get the name (e.g. "foo") and verify it is well formed.\r
- StringRef OrigMatchStr = MatchStr;\r
- Expected<FileCheckPattern::VariableProperties> ParseVarResult =\r
- parseVariable(MatchStr, SM);\r
- if (!ParseVarResult) {\r
- logAllUnhandledErrors(ParseVarResult.takeError(), errs());\r
- return true;\r
- }\r
- StringRef Name = ParseVarResult->Name;\r
- bool IsPseudo = ParseVarResult->IsPseudo;\r
-\r
- IsDefinition = (VarEndIdx != StringRef::npos);\r
- SubstNeeded = !IsDefinition;\r
- if (IsDefinition) {\r
- if ((IsPseudo || !MatchStr.consume_front(":"))) {\r
- SM.PrintMessage(SMLoc::getFromPointer(Name.data()),\r
- SourceMgr::DK_Error,\r
- "invalid name in string variable definition");\r
- return true;\r
- }\r
-\r
- // Detect collisions between string and numeric variables when the\r
- // former is created later than the latter.\r
- if (Context->GlobalNumericVariableTable.find(Name) !=\r
- Context->GlobalNumericVariableTable.end()) {\r
- SM.PrintMessage(\r
- SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,\r
- "numeric variable with name '" + Name + "' already exists");\r
- return true;\r
- }\r
- DefName = Name;\r
- MatchRegexp = MatchStr;\r
- } else {\r
- if (IsPseudo) {\r
- MatchStr = OrigMatchStr;\r
- IsLegacyLineExpr = IsNumBlock = true;\r
- } else\r
- SubstStr = Name;\r
- }\r
- }\r
-\r
- // Parse numeric substitution block.\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST;\r
- Optional<FileCheckNumericVariable *> DefinedNumericVariable;\r
- if (IsNumBlock) {\r
- Expected<std::unique_ptr<FileCheckExpressionAST>> ParseResult =\r
- parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable,\r
- IsLegacyLineExpr, LineNumber, Context,\r
- SM);\r
- if (!ParseResult) {\r
- logAllUnhandledErrors(ParseResult.takeError(), errs());\r
- return true;\r
- }\r
- ExpressionAST = std::move(*ParseResult);\r
- SubstNeeded = ExpressionAST != nullptr;\r
- if (DefinedNumericVariable) {\r
- IsDefinition = true;\r
- DefName = (*DefinedNumericVariable)->getName();\r
- }\r
- if (SubstNeeded)\r
- SubstStr = MatchStr;\r
- else\r
- MatchRegexp = "[0-9]+";\r
- }\r
-\r
- // Handle variable definition: [[<def>:(...)]] and [[#(...)<def>:(...)]].\r
- if (IsDefinition) {\r
- RegExStr += '(';\r
- ++SubstInsertIdx;\r
-\r
- if (IsNumBlock) {\r
- FileCheckNumericVariableMatch NumericVariableDefinition = {\r
- *DefinedNumericVariable, CurParen};\r
- NumericVariableDefs[DefName] = NumericVariableDefinition;\r
- // This store is done here rather than in match() to allow\r
- // parseNumericVariableUse() to get the pointer to the class instance\r
- // of the right variable definition corresponding to a given numeric\r
- // variable use.\r
- Context->GlobalNumericVariableTable[DefName] =\r
- *DefinedNumericVariable;\r
- } else {\r
- VariableDefs[DefName] = CurParen;\r
- // Mark string variable as defined to detect collisions between\r
- // string and numeric variables in parseNumericVariableUse() and\r
- // defineCmdlineVariables() when the latter is created later than the\r
- // former. We cannot reuse GlobalVariableTable for this by populating\r
- // it with an empty string since we would then lose the ability to\r
- // detect the use of an undefined variable in match().\r
- Context->DefinedVariableTable[DefName] = true;\r
- }\r
-\r
- ++CurParen;\r
- }\r
-\r
- if (!MatchRegexp.empty() && AddRegExToRegEx(MatchRegexp, CurParen, SM))\r
- return true;\r
-\r
- if (IsDefinition)\r
- RegExStr += ')';\r
-\r
- // Handle substitutions: [[foo]] and [[#<foo expr>]].\r
- if (SubstNeeded) {\r
- // Handle substitution of string variables that were defined earlier on\r
- // the same line by emitting a backreference. Expressions do not\r
- // support substituting a numeric variable defined on the same line.\r
- if (!IsNumBlock && VariableDefs.find(SubstStr) != VariableDefs.end()) {\r
- unsigned CaptureParenGroup = VariableDefs[SubstStr];\r
- if (CaptureParenGroup < 1 || CaptureParenGroup > 9) {\r
- SM.PrintMessage(SMLoc::getFromPointer(SubstStr.data()),\r
- SourceMgr::DK_Error,\r
- "Can't back-reference more than 9 variables");\r
- return true;\r
- }\r
- AddBackrefToRegEx(CaptureParenGroup);\r
- } else {\r
- // Handle substitution of string variables ([[<var>]]) defined in\r
- // previous CHECK patterns, and substitution of expressions.\r
- FileCheckSubstitution *Substitution =\r
- IsNumBlock\r
- ? Context->makeNumericSubstitution(\r
- SubstStr, std::move(ExpressionAST), SubstInsertIdx)\r
- : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);\r
- Substitutions.push_back(Substitution);\r
- }\r
- }\r
- }\r
-\r
- // Handle fixed string matches.\r
- // Find the end, which is the start of the next regex.\r
- size_t FixedMatchEnd = PatternStr.find("{{");\r
- FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[["));\r
- RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd));\r
- PatternStr = PatternStr.substr(FixedMatchEnd);\r
- }\r
-\r
- if (MatchFullLinesHere) {\r
- if (!Req.NoCanonicalizeWhiteSpace)\r
- RegExStr += " *";\r
- RegExStr += '$';\r
- }\r
-\r
- return false;\r
-}\r
-\r
-bool FileCheckPattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM) {\r
- Regex R(RS);\r
- std::string Error;\r
- if (!R.isValid(Error)) {\r
- SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error,\r
- "invalid regex: " + Error);\r
- return true;\r
- }\r
-\r
- RegExStr += RS.str();\r
- CurParen += R.getNumMatches();\r
- return false;\r
-}\r
-\r
-void FileCheckPattern::AddBackrefToRegEx(unsigned BackrefNum) {\r
- assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number");\r
- std::string Backref = std::string("\\") + std::string(1, '0' + BackrefNum);\r
- RegExStr += Backref;\r
-}\r
-\r
-Expected<size_t> FileCheckPattern::match(StringRef Buffer, size_t &MatchLen,\r
- const SourceMgr &SM) const {\r
- // If this is the EOF pattern, match it immediately.\r
- if (CheckTy == Check::CheckEOF) {\r
- MatchLen = 0;\r
- return Buffer.size();\r
- }\r
-\r
- // If this is a fixed string pattern, just match it now.\r
- if (!FixedStr.empty()) {\r
- MatchLen = FixedStr.size();\r
- size_t Pos = IgnoreCase ? Buffer.find_lower(FixedStr)\r
- : Buffer.find(FixedStr);\r
- if (Pos == StringRef::npos)\r
- return make_error<FileCheckNotFoundError>();\r
- return Pos;\r
- }\r
-\r
- // Regex match.\r
-\r
- // If there are substitutions, we need to create a temporary string with the\r
- // actual value.\r
- StringRef RegExToMatch = RegExStr;\r
- std::string TmpStr;\r
- if (!Substitutions.empty()) {\r
- TmpStr = RegExStr;\r
- if (LineNumber)\r
- Context->LineVariable->setValue(*LineNumber);\r
-\r
- size_t InsertOffset = 0;\r
- // Substitute all string variables and expressions whose values are only\r
- // now known. Use of string variables defined on the same line are handled\r
- // by back-references.\r
- for (const auto &Substitution : Substitutions) {\r
- // Substitute and check for failure (e.g. use of undefined variable).\r
- Expected<std::string> Value = Substitution->getResult();\r
- if (!Value)\r
- return Value.takeError();\r
-\r
- // Plop it into the regex at the adjusted offset.\r
- TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,\r
- Value->begin(), Value->end());\r
- InsertOffset += Value->size();\r
- }\r
-\r
- // Match the newly constructed regex.\r
- RegExToMatch = TmpStr;\r
- }\r
-\r
- SmallVector<StringRef, 4> MatchInfo;\r
- unsigned int Flags = Regex::Newline;\r
- if (IgnoreCase)\r
- Flags |= Regex::IgnoreCase;\r
- if (!Regex(RegExToMatch, Flags).match(Buffer, &MatchInfo))\r
- return make_error<FileCheckNotFoundError>();\r
-\r
- // Successful regex match.\r
- assert(!MatchInfo.empty() && "Didn't get any match");\r
- StringRef FullMatch = MatchInfo[0];\r
-\r
- // If this defines any string variables, remember their values.\r
- for (const auto &VariableDef : VariableDefs) {\r
- assert(VariableDef.second < MatchInfo.size() && "Internal paren error");\r
- Context->GlobalVariableTable[VariableDef.first] =\r
- MatchInfo[VariableDef.second];\r
- }\r
-\r
- // If this defines any numeric variables, remember their values.\r
- for (const auto &NumericVariableDef : NumericVariableDefs) {\r
- const FileCheckNumericVariableMatch &NumericVariableMatch =\r
- NumericVariableDef.getValue();\r
- unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;\r
- assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");\r
- FileCheckNumericVariable *DefinedNumericVariable =\r
- NumericVariableMatch.DefinedNumericVariable;\r
-\r
- StringRef MatchedValue = MatchInfo[CaptureParenGroup];\r
- uint64_t Val;\r
- if (MatchedValue.getAsInteger(10, Val))\r
- return FileCheckErrorDiagnostic::get(SM, MatchedValue,\r
- "Unable to represent numeric value");\r
- DefinedNumericVariable->setValue(Val);\r
- }\r
-\r
- // Like CHECK-NEXT, CHECK-EMPTY's match range is considered to start after\r
- // the required preceding newline, which is consumed by the pattern in the\r
- // case of CHECK-EMPTY but not CHECK-NEXT.\r
- size_t MatchStartSkip = CheckTy == Check::CheckEmpty;\r
- MatchLen = FullMatch.size() - MatchStartSkip;\r
- return FullMatch.data() - Buffer.data() + MatchStartSkip;\r
-}\r
-\r
-unsigned FileCheckPattern::computeMatchDistance(StringRef Buffer) const {\r
- // Just compute the number of matching characters. For regular expressions, we\r
- // just compare against the regex itself and hope for the best.\r
- //\r
- // FIXME: One easy improvement here is have the regex lib generate a single\r
- // example regular expression which matches, and use that as the example\r
- // string.\r
- StringRef ExampleString(FixedStr);\r
- if (ExampleString.empty())\r
- ExampleString = RegExStr;\r
-\r
- // Only compare up to the first line in the buffer, or the string size.\r
- StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());\r
- BufferPrefix = BufferPrefix.split('\n').first;\r
- return BufferPrefix.edit_distance(ExampleString);\r
-}\r
-\r
-void FileCheckPattern::printSubstitutions(const SourceMgr &SM, StringRef Buffer,\r
- SMRange MatchRange) const {\r
- // Print what we know about substitutions.\r
- if (!Substitutions.empty()) {\r
- for (const auto &Substitution : Substitutions) {\r
- SmallString<256> Msg;\r
- raw_svector_ostream OS(Msg);\r
- Expected<std::string> MatchedValue = Substitution->getResult();\r
-\r
- // Substitution failed or is not known at match time, print the undefined\r
- // variables it uses.\r
- if (!MatchedValue) {\r
- bool UndefSeen = false;\r
- handleAllErrors(MatchedValue.takeError(),\r
- [](const FileCheckNotFoundError &E) {},\r
- // Handled in PrintNoMatch().\r
- [](const FileCheckErrorDiagnostic &E) {},\r
- [&](const FileCheckUndefVarError &E) {\r
- if (!UndefSeen) {\r
- OS << "uses undefined variable(s):";\r
- UndefSeen = true;\r
- }\r
- OS << " ";\r
- E.log(OS);\r
- });\r
- } else {\r
- // Substitution succeeded. Print substituted value.\r
- OS << "with \"";\r
- OS.write_escaped(Substitution->getFromString()) << "\" equal to \"";\r
- OS.write_escaped(*MatchedValue) << "\"";\r
- }\r
-\r
- if (MatchRange.isValid())\r
- SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, OS.str(),\r
- {MatchRange});\r
- else\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),\r
- SourceMgr::DK_Note, OS.str());\r
- }\r
- }\r
-}\r
-\r
-static SMRange ProcessMatchResult(FileCheckDiag::MatchType MatchTy,\r
- const SourceMgr &SM, SMLoc Loc,\r
- Check::FileCheckType CheckTy,\r
- StringRef Buffer, size_t Pos, size_t Len,\r
- std::vector<FileCheckDiag> *Diags,\r
- bool AdjustPrevDiag = false) {\r
- SMLoc Start = SMLoc::getFromPointer(Buffer.data() + Pos);\r
- SMLoc End = SMLoc::getFromPointer(Buffer.data() + Pos + Len);\r
- SMRange Range(Start, End);\r
- if (Diags) {\r
- if (AdjustPrevDiag)\r
- Diags->rbegin()->MatchTy = MatchTy;\r
- else\r
- Diags->emplace_back(SM, CheckTy, Loc, MatchTy, Range);\r
- }\r
- return Range;\r
-}\r
-\r
-void FileCheckPattern::printFuzzyMatch(\r
- const SourceMgr &SM, StringRef Buffer,\r
- std::vector<FileCheckDiag> *Diags) const {\r
- // Attempt to find the closest/best fuzzy match. Usually an error happens\r
- // because some string in the output didn't exactly match. In these cases, we\r
- // would like to show the user a best guess at what "should have" matched, to\r
- // save them having to actually check the input manually.\r
- size_t NumLinesForward = 0;\r
- size_t Best = StringRef::npos;\r
- double BestQuality = 0;\r
-\r
- // Use an arbitrary 4k limit on how far we will search.\r
- for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) {\r
- if (Buffer[i] == '\n')\r
- ++NumLinesForward;\r
-\r
- // Patterns have leading whitespace stripped, so skip whitespace when\r
- // looking for something which looks like a pattern.\r
- if (Buffer[i] == ' ' || Buffer[i] == '\t')\r
- continue;\r
-\r
- // Compute the "quality" of this match as an arbitrary combination of the\r
- // match distance and the number of lines skipped to get to this match.\r
- unsigned Distance = computeMatchDistance(Buffer.substr(i));\r
- double Quality = Distance + (NumLinesForward / 100.);\r
-\r
- if (Quality < BestQuality || Best == StringRef::npos) {\r
- Best = i;\r
- BestQuality = Quality;\r
- }\r
- }\r
-\r
- // Print the "possible intended match here" line if we found something\r
- // reasonable and not equal to what we showed in the "scanning from here"\r
- // line.\r
- if (Best && Best != StringRef::npos && BestQuality < 50) {\r
- SMRange MatchRange =\r
- ProcessMatchResult(FileCheckDiag::MatchFuzzy, SM, getLoc(),\r
- getCheckTy(), Buffer, Best, 0, Diags);\r
- SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note,\r
- "possible intended match here");\r
-\r
- // FIXME: If we wanted to be really friendly we would show why the match\r
- // failed, as it can be hard to spot simple one character differences.\r
- }\r
-}\r
-\r
-Expected<StringRef>\r
-FileCheckPatternContext::getPatternVarValue(StringRef VarName) {\r
- auto VarIter = GlobalVariableTable.find(VarName);\r
- if (VarIter == GlobalVariableTable.end())\r
- return make_error<FileCheckUndefVarError>(VarName);\r
-\r
- return VarIter->second;\r
-}\r
-\r
-template <class... Types>\r
-FileCheckNumericVariable *\r
-FileCheckPatternContext::makeNumericVariable(Types... args) {\r
- NumericVariables.push_back(\r
- std::make_unique<FileCheckNumericVariable>(args...));\r
- return NumericVariables.back().get();\r
-}\r
-\r
-FileCheckSubstitution *\r
-FileCheckPatternContext::makeStringSubstitution(StringRef VarName,\r
- size_t InsertIdx) {\r
- Substitutions.push_back(\r
- std::make_unique<FileCheckStringSubstitution>(this, VarName, InsertIdx));\r
- return Substitutions.back().get();\r
-}\r
-\r
-FileCheckSubstitution *FileCheckPatternContext::makeNumericSubstitution(\r
- StringRef ExpressionStr,\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST, size_t InsertIdx) {\r
- Substitutions.push_back(std::make_unique<FileCheckNumericSubstitution>(\r
- this, ExpressionStr, std::move(ExpressionAST), InsertIdx));\r
- return Substitutions.back().get();\r
-}\r
-\r
-size_t FileCheckPattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {\r
- // Offset keeps track of the current offset within the input Str\r
- size_t Offset = 0;\r
- // [...] Nesting depth\r
- size_t BracketDepth = 0;\r
-\r
- while (!Str.empty()) {\r
- if (Str.startswith("]]") && BracketDepth == 0)\r
- return Offset;\r
- if (Str[0] == '\\') {\r
- // Backslash escapes the next char within regexes, so skip them both.\r
- Str = Str.substr(2);\r
- Offset += 2;\r
- } else {\r
- switch (Str[0]) {\r
- default:\r
- break;\r
- case '[':\r
- BracketDepth++;\r
- break;\r
- case ']':\r
- if (BracketDepth == 0) {\r
- SM.PrintMessage(SMLoc::getFromPointer(Str.data()),\r
- SourceMgr::DK_Error,\r
- "missing closing \"]\" for regex variable");\r
- exit(1);\r
- }\r
- BracketDepth--;\r
- break;\r
- }\r
- Str = Str.substr(1);\r
- Offset++;\r
- }\r
- }\r
-\r
- return StringRef::npos;\r
-}\r
-\r
-StringRef FileCheck::CanonicalizeFile(MemoryBuffer &MB,\r
- SmallVectorImpl<char> &OutputBuffer) {\r
- OutputBuffer.reserve(MB.getBufferSize());\r
-\r
- for (const char *Ptr = MB.getBufferStart(), *End = MB.getBufferEnd();\r
- Ptr != End; ++Ptr) {\r
- // Eliminate trailing dosish \r.\r
- if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') {\r
- continue;\r
- }\r
-\r
- // If current char is not a horizontal whitespace or if horizontal\r
- // whitespace canonicalization is disabled, dump it to output as is.\r
- if (Req.NoCanonicalizeWhiteSpace || (*Ptr != ' ' && *Ptr != '\t')) {\r
- OutputBuffer.push_back(*Ptr);\r
- continue;\r
- }\r
-\r
- // Otherwise, add one space and advance over neighboring space.\r
- OutputBuffer.push_back(' ');\r
- while (Ptr + 1 != End && (Ptr[1] == ' ' || Ptr[1] == '\t'))\r
- ++Ptr;\r
- }\r
-\r
- // Add a null byte and then return all but that byte.\r
- OutputBuffer.push_back('\0');\r
- return StringRef(OutputBuffer.data(), OutputBuffer.size() - 1);\r
-}\r
-\r
-FileCheckDiag::FileCheckDiag(const SourceMgr &SM,\r
- const Check::FileCheckType &CheckTy,\r
- SMLoc CheckLoc, MatchType MatchTy,\r
- SMRange InputRange)\r
- : CheckTy(CheckTy), MatchTy(MatchTy) {\r
- auto Start = SM.getLineAndColumn(InputRange.Start);\r
- auto End = SM.getLineAndColumn(InputRange.End);\r
- InputStartLine = Start.first;\r
- InputStartCol = Start.second;\r
- InputEndLine = End.first;\r
- InputEndCol = End.second;\r
- Start = SM.getLineAndColumn(CheckLoc);\r
- CheckLine = Start.first;\r
- CheckCol = Start.second;\r
-}\r
-\r
-static bool IsPartOfWord(char c) {\r
- return (isalnum(c) || c == '-' || c == '_');\r
-}\r
-\r
-Check::FileCheckType &Check::FileCheckType::setCount(int C) {\r
- assert(Count > 0 && "zero and negative counts are not supported");\r
- assert((C == 1 || Kind == CheckPlain) &&\r
- "count supported only for plain CHECK directives");\r
- Count = C;\r
- return *this;\r
-}\r
-\r
-std::string Check::FileCheckType::getDescription(StringRef Prefix) const {\r
- switch (Kind) {\r
- case Check::CheckNone:\r
- return "invalid";\r
- case Check::CheckPlain:\r
- if (Count > 1)\r
- return Prefix.str() + "-COUNT";\r
- return Prefix;\r
- case Check::CheckNext:\r
- return Prefix.str() + "-NEXT";\r
- case Check::CheckSame:\r
- return Prefix.str() + "-SAME";\r
- case Check::CheckNot:\r
- return Prefix.str() + "-NOT";\r
- case Check::CheckDAG:\r
- return Prefix.str() + "-DAG";\r
- case Check::CheckLabel:\r
- return Prefix.str() + "-LABEL";\r
- case Check::CheckEmpty:\r
- return Prefix.str() + "-EMPTY";\r
- case Check::CheckEOF:\r
- return "implicit EOF";\r
- case Check::CheckBadNot:\r
- return "bad NOT";\r
- case Check::CheckBadCount:\r
- return "bad COUNT";\r
- }\r
- llvm_unreachable("unknown FileCheckType");\r
-}\r
-\r
-static std::pair<Check::FileCheckType, StringRef>\r
-FindCheckType(StringRef Buffer, StringRef Prefix) {\r
- if (Buffer.size() <= Prefix.size())\r
- return {Check::CheckNone, StringRef()};\r
-\r
- char NextChar = Buffer[Prefix.size()];\r
-\r
- StringRef Rest = Buffer.drop_front(Prefix.size() + 1);\r
- // Verify that the : is present after the prefix.\r
- if (NextChar == ':')\r
- return {Check::CheckPlain, Rest};\r
-\r
- if (NextChar != '-')\r
- return {Check::CheckNone, StringRef()};\r
-\r
- if (Rest.consume_front("COUNT-")) {\r
- int64_t Count;\r
- if (Rest.consumeInteger(10, Count))\r
- // Error happened in parsing integer.\r
- return {Check::CheckBadCount, Rest};\r
- if (Count <= 0 || Count > INT32_MAX)\r
- return {Check::CheckBadCount, Rest};\r
- if (!Rest.consume_front(":"))\r
- return {Check::CheckBadCount, Rest};\r
- return {Check::FileCheckType(Check::CheckPlain).setCount(Count), Rest};\r
- }\r
-\r
- if (Rest.consume_front("NEXT:"))\r
- return {Check::CheckNext, Rest};\r
-\r
- if (Rest.consume_front("SAME:"))\r
- return {Check::CheckSame, Rest};\r
-\r
- if (Rest.consume_front("NOT:"))\r
- return {Check::CheckNot, Rest};\r
-\r
- if (Rest.consume_front("DAG:"))\r
- return {Check::CheckDAG, Rest};\r
-\r
- if (Rest.consume_front("LABEL:"))\r
- return {Check::CheckLabel, Rest};\r
-\r
- if (Rest.consume_front("EMPTY:"))\r
- return {Check::CheckEmpty, Rest};\r
-\r
- // You can't combine -NOT with another suffix.\r
- if (Rest.startswith("DAG-NOT:") || Rest.startswith("NOT-DAG:") ||\r
- Rest.startswith("NEXT-NOT:") || Rest.startswith("NOT-NEXT:") ||\r
- Rest.startswith("SAME-NOT:") || Rest.startswith("NOT-SAME:") ||\r
- Rest.startswith("EMPTY-NOT:") || Rest.startswith("NOT-EMPTY:"))\r
- return {Check::CheckBadNot, Rest};\r
-\r
- return {Check::CheckNone, Rest};\r
-}\r
-\r
-// From the given position, find the next character after the word.\r
-static size_t SkipWord(StringRef Str, size_t Loc) {\r
- while (Loc < Str.size() && IsPartOfWord(Str[Loc]))\r
- ++Loc;\r
- return Loc;\r
-}\r
-\r
-/// Searches the buffer for the first prefix in the prefix regular expression.\r
-///\r
-/// This searches the buffer using the provided regular expression, however it\r
-/// enforces constraints beyond that:\r
-/// 1) The found prefix must not be a suffix of something that looks like\r
-/// a valid prefix.\r
-/// 2) The found prefix must be followed by a valid check type suffix using \c\r
-/// FindCheckType above.\r
-///\r
-/// \returns a pair of StringRefs into the Buffer, which combines:\r
-/// - the first match of the regular expression to satisfy these two is\r
-/// returned,\r
-/// otherwise an empty StringRef is returned to indicate failure.\r
-/// - buffer rewound to the location right after parsed suffix, for parsing\r
-/// to continue from\r
-///\r
-/// If this routine returns a valid prefix, it will also shrink \p Buffer to\r
-/// start at the beginning of the returned prefix, increment \p LineNumber for\r
-/// each new line consumed from \p Buffer, and set \p CheckTy to the type of\r
-/// check found by examining the suffix.\r
-///\r
-/// If no valid prefix is found, the state of Buffer, LineNumber, and CheckTy\r
-/// is unspecified.\r
-static std::pair<StringRef, StringRef>\r
-FindFirstMatchingPrefix(Regex &PrefixRE, StringRef &Buffer,\r
- unsigned &LineNumber, Check::FileCheckType &CheckTy) {\r
- SmallVector<StringRef, 2> Matches;\r
-\r
- while (!Buffer.empty()) {\r
- // Find the first (longest) match using the RE.\r
- if (!PrefixRE.match(Buffer, &Matches))\r
- // No match at all, bail.\r
- return {StringRef(), StringRef()};\r
-\r
- StringRef Prefix = Matches[0];\r
- Matches.clear();\r
-\r
- assert(Prefix.data() >= Buffer.data() &&\r
- Prefix.data() < Buffer.data() + Buffer.size() &&\r
- "Prefix doesn't start inside of buffer!");\r
- size_t Loc = Prefix.data() - Buffer.data();\r
- StringRef Skipped = Buffer.substr(0, Loc);\r
- Buffer = Buffer.drop_front(Loc);\r
- LineNumber += Skipped.count('\n');\r
-\r
- // Check that the matched prefix isn't a suffix of some other check-like\r
- // word.\r
- // FIXME: This is a very ad-hoc check. it would be better handled in some\r
- // other way. Among other things it seems hard to distinguish between\r
- // intentional and unintentional uses of this feature.\r
- if (Skipped.empty() || !IsPartOfWord(Skipped.back())) {\r
- // Now extract the type.\r
- StringRef AfterSuffix;\r
- std::tie(CheckTy, AfterSuffix) = FindCheckType(Buffer, Prefix);\r
-\r
- // If we've found a valid check type for this prefix, we're done.\r
- if (CheckTy != Check::CheckNone)\r
- return {Prefix, AfterSuffix};\r
- }\r
-\r
- // If we didn't successfully find a prefix, we need to skip this invalid\r
- // prefix and continue scanning. We directly skip the prefix that was\r
- // matched and any additional parts of that check-like word.\r
- Buffer = Buffer.drop_front(SkipWord(Buffer, Prefix.size()));\r
- }\r
-\r
- // We ran out of buffer while skipping partial matches so give up.\r
- return {StringRef(), StringRef()};\r
-}\r
-\r
-void FileCheckPatternContext::createLineVariable() {\r
- assert(!LineVariable && "@LINE pseudo numeric variable already created");\r
- StringRef LineName = "@LINE";\r
- LineVariable = makeNumericVariable(LineName);\r
- GlobalNumericVariableTable[LineName] = LineVariable;\r
-}\r
-\r
-FileCheck::FileCheck(FileCheckRequest Req)\r
- : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),\r
- CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}\r
-\r
-FileCheck::~FileCheck() = default;\r
-\r
-bool FileCheck::readCheckFile(SourceMgr &SM, StringRef Buffer,\r
- Regex &PrefixRE) {\r
- Error DefineError =\r
- PatternContext->defineCmdlineVariables(Req.GlobalDefines, SM);\r
- if (DefineError) {\r
- logAllUnhandledErrors(std::move(DefineError), errs());\r
- return true;\r
- }\r
-\r
- PatternContext->createLineVariable();\r
-\r
- std::vector<FileCheckPattern> ImplicitNegativeChecks;\r
- for (const auto &PatternString : Req.ImplicitCheckNot) {\r
- // Create a buffer with fake command line content in order to display the\r
- // command line option responsible for the specific implicit CHECK-NOT.\r
- std::string Prefix = "-implicit-check-not='";\r
- std::string Suffix = "'";\r
- std::unique_ptr<MemoryBuffer> CmdLine = MemoryBuffer::getMemBufferCopy(\r
- Prefix + PatternString + Suffix, "command line");\r
-\r
- StringRef PatternInBuffer =\r
- CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());\r
- SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());\r
-\r
- ImplicitNegativeChecks.push_back(\r
- FileCheckPattern(Check::CheckNot, PatternContext.get()));\r
- ImplicitNegativeChecks.back().parsePattern(PatternInBuffer,\r
- "IMPLICIT-CHECK", SM, Req);\r
- }\r
-\r
- std::vector<FileCheckPattern> DagNotMatches = ImplicitNegativeChecks;\r
-\r
- // LineNumber keeps track of the line on which CheckPrefix instances are\r
- // found.\r
- unsigned LineNumber = 1;\r
-\r
- while (1) {\r
- Check::FileCheckType CheckTy;\r
-\r
- // See if a prefix occurs in the memory buffer.\r
- StringRef UsedPrefix;\r
- StringRef AfterSuffix;\r
- std::tie(UsedPrefix, AfterSuffix) =\r
- FindFirstMatchingPrefix(PrefixRE, Buffer, LineNumber, CheckTy);\r
- if (UsedPrefix.empty())\r
- break;\r
- assert(UsedPrefix.data() == Buffer.data() &&\r
- "Failed to move Buffer's start forward, or pointed prefix outside "\r
- "of the buffer!");\r
- assert(AfterSuffix.data() >= Buffer.data() &&\r
- AfterSuffix.data() < Buffer.data() + Buffer.size() &&\r
- "Parsing after suffix doesn't start inside of buffer!");\r
-\r
- // Location to use for error messages.\r
- const char *UsedPrefixStart = UsedPrefix.data();\r
-\r
- // Skip the buffer to the end of parsed suffix (or just prefix, if no good\r
- // suffix was processed).\r
- Buffer = AfterSuffix.empty() ? Buffer.drop_front(UsedPrefix.size())\r
- : AfterSuffix;\r
-\r
- // Complain about useful-looking but unsupported suffixes.\r
- if (CheckTy == Check::CheckBadNot) {\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,\r
- "unsupported -NOT combo on prefix '" + UsedPrefix + "'");\r
- return true;\r
- }\r
-\r
- // Complain about invalid count specification.\r
- if (CheckTy == Check::CheckBadCount) {\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,\r
- "invalid count in -COUNT specification on prefix '" +\r
- UsedPrefix + "'");\r
- return true;\r
- }\r
-\r
- // Okay, we found the prefix, yay. Remember the rest of the line, but ignore\r
- // leading whitespace.\r
- if (!(Req.NoCanonicalizeWhiteSpace && Req.MatchFullLines))\r
- Buffer = Buffer.substr(Buffer.find_first_not_of(" \t"));\r
-\r
- // Scan ahead to the end of line.\r
- size_t EOL = Buffer.find_first_of("\n\r");\r
-\r
- // Remember the location of the start of the pattern, for diagnostics.\r
- SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());\r
-\r
- // Parse the pattern.\r
- FileCheckPattern P(CheckTy, PatternContext.get(), LineNumber);\r
- if (P.parsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, Req))\r
- return true;\r
-\r
- // Verify that CHECK-LABEL lines do not define or use variables\r
- if ((CheckTy == Check::CheckLabel) && P.hasVariable()) {\r
- SM.PrintMessage(\r
- SMLoc::getFromPointer(UsedPrefixStart), SourceMgr::DK_Error,\r
- "found '" + UsedPrefix + "-LABEL:'"\r
- " with variable definition or use");\r
- return true;\r
- }\r
-\r
- Buffer = Buffer.substr(EOL);\r
-\r
- // Verify that CHECK-NEXT/SAME/EMPTY lines have at least one CHECK line before them.\r
- if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame ||\r
- CheckTy == Check::CheckEmpty) &&\r
- CheckStrings->empty()) {\r
- StringRef Type = CheckTy == Check::CheckNext\r
- ? "NEXT"\r
- : CheckTy == Check::CheckEmpty ? "EMPTY" : "SAME";\r
- SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),\r
- SourceMgr::DK_Error,\r
- "found '" + UsedPrefix + "-" + Type +\r
- "' without previous '" + UsedPrefix + ": line");\r
- return true;\r
- }\r
-\r
- // Handle CHECK-DAG/-NOT.\r
- if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) {\r
- DagNotMatches.push_back(P);\r
- continue;\r
- }\r
-\r
- // Okay, add the string we captured to the output vector and move on.\r
- CheckStrings->emplace_back(P, UsedPrefix, PatternLoc);\r
- std::swap(DagNotMatches, CheckStrings->back().DagNotStrings);\r
- DagNotMatches = ImplicitNegativeChecks;\r
- }\r
-\r
- // Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first\r
- // prefix as a filler for the error message.\r
- if (!DagNotMatches.empty()) {\r
- CheckStrings->emplace_back(\r
- FileCheckPattern(Check::CheckEOF, PatternContext.get(), LineNumber + 1),\r
- *Req.CheckPrefixes.begin(), SMLoc::getFromPointer(Buffer.data()));\r
- std::swap(DagNotMatches, CheckStrings->back().DagNotStrings);\r
- }\r
-\r
- if (CheckStrings->empty()) {\r
- errs() << "error: no check strings found with prefix"\r
- << (Req.CheckPrefixes.size() > 1 ? "es " : " ");\r
- auto I = Req.CheckPrefixes.begin();\r
- auto E = Req.CheckPrefixes.end();\r
- if (I != E) {\r
- errs() << "\'" << *I << ":'";\r
- ++I;\r
- }\r
- for (; I != E; ++I)\r
- errs() << ", \'" << *I << ":'";\r
-\r
- errs() << '\n';\r
- return true;\r
- }\r
-\r
- return false;\r
-}\r
-\r
-static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,\r
- StringRef Prefix, SMLoc Loc, const FileCheckPattern &Pat,\r
- int MatchedCount, StringRef Buffer, size_t MatchPos,\r
- size_t MatchLen, const FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) {\r
- bool PrintDiag = true;\r
- if (ExpectedMatch) {\r
- if (!Req.Verbose)\r
- return;\r
- if (!Req.VerboseVerbose && Pat.getCheckTy() == Check::CheckEOF)\r
- return;\r
- // Due to their verbosity, we don't print verbose diagnostics here if we're\r
- // gathering them for a different rendering, but we always print other\r
- // diagnostics.\r
- PrintDiag = !Diags;\r
- }\r
- SMRange MatchRange = ProcessMatchResult(\r
- ExpectedMatch ? FileCheckDiag::MatchFoundAndExpected\r
- : FileCheckDiag::MatchFoundButExcluded,\r
- SM, Loc, Pat.getCheckTy(), Buffer, MatchPos, MatchLen, Diags);\r
- if (!PrintDiag)\r
- return;\r
-\r
- std::string Message = formatv("{0}: {1} string found in input",\r
- Pat.getCheckTy().getDescription(Prefix),\r
- (ExpectedMatch ? "expected" : "excluded"))\r
- .str();\r
- if (Pat.getCount() > 1)\r
- Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();\r
-\r
- SM.PrintMessage(\r
- Loc, ExpectedMatch ? SourceMgr::DK_Remark : SourceMgr::DK_Error, Message);\r
- SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, "found here",\r
- {MatchRange});\r
- Pat.printSubstitutions(SM, Buffer, MatchRange);\r
-}\r
-\r
-static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,\r
- const FileCheckString &CheckStr, int MatchedCount,\r
- StringRef Buffer, size_t MatchPos, size_t MatchLen,\r
- FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) {\r
- PrintMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,\r
- MatchedCount, Buffer, MatchPos, MatchLen, Req, Diags);\r
-}\r
-\r
-static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,\r
- StringRef Prefix, SMLoc Loc,\r
- const FileCheckPattern &Pat, int MatchedCount,\r
- StringRef Buffer, bool VerboseVerbose,\r
- std::vector<FileCheckDiag> *Diags, Error MatchErrors) {\r
- assert(MatchErrors && "Called on successful match");\r
- bool PrintDiag = true;\r
- if (!ExpectedMatch) {\r
- if (!VerboseVerbose) {\r
- consumeError(std::move(MatchErrors));\r
- return;\r
- }\r
- // Due to their verbosity, we don't print verbose diagnostics here if we're\r
- // gathering them for a different rendering, but we always print other\r
- // diagnostics.\r
- PrintDiag = !Diags;\r
- }\r
-\r
- // If the current position is at the end of a line, advance to the start of\r
- // the next line.\r
- Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r"));\r
- SMRange SearchRange = ProcessMatchResult(\r
- ExpectedMatch ? FileCheckDiag::MatchNoneButExpected\r
- : FileCheckDiag::MatchNoneAndExcluded,\r
- SM, Loc, Pat.getCheckTy(), Buffer, 0, Buffer.size(), Diags);\r
- if (!PrintDiag) {\r
- consumeError(std::move(MatchErrors));\r
- return;\r
- }\r
-\r
- MatchErrors =\r
- handleErrors(std::move(MatchErrors),\r
- [](const FileCheckErrorDiagnostic &E) { E.log(errs()); });\r
-\r
- // No problem matching the string per se.\r
- if (!MatchErrors)\r
- return;\r
- consumeError(std::move(MatchErrors));\r
-\r
- // Print "not found" diagnostic.\r
- std::string Message = formatv("{0}: {1} string not found in input",\r
- Pat.getCheckTy().getDescription(Prefix),\r
- (ExpectedMatch ? "expected" : "excluded"))\r
- .str();\r
- if (Pat.getCount() > 1)\r
- Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();\r
- SM.PrintMessage(\r
- Loc, ExpectedMatch ? SourceMgr::DK_Error : SourceMgr::DK_Remark, Message);\r
-\r
- // Print the "scanning from here" line.\r
- SM.PrintMessage(SearchRange.Start, SourceMgr::DK_Note, "scanning from here");\r
-\r
- // Allow the pattern to print additional information if desired.\r
- Pat.printSubstitutions(SM, Buffer);\r
-\r
- if (ExpectedMatch)\r
- Pat.printFuzzyMatch(SM, Buffer, Diags);\r
-}\r
-\r
-static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,\r
- const FileCheckString &CheckStr, int MatchedCount,\r
- StringRef Buffer, bool VerboseVerbose,\r
- std::vector<FileCheckDiag> *Diags, Error MatchErrors) {\r
- PrintNoMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,\r
- MatchedCount, Buffer, VerboseVerbose, Diags,\r
- std::move(MatchErrors));\r
-}\r
-\r
-/// Counts the number of newlines in the specified range.\r
-static unsigned CountNumNewlinesBetween(StringRef Range,\r
- const char *&FirstNewLine) {\r
- unsigned NumNewLines = 0;\r
- while (1) {\r
- // Scan for newline.\r
- Range = Range.substr(Range.find_first_of("\n\r"));\r
- if (Range.empty())\r
- return NumNewLines;\r
-\r
- ++NumNewLines;\r
-\r
- // Handle \n\r and \r\n as a single newline.\r
- if (Range.size() > 1 && (Range[1] == '\n' || Range[1] == '\r') &&\r
- (Range[0] != Range[1]))\r
- Range = Range.substr(1);\r
- Range = Range.substr(1);\r
-\r
- if (NumNewLines == 1)\r
- FirstNewLine = Range.begin();\r
- }\r
-}\r
-\r
-size_t FileCheckString::Check(const SourceMgr &SM, StringRef Buffer,\r
- bool IsLabelScanMode, size_t &MatchLen,\r
- FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) const {\r
- size_t LastPos = 0;\r
- std::vector<const FileCheckPattern *> NotStrings;\r
-\r
- // IsLabelScanMode is true when we are scanning forward to find CHECK-LABEL\r
- // bounds; we have not processed variable definitions within the bounded block\r
- // yet so cannot handle any final CHECK-DAG yet; this is handled when going\r
- // over the block again (including the last CHECK-LABEL) in normal mode.\r
- if (!IsLabelScanMode) {\r
- // Match "dag strings" (with mixed "not strings" if any).\r
- LastPos = CheckDag(SM, Buffer, NotStrings, Req, Diags);\r
- if (LastPos == StringRef::npos)\r
- return StringRef::npos;\r
- }\r
-\r
- // Match itself from the last position after matching CHECK-DAG.\r
- size_t LastMatchEnd = LastPos;\r
- size_t FirstMatchPos = 0;\r
- // Go match the pattern Count times. Majority of patterns only match with\r
- // count 1 though.\r
- assert(Pat.getCount() != 0 && "pattern count can not be zero");\r
- for (int i = 1; i <= Pat.getCount(); i++) {\r
- StringRef MatchBuffer = Buffer.substr(LastMatchEnd);\r
- size_t CurrentMatchLen;\r
- // get a match at current start point\r
- Expected<size_t> MatchResult = Pat.match(MatchBuffer, CurrentMatchLen, SM);\r
-\r
- // report\r
- if (!MatchResult) {\r
- PrintNoMatch(true, SM, *this, i, MatchBuffer, Req.VerboseVerbose, Diags,\r
- MatchResult.takeError());\r
- return StringRef::npos;\r
- }\r
- size_t MatchPos = *MatchResult;\r
- PrintMatch(true, SM, *this, i, MatchBuffer, MatchPos, CurrentMatchLen, Req,\r
- Diags);\r
- if (i == 1)\r
- FirstMatchPos = LastPos + MatchPos;\r
-\r
- // move start point after the match\r
- LastMatchEnd += MatchPos + CurrentMatchLen;\r
- }\r
- // Full match len counts from first match pos.\r
- MatchLen = LastMatchEnd - FirstMatchPos;\r
-\r
- // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT\r
- // or CHECK-NOT\r
- if (!IsLabelScanMode) {\r
- size_t MatchPos = FirstMatchPos - LastPos;\r
- StringRef MatchBuffer = Buffer.substr(LastPos);\r
- StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos);\r
-\r
- // If this check is a "CHECK-NEXT", verify that the previous match was on\r
- // the previous line (i.e. that there is one newline between them).\r
- if (CheckNext(SM, SkippedRegion)) {\r
- ProcessMatchResult(FileCheckDiag::MatchFoundButWrongLine, SM, Loc,\r
- Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,\r
- Diags, Req.Verbose);\r
- return StringRef::npos;\r
- }\r
-\r
- // If this check is a "CHECK-SAME", verify that the previous match was on\r
- // the same line (i.e. that there is no newline between them).\r
- if (CheckSame(SM, SkippedRegion)) {\r
- ProcessMatchResult(FileCheckDiag::MatchFoundButWrongLine, SM, Loc,\r
- Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,\r
- Diags, Req.Verbose);\r
- return StringRef::npos;\r
- }\r
-\r
- // If this match had "not strings", verify that they don't exist in the\r
- // skipped region.\r
- if (CheckNot(SM, SkippedRegion, NotStrings, Req, Diags))\r
- return StringRef::npos;\r
- }\r
-\r
- return FirstMatchPos;\r
-}\r
-\r
-bool FileCheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const {\r
- if (Pat.getCheckTy() != Check::CheckNext &&\r
- Pat.getCheckTy() != Check::CheckEmpty)\r
- return false;\r
-\r
- Twine CheckName =\r
- Prefix +\r
- Twine(Pat.getCheckTy() == Check::CheckEmpty ? "-EMPTY" : "-NEXT");\r
-\r
- // Count the number of newlines between the previous match and this one.\r
- const char *FirstNewLine = nullptr;\r
- unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine);\r
-\r
- if (NumNewLines == 0) {\r
- SM.PrintMessage(Loc, SourceMgr::DK_Error,\r
- CheckName + ": is on the same line as previous match");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,\r
- "'next' match was here");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,\r
- "previous match ended here");\r
- return true;\r
- }\r
-\r
- if (NumNewLines != 1) {\r
- SM.PrintMessage(Loc, SourceMgr::DK_Error,\r
- CheckName +\r
- ": is not on the line after the previous match");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,\r
- "'next' match was here");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,\r
- "previous match ended here");\r
- SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note,\r
- "non-matching line after previous match is here");\r
- return true;\r
- }\r
-\r
- return false;\r
-}\r
-\r
-bool FileCheckString::CheckSame(const SourceMgr &SM, StringRef Buffer) const {\r
- if (Pat.getCheckTy() != Check::CheckSame)\r
- return false;\r
-\r
- // Count the number of newlines between the previous match and this one.\r
- const char *FirstNewLine = nullptr;\r
- unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine);\r
-\r
- if (NumNewLines != 0) {\r
- SM.PrintMessage(Loc, SourceMgr::DK_Error,\r
- Prefix +\r
- "-SAME: is not on the same line as the previous match");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,\r
- "'next' match was here");\r
- SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,\r
- "previous match ended here");\r
- return true;\r
- }\r
-\r
- return false;\r
-}\r
-\r
-bool FileCheckString::CheckNot(\r
- const SourceMgr &SM, StringRef Buffer,\r
- const std::vector<const FileCheckPattern *> &NotStrings,\r
- const FileCheckRequest &Req, std::vector<FileCheckDiag> *Diags) const {\r
- for (const FileCheckPattern *Pat : NotStrings) {\r
- assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!");\r
-\r
- size_t MatchLen = 0;\r
- Expected<size_t> MatchResult = Pat->match(Buffer, MatchLen, SM);\r
-\r
- if (!MatchResult) {\r
- PrintNoMatch(false, SM, Prefix, Pat->getLoc(), *Pat, 1, Buffer,\r
- Req.VerboseVerbose, Diags, MatchResult.takeError());\r
- continue;\r
- }\r
- size_t Pos = *MatchResult;\r
-\r
- PrintMatch(false, SM, Prefix, Pat->getLoc(), *Pat, 1, Buffer, Pos, MatchLen,\r
- Req, Diags);\r
-\r
- return true;\r
- }\r
-\r
- return false;\r
-}\r
-\r
-size_t\r
-FileCheckString::CheckDag(const SourceMgr &SM, StringRef Buffer,\r
- std::vector<const FileCheckPattern *> &NotStrings,\r
- const FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) const {\r
- if (DagNotStrings.empty())\r
- return 0;\r
-\r
- // The start of the search range.\r
- size_t StartPos = 0;\r
-\r
- struct MatchRange {\r
- size_t Pos;\r
- size_t End;\r
- };\r
- // A sorted list of ranges for non-overlapping CHECK-DAG matches. Match\r
- // ranges are erased from this list once they are no longer in the search\r
- // range.\r
- std::list<MatchRange> MatchRanges;\r
-\r
- // We need PatItr and PatEnd later for detecting the end of a CHECK-DAG\r
- // group, so we don't use a range-based for loop here.\r
- for (auto PatItr = DagNotStrings.begin(), PatEnd = DagNotStrings.end();\r
- PatItr != PatEnd; ++PatItr) {\r
- const FileCheckPattern &Pat = *PatItr;\r
- assert((Pat.getCheckTy() == Check::CheckDAG ||\r
- Pat.getCheckTy() == Check::CheckNot) &&\r
- "Invalid CHECK-DAG or CHECK-NOT!");\r
-\r
- if (Pat.getCheckTy() == Check::CheckNot) {\r
- NotStrings.push_back(&Pat);\r
- continue;\r
- }\r
-\r
- assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!");\r
-\r
- // CHECK-DAG always matches from the start.\r
- size_t MatchLen = 0, MatchPos = StartPos;\r
-\r
- // Search for a match that doesn't overlap a previous match in this\r
- // CHECK-DAG group.\r
- for (auto MI = MatchRanges.begin(), ME = MatchRanges.end(); true; ++MI) {\r
- StringRef MatchBuffer = Buffer.substr(MatchPos);\r
- Expected<size_t> MatchResult = Pat.match(MatchBuffer, MatchLen, SM);\r
- // With a group of CHECK-DAGs, a single mismatching means the match on\r
- // that group of CHECK-DAGs fails immediately.\r
- if (!MatchResult) {\r
- PrintNoMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, MatchBuffer,\r
- Req.VerboseVerbose, Diags, MatchResult.takeError());\r
- return StringRef::npos;\r
- }\r
- size_t MatchPosBuf = *MatchResult;\r
- // Re-calc it as the offset relative to the start of the original string.\r
- MatchPos += MatchPosBuf;\r
- if (Req.VerboseVerbose)\r
- PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, Buffer, MatchPos,\r
- MatchLen, Req, Diags);\r
- MatchRange M{MatchPos, MatchPos + MatchLen};\r
- if (Req.AllowDeprecatedDagOverlap) {\r
- // We don't need to track all matches in this mode, so we just maintain\r
- // one match range that encompasses the current CHECK-DAG group's\r
- // matches.\r
- if (MatchRanges.empty())\r
- MatchRanges.insert(MatchRanges.end(), M);\r
- else {\r
- auto Block = MatchRanges.begin();\r
- Block->Pos = std::min(Block->Pos, M.Pos);\r
- Block->End = std::max(Block->End, M.End);\r
- }\r
- break;\r
- }\r
- // Iterate previous matches until overlapping match or insertion point.\r
- bool Overlap = false;\r
- for (; MI != ME; ++MI) {\r
- if (M.Pos < MI->End) {\r
- // !Overlap => New match has no overlap and is before this old match.\r
- // Overlap => New match overlaps this old match.\r
- Overlap = MI->Pos < M.End;\r
- break;\r
- }\r
- }\r
- if (!Overlap) {\r
- // Insert non-overlapping match into list.\r
- MatchRanges.insert(MI, M);\r
- break;\r
- }\r
- if (Req.VerboseVerbose) {\r
- // Due to their verbosity, we don't print verbose diagnostics here if\r
- // we're gathering them for a different rendering, but we always print\r
- // other diagnostics.\r
- if (!Diags) {\r
- SMLoc OldStart = SMLoc::getFromPointer(Buffer.data() + MI->Pos);\r
- SMLoc OldEnd = SMLoc::getFromPointer(Buffer.data() + MI->End);\r
- SMRange OldRange(OldStart, OldEnd);\r
- SM.PrintMessage(OldStart, SourceMgr::DK_Note,\r
- "match discarded, overlaps earlier DAG match here",\r
- {OldRange});\r
- } else\r
- Diags->rbegin()->MatchTy = FileCheckDiag::MatchFoundButDiscarded;\r
- }\r
- MatchPos = MI->End;\r
- }\r
- if (!Req.VerboseVerbose)\r
- PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, Buffer, MatchPos,\r
- MatchLen, Req, Diags);\r
-\r
- // Handle the end of a CHECK-DAG group.\r
- if (std::next(PatItr) == PatEnd ||\r
- std::next(PatItr)->getCheckTy() == Check::CheckNot) {\r
- if (!NotStrings.empty()) {\r
- // If there are CHECK-NOTs between two CHECK-DAGs or from CHECK to\r
- // CHECK-DAG, verify that there are no 'not' strings occurred in that\r
- // region.\r
- StringRef SkippedRegion =\r
- Buffer.slice(StartPos, MatchRanges.begin()->Pos);\r
- if (CheckNot(SM, SkippedRegion, NotStrings, Req, Diags))\r
- return StringRef::npos;\r
- // Clear "not strings".\r
- NotStrings.clear();\r
- }\r
- // All subsequent CHECK-DAGs and CHECK-NOTs should be matched from the\r
- // end of this CHECK-DAG group's match range.\r
- StartPos = MatchRanges.rbegin()->End;\r
- // Don't waste time checking for (impossible) overlaps before that.\r
- MatchRanges.clear();\r
- }\r
- }\r
-\r
- return StartPos;\r
-}\r
-\r
-// A check prefix must contain only alphanumeric, hyphens and underscores.\r
-static bool ValidateCheckPrefix(StringRef CheckPrefix) {\r
- static const Regex Validator("^[a-zA-Z0-9_-]*$");\r
- return Validator.match(CheckPrefix);\r
-}\r
-\r
-bool FileCheck::ValidateCheckPrefixes() {\r
- StringSet<> PrefixSet;\r
-\r
- for (StringRef Prefix : Req.CheckPrefixes) {\r
- // Reject empty prefixes.\r
- if (Prefix == "")\r
- return false;\r
-\r
- if (!PrefixSet.insert(Prefix).second)\r
- return false;\r
-\r
- if (!ValidateCheckPrefix(Prefix))\r
- return false;\r
- }\r
-\r
- return true;\r
-}\r
-\r
-Regex FileCheck::buildCheckPrefixRegex() {\r
- // I don't think there's a way to specify an initial value for cl::list,\r
- // so if nothing was specified, add the default\r
- if (Req.CheckPrefixes.empty())\r
- Req.CheckPrefixes.push_back("CHECK");\r
-\r
- // We already validated the contents of CheckPrefixes so just concatenate\r
- // them as alternatives.\r
- SmallString<32> PrefixRegexStr;\r
- for (StringRef Prefix : Req.CheckPrefixes) {\r
- if (Prefix != Req.CheckPrefixes.front())\r
- PrefixRegexStr.push_back('|');\r
-\r
- PrefixRegexStr.append(Prefix);\r
- }\r
-\r
- return Regex(PrefixRegexStr);\r
-}\r
-\r
-Error FileCheckPatternContext::defineCmdlineVariables(\r
- std::vector<std::string> &CmdlineDefines, SourceMgr &SM) {\r
- assert(GlobalVariableTable.empty() && GlobalNumericVariableTable.empty() &&\r
- "Overriding defined variable with command-line variable definitions");\r
-\r
- if (CmdlineDefines.empty())\r
- return Error::success();\r
-\r
- // Create a string representing the vector of command-line definitions. Each\r
- // definition is on its own line and prefixed with a definition number to\r
- // clarify which definition a given diagnostic corresponds to.\r
- unsigned I = 0;\r
- Error Errs = Error::success();\r
- std::string CmdlineDefsDiag;\r
- SmallVector<std::pair<size_t, size_t>, 4> CmdlineDefsIndices;\r
- for (StringRef CmdlineDef : CmdlineDefines) {\r
- std::string DefPrefix = ("Global define #" + Twine(++I) + ": ").str();\r
- size_t EqIdx = CmdlineDef.find('=');\r
- if (EqIdx == StringRef::npos) {\r
- CmdlineDefsIndices.push_back(std::make_pair(CmdlineDefsDiag.size(), 0));\r
- continue;\r
- }\r
- // Numeric variable definition.\r
- if (CmdlineDef[0] == '#') {\r
- // Append a copy of the command-line definition adapted to use the same\r
- // format as in the input file to be able to reuse\r
- // parseNumericSubstitutionBlock.\r
- CmdlineDefsDiag += (DefPrefix + CmdlineDef + " (parsed as: [[").str();\r
- std::string SubstitutionStr = CmdlineDef;\r
- SubstitutionStr[EqIdx] = ':';\r
- CmdlineDefsIndices.push_back(\r
- std::make_pair(CmdlineDefsDiag.size(), SubstitutionStr.size()));\r
- CmdlineDefsDiag += (SubstitutionStr + Twine("]])\n")).str();\r
- } else {\r
- CmdlineDefsDiag += DefPrefix;\r
- CmdlineDefsIndices.push_back(\r
- std::make_pair(CmdlineDefsDiag.size(), CmdlineDef.size()));\r
- CmdlineDefsDiag += (CmdlineDef + "\n").str();\r
- }\r
- }\r
-\r
- // Create a buffer with fake command line content in order to display\r
- // parsing diagnostic with location information and point to the\r
- // global definition with invalid syntax.\r
- std::unique_ptr<MemoryBuffer> CmdLineDefsDiagBuffer =\r
- MemoryBuffer::getMemBufferCopy(CmdlineDefsDiag, "Global defines");\r
- StringRef CmdlineDefsDiagRef = CmdLineDefsDiagBuffer->getBuffer();\r
- SM.AddNewSourceBuffer(std::move(CmdLineDefsDiagBuffer), SMLoc());\r
-\r
- for (std::pair<size_t, size_t> CmdlineDefIndices : CmdlineDefsIndices) {\r
- StringRef CmdlineDef = CmdlineDefsDiagRef.substr(CmdlineDefIndices.first,\r
- CmdlineDefIndices.second);\r
- if (CmdlineDef.empty()) {\r
- Errs = joinErrors(\r
- std::move(Errs),\r
- FileCheckErrorDiagnostic::get(\r
- SM, CmdlineDef, "missing equal sign in global definition"));\r
- continue;\r
- }\r
-\r
- // Numeric variable definition.\r
- if (CmdlineDef[0] == '#') {\r
- // Now parse the definition both to check that the syntax is correct and\r
- // to create the necessary class instance.\r
- StringRef CmdlineDefExpr = CmdlineDef.substr(1);\r
- Optional<FileCheckNumericVariable *> DefinedNumericVariable;\r
- Expected<std::unique_ptr<FileCheckExpressionAST>> ExpressionASTResult =\r
- FileCheckPattern::parseNumericSubstitutionBlock(\r
- CmdlineDefExpr, DefinedNumericVariable, false, None, this, SM);\r
- if (!ExpressionASTResult) {\r
- Errs = joinErrors(std::move(Errs), ExpressionASTResult.takeError());\r
- continue;\r
- }\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST =\r
- std::move(*ExpressionASTResult);\r
- // Now evaluate the expression whose value this variable should be set\r
- // to, since the expression of a command-line variable definition should\r
- // only use variables defined earlier on the command-line. If not, this\r
- // is an error and we report it.\r
- Expected<uint64_t> Value = ExpressionAST->eval();\r
- if (!Value) {\r
- Errs = joinErrors(std::move(Errs), Value.takeError());\r
- continue;\r
- }\r
-\r
- assert(DefinedNumericVariable && "No variable defined");\r
- (*DefinedNumericVariable)->setValue(*Value);\r
-\r
- // Record this variable definition.\r
- GlobalNumericVariableTable[(*DefinedNumericVariable)->getName()] =\r
- *DefinedNumericVariable;\r
- } else {\r
- // String variable definition.\r
- std::pair<StringRef, StringRef> CmdlineNameVal = CmdlineDef.split('=');\r
- StringRef CmdlineName = CmdlineNameVal.first;\r
- StringRef OrigCmdlineName = CmdlineName;\r
- Expected<FileCheckPattern::VariableProperties> ParseVarResult =\r
- FileCheckPattern::parseVariable(CmdlineName, SM);\r
- if (!ParseVarResult) {\r
- Errs = joinErrors(std::move(Errs), ParseVarResult.takeError());\r
- continue;\r
- }\r
- // Check that CmdlineName does not denote a pseudo variable is only\r
- // composed of the parsed numeric variable. This catches cases like\r
- // "FOO+2" in a "FOO+2=10" definition.\r
- if (ParseVarResult->IsPseudo || !CmdlineName.empty()) {\r
- Errs = joinErrors(std::move(Errs),\r
- FileCheckErrorDiagnostic::get(\r
- SM, OrigCmdlineName,\r
- "invalid name in string variable definition '" +\r
- OrigCmdlineName + "'"));\r
- continue;\r
- }\r
- StringRef Name = ParseVarResult->Name;\r
-\r
- // Detect collisions between string and numeric variables when the former\r
- // is created later than the latter.\r
- if (GlobalNumericVariableTable.find(Name) !=\r
- GlobalNumericVariableTable.end()) {\r
- Errs = joinErrors(std::move(Errs), FileCheckErrorDiagnostic::get(\r
- SM, Name,\r
- "numeric variable with name '" +\r
- Name + "' already exists"));\r
- continue;\r
- }\r
- GlobalVariableTable.insert(CmdlineNameVal);\r
- // Mark the string variable as defined to detect collisions between\r
- // string and numeric variables in defineCmdlineVariables when the latter\r
- // is created later than the former. We cannot reuse GlobalVariableTable\r
- // for this by populating it with an empty string since we would then\r
- // lose the ability to detect the use of an undefined variable in\r
- // match().\r
- DefinedVariableTable[Name] = true;\r
- }\r
- }\r
-\r
- return Errs;\r
-}\r
-\r
-void FileCheckPatternContext::clearLocalVars() {\r
- SmallVector<StringRef, 16> LocalPatternVars, LocalNumericVars;\r
- for (const StringMapEntry<StringRef> &Var : GlobalVariableTable)\r
- if (Var.first()[0] != '$')\r
- LocalPatternVars.push_back(Var.first());\r
-\r
- // Numeric substitution reads the value of a variable directly, not via\r
- // GlobalNumericVariableTable. Therefore, we clear local variables by\r
- // clearing their value which will lead to a numeric substitution failure. We\r
- // also mark the variable for removal from GlobalNumericVariableTable since\r
- // this is what defineCmdlineVariables checks to decide that no global\r
- // variable has been defined.\r
- for (const auto &Var : GlobalNumericVariableTable)\r
- if (Var.first()[0] != '$') {\r
- Var.getValue()->clearValue();\r
- LocalNumericVars.push_back(Var.first());\r
- }\r
-\r
- for (const auto &Var : LocalPatternVars)\r
- GlobalVariableTable.erase(Var);\r
- for (const auto &Var : LocalNumericVars)\r
- GlobalNumericVariableTable.erase(Var);\r
-}\r
-\r
-bool FileCheck::checkInput(SourceMgr &SM, StringRef Buffer,\r
- std::vector<FileCheckDiag> *Diags) {\r
- bool ChecksFailed = false;\r
-\r
- unsigned i = 0, j = 0, e = CheckStrings->size();\r
- while (true) {\r
- StringRef CheckRegion;\r
- if (j == e) {\r
- CheckRegion = Buffer;\r
- } else {\r
- const FileCheckString &CheckLabelStr = (*CheckStrings)[j];\r
- if (CheckLabelStr.Pat.getCheckTy() != Check::CheckLabel) {\r
- ++j;\r
- continue;\r
- }\r
-\r
- // Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG\r
- size_t MatchLabelLen = 0;\r
- size_t MatchLabelPos =\r
- CheckLabelStr.Check(SM, Buffer, true, MatchLabelLen, Req, Diags);\r
- if (MatchLabelPos == StringRef::npos)\r
- // Immediately bail if CHECK-LABEL fails, nothing else we can do.\r
- return false;\r
-\r
- CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen);\r
- Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen);\r
- ++j;\r
- }\r
-\r
- // Do not clear the first region as it's the one before the first\r
- // CHECK-LABEL and it would clear variables defined on the command-line\r
- // before they get used.\r
- if (i != 0 && Req.EnableVarScope)\r
- PatternContext->clearLocalVars();\r
-\r
- for (; i != j; ++i) {\r
- const FileCheckString &CheckStr = (*CheckStrings)[i];\r
-\r
- // Check each string within the scanned region, including a second check\r
- // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG)\r
- size_t MatchLen = 0;\r
- size_t MatchPos =\r
- CheckStr.Check(SM, CheckRegion, false, MatchLen, Req, Diags);\r
-\r
- if (MatchPos == StringRef::npos) {\r
- ChecksFailed = true;\r
- i = j;\r
- break;\r
- }\r
-\r
- CheckRegion = CheckRegion.substr(MatchPos + MatchLen);\r
- }\r
-\r
- if (j == e)\r
- break;\r
- }\r
-\r
- // Success if no checks failed.\r
- return !ChecksFailed;\r
-}\r
+//===- FileCheck.cpp - Check that File's Contents match what is expected --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// FileCheck does a line-by line check of a file that validates whether it
+// contains the expected content. This is useful for regression tests etc.
+//
+// This file implements most of the API that will be used by the FileCheck utility
+// as well as various unittests.
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/FileCheck.h"
+#include "FileCheckImpl.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/FormatVariadic.h"
+#include <cstdint>
+#include <list>
+#include <tuple>
+#include <utility>
+
+using namespace llvm;
+
+Expected<uint64_t> FileCheckNumericVariableUse::eval() const {
+ Optional<uint64_t> Value = NumericVariable->getValue();
+ if (Value)
+ return *Value;
+
+ return make_error<FileCheckUndefVarError>(Name);
+}
+
+Expected<uint64_t> FileCheckASTBinop::eval() const {
+ Expected<uint64_t> LeftOp = LeftOperand->eval();
+ Expected<uint64_t> RightOp = RightOperand->eval();
+
+ // Bubble up any error (e.g. undefined variables) in the recursive
+ // evaluation.
+ if (!LeftOp || !RightOp) {
+ Error Err = Error::success();
+ if (!LeftOp)
+ Err = joinErrors(std::move(Err), LeftOp.takeError());
+ if (!RightOp)
+ Err = joinErrors(std::move(Err), RightOp.takeError());
+ return std::move(Err);
+ }
+
+ return EvalBinop(*LeftOp, *RightOp);
+}
+
+Expected<std::string> FileCheckNumericSubstitution::getResult() const {
+ Expected<uint64_t> EvaluatedValue = ExpressionAST->eval();
+ if (!EvaluatedValue)
+ return EvaluatedValue.takeError();
+ return utostr(*EvaluatedValue);
+}
+
+Expected<std::string> FileCheckStringSubstitution::getResult() const {
+ // Look up the value and escape it so that we can put it into the regex.
+ Expected<StringRef> VarVal = Context->getPatternVarValue(FromStr);
+ if (!VarVal)
+ return VarVal.takeError();
+ return Regex::escape(*VarVal);
+}
+
+bool FileCheckPattern::isValidVarNameStart(char C) {
+ return C == '_' || isalpha(C);
+}
+
+Expected<FileCheckPattern::VariableProperties>
+FileCheckPattern::parseVariable(StringRef &Str, const SourceMgr &SM) {
+ if (Str.empty())
+ return FileCheckErrorDiagnostic::get(SM, Str, "empty variable name");
+
+ bool ParsedOneChar = false;
+ unsigned I = 0;
+ bool IsPseudo = Str[0] == '@';
+
+ // Global vars start with '$'.
+ if (Str[0] == '$' || IsPseudo)
+ ++I;
+
+ for (unsigned E = Str.size(); I != E; ++I) {
+ if (!ParsedOneChar && !isValidVarNameStart(Str[I]))
+ return FileCheckErrorDiagnostic::get(SM, Str, "invalid variable name");
+
+ // Variable names are composed of alphanumeric characters and underscores.
+ if (Str[I] != '_' && !isalnum(Str[I]))
+ break;
+ ParsedOneChar = true;
+ }
+
+ StringRef Name = Str.take_front(I);
+ Str = Str.substr(I);
+ return VariableProperties {Name, IsPseudo};
+}
+
+// StringRef holding all characters considered as horizontal whitespaces by
+// FileCheck input canonicalization.
+constexpr StringLiteral SpaceChars = " \t";
+
+// Parsing helper function that strips the first character in S and returns it.
+static char popFront(StringRef &S) {
+ char C = S.front();
+ S = S.drop_front();
+ return C;
+}
+
+char FileCheckUndefVarError::ID = 0;
+char FileCheckErrorDiagnostic::ID = 0;
+char FileCheckNotFoundError::ID = 0;
+
+Expected<FileCheckNumericVariable *>
+FileCheckPattern::parseNumericVariableDefinition(
+ StringRef &Expr, FileCheckPatternContext *Context,
+ Optional<size_t> LineNumber, const SourceMgr &SM) {
+ Expected<VariableProperties> ParseVarResult = parseVariable(Expr, SM);
+ if (!ParseVarResult)
+ return ParseVarResult.takeError();
+ StringRef Name = ParseVarResult->Name;
+
+ if (ParseVarResult->IsPseudo)
+ return FileCheckErrorDiagnostic::get(
+ SM, Name, "definition of pseudo numeric variable unsupported");
+
+ // Detect collisions between string and numeric variables when the latter
+ // is created later than the former.
+ if (Context->DefinedVariableTable.find(Name) !=
+ Context->DefinedVariableTable.end())
+ return FileCheckErrorDiagnostic::get(
+ SM, Name, "string variable with name '" + Name + "' already exists");
+
+ Expr = Expr.ltrim(SpaceChars);
+ if (!Expr.empty())
+ return FileCheckErrorDiagnostic::get(
+ SM, Expr, "unexpected characters after numeric variable name");
+
+ FileCheckNumericVariable *DefinedNumericVariable;
+ auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
+ if (VarTableIter != Context->GlobalNumericVariableTable.end())
+ DefinedNumericVariable = VarTableIter->second;
+ else
+ DefinedNumericVariable = Context->makeNumericVariable(Name, LineNumber);
+
+ return DefinedNumericVariable;
+}
+
+Expected<std::unique_ptr<FileCheckNumericVariableUse>>
+FileCheckPattern::parseNumericVariableUse(StringRef Name, bool IsPseudo,
+ Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context,
+ const SourceMgr &SM) {
+ if (IsPseudo && !Name.equals("@LINE"))
+ return FileCheckErrorDiagnostic::get(
+ SM, Name, "invalid pseudo numeric variable '" + Name + "'");
+
+ // Numeric variable definitions and uses are parsed in the order in which
+ // they appear in the CHECK patterns. For each definition, the pointer to the
+ // class instance of the corresponding numeric variable definition is stored
+ // in GlobalNumericVariableTable in parsePattern. Therefore, if the pointer
+ // we get below is null, it means no such variable was defined before. When
+ // that happens, we create a dummy variable so that parsing can continue. All
+ // uses of undefined variables, whether string or numeric, are then diagnosed
+ // in printSubstitutions() after failing to match.
+ auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
+ FileCheckNumericVariable *NumericVariable;
+ if (VarTableIter != Context->GlobalNumericVariableTable.end())
+ NumericVariable = VarTableIter->second;
+ else {
+ NumericVariable = Context->makeNumericVariable(Name);
+ Context->GlobalNumericVariableTable[Name] = NumericVariable;
+ }
+
+ Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
+ if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
+ return FileCheckErrorDiagnostic::get(
+ SM, Name,
+ "numeric variable '" + Name +
+ "' defined earlier in the same CHECK directive");
+
+ return std::make_unique<FileCheckNumericVariableUse>(Name, NumericVariable);
+}
+
+Expected<std::unique_ptr<FileCheckExpressionAST>>
+FileCheckPattern::parseNumericOperand(StringRef &Expr, AllowedOperand AO,
+ Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context,
+ const SourceMgr &SM) {
+ if (AO == AllowedOperand::LineVar || AO == AllowedOperand::Any) {
+ // Try to parse as a numeric variable use.
+ Expected<FileCheckPattern::VariableProperties> ParseVarResult =
+ parseVariable(Expr, SM);
+ if (ParseVarResult)
+ return parseNumericVariableUse(ParseVarResult->Name,
+ ParseVarResult->IsPseudo, LineNumber,
+ Context, SM);
+ if (AO == AllowedOperand::LineVar)
+ return ParseVarResult.takeError();
+ // Ignore the error and retry parsing as a literal.
+ consumeError(ParseVarResult.takeError());
+ }
+
+ // Otherwise, parse it as a literal.
+ uint64_t LiteralValue;
+ if (!Expr.consumeInteger(/*Radix=*/10, LiteralValue))
+ return std::make_unique<FileCheckExpressionLiteral>(LiteralValue);
+
+ return FileCheckErrorDiagnostic::get(SM, Expr,
+ "invalid operand format '" + Expr + "'");
+}
+
+static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
+ return LeftOp + RightOp;
+}
+
+static uint64_t sub(uint64_t LeftOp, uint64_t RightOp) {
+ return LeftOp - RightOp;
+}
+
+Expected<std::unique_ptr<FileCheckExpressionAST>> FileCheckPattern::parseBinop(
+ StringRef &Expr, std::unique_ptr<FileCheckExpressionAST> LeftOp,
+ bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context, const SourceMgr &SM) {
+ Expr = Expr.ltrim(SpaceChars);
+ if (Expr.empty())
+ return std::move(LeftOp);
+
+ // Check if this is a supported operation and select a function to perform
+ // it.
+ SMLoc OpLoc = SMLoc::getFromPointer(Expr.data());
+ char Operator = popFront(Expr);
+ binop_eval_t EvalBinop;
+ switch (Operator) {
+ case '+':
+ EvalBinop = add;
+ break;
+ case '-':
+ EvalBinop = sub;
+ break;
+ default:
+ return FileCheckErrorDiagnostic::get(
+ SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");
+ }
+
+ // Parse right operand.
+ Expr = Expr.ltrim(SpaceChars);
+ if (Expr.empty())
+ return FileCheckErrorDiagnostic::get(SM, Expr,
+ "missing operand in expression");
+ // The second operand in a legacy @LINE expression is always a literal.
+ AllowedOperand AO =
+ IsLegacyLineExpr ? AllowedOperand::Literal : AllowedOperand::Any;
+ Expected<std::unique_ptr<FileCheckExpressionAST>> RightOpResult =
+ parseNumericOperand(Expr, AO, LineNumber, Context, SM);
+ if (!RightOpResult)
+ return RightOpResult;
+
+ Expr = Expr.ltrim(SpaceChars);
+ return std::make_unique<FileCheckASTBinop>(EvalBinop, std::move(LeftOp),
+ std::move(*RightOpResult));
+}
+
+Expected<std::unique_ptr<FileCheckExpressionAST>>
+FileCheckPattern::parseNumericSubstitutionBlock(
+ StringRef Expr,
+ Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
+ bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context, const SourceMgr &SM) {
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST = nullptr;
+ StringRef DefExpr = StringRef();
+ DefinedNumericVariable = None;
+ // Save variable definition expression if any.
+ size_t DefEnd = Expr.find(':');
+ if (DefEnd != StringRef::npos) {
+ DefExpr = Expr.substr(0, DefEnd);
+ Expr = Expr.substr(DefEnd + 1);
+ }
+
+ // Parse the expression itself.
+ Expr = Expr.ltrim(SpaceChars);
+ if (!Expr.empty()) {
+ // The first operand in a legacy @LINE expression is always the @LINE
+ // pseudo variable.
+ AllowedOperand AO =
+ IsLegacyLineExpr ? AllowedOperand::LineVar : AllowedOperand::Any;
+ Expected<std::unique_ptr<FileCheckExpressionAST>> ParseResult =
+ parseNumericOperand(Expr, AO, LineNumber, Context, SM);
+ while (ParseResult && !Expr.empty()) {
+ ParseResult = parseBinop(Expr, std::move(*ParseResult), IsLegacyLineExpr,
+ LineNumber, Context, SM);
+ // Legacy @LINE expressions only allow 2 operands.
+ if (ParseResult && IsLegacyLineExpr && !Expr.empty())
+ return FileCheckErrorDiagnostic::get(
+ SM, Expr,
+ "unexpected characters at end of expression '" + Expr + "'");
+ }
+ if (!ParseResult)
+ return ParseResult;
+ ExpressionAST = std::move(*ParseResult);
+ }
+
+ // Parse the numeric variable definition.
+ if (DefEnd != StringRef::npos) {
+ DefExpr = DefExpr.ltrim(SpaceChars);
+ Expected<FileCheckNumericVariable *> ParseResult =
+ parseNumericVariableDefinition(DefExpr, Context, LineNumber, SM);
+
+ if (!ParseResult)
+ return ParseResult.takeError();
+ DefinedNumericVariable = *ParseResult;
+ }
+
+ return std::move(ExpressionAST);
+}
+
+bool FileCheckPattern::parsePattern(StringRef PatternStr, StringRef Prefix,
+ SourceMgr &SM,
+ const FileCheckRequest &Req) {
+ bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
+
+ PatternLoc = SMLoc::getFromPointer(PatternStr.data());
+
+ if (!(Req.NoCanonicalizeWhiteSpace && Req.MatchFullLines))
+ // Ignore trailing whitespace.
+ while (!PatternStr.empty() &&
+ (PatternStr.back() == ' ' || PatternStr.back() == '\t'))
+ PatternStr = PatternStr.substr(0, PatternStr.size() - 1);
+
+ // Check that there is something on the line.
+ if (PatternStr.empty() && CheckTy != Check::CheckEmpty) {
+ SM.PrintMessage(PatternLoc, SourceMgr::DK_Error,
+ "found empty check string with prefix '" + Prefix + ":'");
+ return true;
+ }
+
+ if (!PatternStr.empty() && CheckTy == Check::CheckEmpty) {
+ SM.PrintMessage(
+ PatternLoc, SourceMgr::DK_Error,
+ "found non-empty check string for empty check with prefix '" + Prefix +
+ ":'");
+ return true;
+ }
+
+ if (CheckTy == Check::CheckEmpty) {
+ RegExStr = "(\n$)";
+ return false;
+ }
+
+ // Check to see if this is a fixed string, or if it has regex pieces.
+ if (!MatchFullLinesHere &&
+ (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos &&
+ PatternStr.find("[[") == StringRef::npos))) {
+ FixedStr = PatternStr;
+ return false;
+ }
+
+ if (MatchFullLinesHere) {
+ RegExStr += '^';
+ if (!Req.NoCanonicalizeWhiteSpace)
+ RegExStr += " *";
+ }
+
+ // Paren value #0 is for the fully matched string. Any new parenthesized
+ // values add from there.
+ unsigned CurParen = 1;
+
+ // Otherwise, there is at least one regex piece. Build up the regex pattern
+ // by escaping scary characters in fixed strings, building up one big regex.
+ while (!PatternStr.empty()) {
+ // RegEx matches.
+ if (PatternStr.startswith("{{")) {
+ // This is the start of a regex match. Scan for the }}.
+ size_t End = PatternStr.find("}}");
+ if (End == StringRef::npos) {
+ SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
+ SourceMgr::DK_Error,
+ "found start of regex string with no end '}}'");
+ return true;
+ }
+
+ // Enclose {{}} patterns in parens just like [[]] even though we're not
+ // capturing the result for any purpose. This is required in case the
+ // expression contains an alternation like: CHECK: abc{{x|z}}def. We
+ // want this to turn into: "abc(x|z)def" not "abcx|zdef".
+ RegExStr += '(';
+ ++CurParen;
+
+ if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM))
+ return true;
+ RegExStr += ')';
+
+ PatternStr = PatternStr.substr(End + 2);
+ continue;
+ }
+
+ // String and numeric substitution blocks. Pattern substitution blocks come
+ // in two forms: [[foo:.*]] and [[foo]]. The former matches .* (or some
+ // other regex) and assigns it to the string variable 'foo'. The latter
+ // substitutes foo's value. Numeric substitution blocks recognize the same
+ // form as string ones, but start with a '#' sign after the double
+ // brackets. They also accept a combined form which sets a numeric variable
+ // to the evaluation of an expression. Both string and numeric variable
+ // names must satisfy the regular expression "[a-zA-Z_][0-9a-zA-Z_]*" to be
+ // valid, as this helps catch some common errors.
+ if (PatternStr.startswith("[[")) {
+ StringRef UnparsedPatternStr = PatternStr.substr(2);
+ // Find the closing bracket pair ending the match. End is going to be an
+ // offset relative to the beginning of the match string.
+ size_t End = FindRegexVarEnd(UnparsedPatternStr, SM);
+ StringRef MatchStr = UnparsedPatternStr.substr(0, End);
+ bool IsNumBlock = MatchStr.consume_front("#");
+
+ if (End == StringRef::npos) {
+ SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
+ SourceMgr::DK_Error,
+ "Invalid substitution block, no ]] found");
+ return true;
+ }
+ // Strip the substitution block we are parsing. End points to the start
+ // of the "]]" closing the expression so account for it in computing the
+ // index of the first unparsed character.
+ PatternStr = UnparsedPatternStr.substr(End + 2);
+
+ bool IsDefinition = false;
+ bool SubstNeeded = false;
+ // Whether the substitution block is a legacy use of @LINE with string
+ // substitution block syntax.
+ bool IsLegacyLineExpr = false;
+ StringRef DefName;
+ StringRef SubstStr;
+ StringRef MatchRegexp;
+ size_t SubstInsertIdx = RegExStr.size();
+
+ // Parse string variable or legacy @LINE expression.
+ if (!IsNumBlock) {
+ size_t VarEndIdx = MatchStr.find(":");
+ size_t SpacePos = MatchStr.substr(0, VarEndIdx).find_first_of(" \t");
+ if (SpacePos != StringRef::npos) {
+ SM.PrintMessage(SMLoc::getFromPointer(MatchStr.data() + SpacePos),
+ SourceMgr::DK_Error, "unexpected whitespace");
+ return true;
+ }
+
+ // Get the name (e.g. "foo") and verify it is well formed.
+ StringRef OrigMatchStr = MatchStr;
+ Expected<FileCheckPattern::VariableProperties> ParseVarResult =
+ parseVariable(MatchStr, SM);
+ if (!ParseVarResult) {
+ logAllUnhandledErrors(ParseVarResult.takeError(), errs());
+ return true;
+ }
+ StringRef Name = ParseVarResult->Name;
+ bool IsPseudo = ParseVarResult->IsPseudo;
+
+ IsDefinition = (VarEndIdx != StringRef::npos);
+ SubstNeeded = !IsDefinition;
+ if (IsDefinition) {
+ if ((IsPseudo || !MatchStr.consume_front(":"))) {
+ SM.PrintMessage(SMLoc::getFromPointer(Name.data()),
+ SourceMgr::DK_Error,
+ "invalid name in string variable definition");
+ return true;
+ }
+
+ // Detect collisions between string and numeric variables when the
+ // former is created later than the latter.
+ if (Context->GlobalNumericVariableTable.find(Name) !=
+ Context->GlobalNumericVariableTable.end()) {
+ SM.PrintMessage(
+ SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
+ "numeric variable with name '" + Name + "' already exists");
+ return true;
+ }
+ DefName = Name;
+ MatchRegexp = MatchStr;
+ } else {
+ if (IsPseudo) {
+ MatchStr = OrigMatchStr;
+ IsLegacyLineExpr = IsNumBlock = true;
+ } else
+ SubstStr = Name;
+ }
+ }
+
+ // Parse numeric substitution block.
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST;
+ Optional<FileCheckNumericVariable *> DefinedNumericVariable;
+ if (IsNumBlock) {
+ Expected<std::unique_ptr<FileCheckExpressionAST>> ParseResult =
+ parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable,
+ IsLegacyLineExpr, LineNumber, Context,
+ SM);
+ if (!ParseResult) {
+ logAllUnhandledErrors(ParseResult.takeError(), errs());
+ return true;
+ }
+ ExpressionAST = std::move(*ParseResult);
+ SubstNeeded = ExpressionAST != nullptr;
+ if (DefinedNumericVariable) {
+ IsDefinition = true;
+ DefName = (*DefinedNumericVariable)->getName();
+ }
+ if (SubstNeeded)
+ SubstStr = MatchStr;
+ else
+ MatchRegexp = "[0-9]+";
+ }
+
+ // Handle variable definition: [[<def>:(...)]] and [[#(...)<def>:(...)]].
+ if (IsDefinition) {
+ RegExStr += '(';
+ ++SubstInsertIdx;
+
+ if (IsNumBlock) {
+ FileCheckNumericVariableMatch NumericVariableDefinition = {
+ *DefinedNumericVariable, CurParen};
+ NumericVariableDefs[DefName] = NumericVariableDefinition;
+ // This store is done here rather than in match() to allow
+ // parseNumericVariableUse() to get the pointer to the class instance
+ // of the right variable definition corresponding to a given numeric
+ // variable use.
+ Context->GlobalNumericVariableTable[DefName] =
+ *DefinedNumericVariable;
+ } else {
+ VariableDefs[DefName] = CurParen;
+ // Mark string variable as defined to detect collisions between
+ // string and numeric variables in parseNumericVariableUse() and
+ // defineCmdlineVariables() when the latter is created later than the
+ // former. We cannot reuse GlobalVariableTable for this by populating
+ // it with an empty string since we would then lose the ability to
+ // detect the use of an undefined variable in match().
+ Context->DefinedVariableTable[DefName] = true;
+ }
+
+ ++CurParen;
+ }
+
+ if (!MatchRegexp.empty() && AddRegExToRegEx(MatchRegexp, CurParen, SM))
+ return true;
+
+ if (IsDefinition)
+ RegExStr += ')';
+
+ // Handle substitutions: [[foo]] and [[#<foo expr>]].
+ if (SubstNeeded) {
+ // Handle substitution of string variables that were defined earlier on
+ // the same line by emitting a backreference. Expressions do not
+ // support substituting a numeric variable defined on the same line.
+ if (!IsNumBlock && VariableDefs.find(SubstStr) != VariableDefs.end()) {
+ unsigned CaptureParenGroup = VariableDefs[SubstStr];
+ if (CaptureParenGroup < 1 || CaptureParenGroup > 9) {
+ SM.PrintMessage(SMLoc::getFromPointer(SubstStr.data()),
+ SourceMgr::DK_Error,
+ "Can't back-reference more than 9 variables");
+ return true;
+ }
+ AddBackrefToRegEx(CaptureParenGroup);
+ } else {
+ // Handle substitution of string variables ([[<var>]]) defined in
+ // previous CHECK patterns, and substitution of expressions.
+ FileCheckSubstitution *Substitution =
+ IsNumBlock
+ ? Context->makeNumericSubstitution(
+ SubstStr, std::move(ExpressionAST), SubstInsertIdx)
+ : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);
+ Substitutions.push_back(Substitution);
+ }
+ }
+ }
+
+ // Handle fixed string matches.
+ // Find the end, which is the start of the next regex.
+ size_t FixedMatchEnd = PatternStr.find("{{");
+ FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[["));
+ RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd));
+ PatternStr = PatternStr.substr(FixedMatchEnd);
+ }
+
+ if (MatchFullLinesHere) {
+ if (!Req.NoCanonicalizeWhiteSpace)
+ RegExStr += " *";
+ RegExStr += '$';
+ }
+
+ return false;
+}
+
+bool FileCheckPattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM) {
+ Regex R(RS);
+ std::string Error;
+ if (!R.isValid(Error)) {
+ SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error,
+ "invalid regex: " + Error);
+ return true;
+ }
+
+ RegExStr += RS.str();
+ CurParen += R.getNumMatches();
+ return false;
+}
+
+void FileCheckPattern::AddBackrefToRegEx(unsigned BackrefNum) {
+ assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number");
+ std::string Backref = std::string("\\") + std::string(1, '0' + BackrefNum);
+ RegExStr += Backref;
+}
+
+Expected<size_t> FileCheckPattern::match(StringRef Buffer, size_t &MatchLen,
+ const SourceMgr &SM) const {
+ // If this is the EOF pattern, match it immediately.
+ if (CheckTy == Check::CheckEOF) {
+ MatchLen = 0;
+ return Buffer.size();
+ }
+
+ // If this is a fixed string pattern, just match it now.
+ if (!FixedStr.empty()) {
+ MatchLen = FixedStr.size();
+ size_t Pos = Buffer.find(FixedStr);
+ if (Pos == StringRef::npos)
+ return make_error<FileCheckNotFoundError>();
+ return Pos;
+ }
+
+ // Regex match.
+
+ // If there are substitutions, we need to create a temporary string with the
+ // actual value.
+ StringRef RegExToMatch = RegExStr;
+ std::string TmpStr;
+ if (!Substitutions.empty()) {
+ TmpStr = RegExStr;
+ if (LineNumber)
+ Context->LineVariable->setValue(*LineNumber);
+
+ size_t InsertOffset = 0;
+ // Substitute all string variables and expressions whose values are only
+ // now known. Use of string variables defined on the same line are handled
+ // by back-references.
+ for (const auto &Substitution : Substitutions) {
+ // Substitute and check for failure (e.g. use of undefined variable).
+ Expected<std::string> Value = Substitution->getResult();
+ if (!Value)
+ return Value.takeError();
+
+ // Plop it into the regex at the adjusted offset.
+ TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,
+ Value->begin(), Value->end());
+ InsertOffset += Value->size();
+ }
+
+ // Match the newly constructed regex.
+ RegExToMatch = TmpStr;
+ }
+
+ SmallVector<StringRef, 4> MatchInfo;
+ if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))
+ return make_error<FileCheckNotFoundError>();
+
+ // Successful regex match.
+ assert(!MatchInfo.empty() && "Didn't get any match");
+ StringRef FullMatch = MatchInfo[0];
+
+ // If this defines any string variables, remember their values.
+ for (const auto &VariableDef : VariableDefs) {
+ assert(VariableDef.second < MatchInfo.size() && "Internal paren error");
+ Context->GlobalVariableTable[VariableDef.first] =
+ MatchInfo[VariableDef.second];
+ }
+
+ // If this defines any numeric variables, remember their values.
+ for (const auto &NumericVariableDef : NumericVariableDefs) {
+ const FileCheckNumericVariableMatch &NumericVariableMatch =
+ NumericVariableDef.getValue();
+ unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
+ assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
+ FileCheckNumericVariable *DefinedNumericVariable =
+ NumericVariableMatch.DefinedNumericVariable;
+
+ StringRef MatchedValue = MatchInfo[CaptureParenGroup];
+ uint64_t Val;
+ if (MatchedValue.getAsInteger(10, Val))
+ return FileCheckErrorDiagnostic::get(SM, MatchedValue,
+ "Unable to represent numeric value");
+ DefinedNumericVariable->setValue(Val);
+ }
+
+ // Like CHECK-NEXT, CHECK-EMPTY's match range is considered to start after
+ // the required preceding newline, which is consumed by the pattern in the
+ // case of CHECK-EMPTY but not CHECK-NEXT.
+ size_t MatchStartSkip = CheckTy == Check::CheckEmpty;
+ MatchLen = FullMatch.size() - MatchStartSkip;
+ return FullMatch.data() - Buffer.data() + MatchStartSkip;
+}
+
+unsigned FileCheckPattern::computeMatchDistance(StringRef Buffer) const {
+ // Just compute the number of matching characters. For regular expressions, we
+ // just compare against the regex itself and hope for the best.
+ //
+ // FIXME: One easy improvement here is have the regex lib generate a single
+ // example regular expression which matches, and use that as the example
+ // string.
+ StringRef ExampleString(FixedStr);
+ if (ExampleString.empty())
+ ExampleString = RegExStr;
+
+ // Only compare up to the first line in the buffer, or the string size.
+ StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());
+ BufferPrefix = BufferPrefix.split('\n').first;
+ return BufferPrefix.edit_distance(ExampleString);
+}
+
+void FileCheckPattern::printSubstitutions(const SourceMgr &SM, StringRef Buffer,
+ SMRange MatchRange) const {
+ // Print what we know about substitutions.
+ if (!Substitutions.empty()) {
+ for (const auto &Substitution : Substitutions) {
+ SmallString<256> Msg;
+ raw_svector_ostream OS(Msg);
+ Expected<std::string> MatchedValue = Substitution->getResult();
+
+ // Substitution failed or is not known at match time, print the undefined
+ // variables it uses.
+ if (!MatchedValue) {
+ bool UndefSeen = false;
+ handleAllErrors(MatchedValue.takeError(),
+ [](const FileCheckNotFoundError &E) {},
+ // Handled in PrintNoMatch().
+ [](const FileCheckErrorDiagnostic &E) {},
+ [&](const FileCheckUndefVarError &E) {
+ if (!UndefSeen) {
+ OS << "uses undefined variable(s):";
+ UndefSeen = true;
+ }
+ OS << " ";
+ E.log(OS);
+ });
+ } else {
+ // Substitution succeeded. Print substituted value.
+ OS << "with \"";
+ OS.write_escaped(Substitution->getFromString()) << "\" equal to \"";
+ OS.write_escaped(*MatchedValue) << "\"";
+ }
+
+ if (MatchRange.isValid())
+ SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, OS.str(),
+ {MatchRange});
+ else
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
+ SourceMgr::DK_Note, OS.str());
+ }
+ }
+}
+
+static SMRange ProcessMatchResult(FileCheckDiag::MatchType MatchTy,
+ const SourceMgr &SM, SMLoc Loc,
+ Check::FileCheckType CheckTy,
+ StringRef Buffer, size_t Pos, size_t Len,
+ std::vector<FileCheckDiag> *Diags,
+ bool AdjustPrevDiag = false) {
+ SMLoc Start = SMLoc::getFromPointer(Buffer.data() + Pos);
+ SMLoc End = SMLoc::getFromPointer(Buffer.data() + Pos + Len);
+ SMRange Range(Start, End);
+ if (Diags) {
+ if (AdjustPrevDiag)
+ Diags->rbegin()->MatchTy = MatchTy;
+ else
+ Diags->emplace_back(SM, CheckTy, Loc, MatchTy, Range);
+ }
+ return Range;
+}
+
+void FileCheckPattern::printFuzzyMatch(
+ const SourceMgr &SM, StringRef Buffer,
+ std::vector<FileCheckDiag> *Diags) const {
+ // Attempt to find the closest/best fuzzy match. Usually an error happens
+ // because some string in the output didn't exactly match. In these cases, we
+ // would like to show the user a best guess at what "should have" matched, to
+ // save them having to actually check the input manually.
+ size_t NumLinesForward = 0;
+ size_t Best = StringRef::npos;
+ double BestQuality = 0;
+
+ // Use an arbitrary 4k limit on how far we will search.
+ for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) {
+ if (Buffer[i] == '\n')
+ ++NumLinesForward;
+
+ // Patterns have leading whitespace stripped, so skip whitespace when
+ // looking for something which looks like a pattern.
+ if (Buffer[i] == ' ' || Buffer[i] == '\t')
+ continue;
+
+ // Compute the "quality" of this match as an arbitrary combination of the
+ // match distance and the number of lines skipped to get to this match.
+ unsigned Distance = computeMatchDistance(Buffer.substr(i));
+ double Quality = Distance + (NumLinesForward / 100.);
+
+ if (Quality < BestQuality || Best == StringRef::npos) {
+ Best = i;
+ BestQuality = Quality;
+ }
+ }
+
+ // Print the "possible intended match here" line if we found something
+ // reasonable and not equal to what we showed in the "scanning from here"
+ // line.
+ if (Best && Best != StringRef::npos && BestQuality < 50) {
+ SMRange MatchRange =
+ ProcessMatchResult(FileCheckDiag::MatchFuzzy, SM, getLoc(),
+ getCheckTy(), Buffer, Best, 0, Diags);
+ SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note,
+ "possible intended match here");
+
+ // FIXME: If we wanted to be really friendly we would show why the match
+ // failed, as it can be hard to spot simple one character differences.
+ }
+}
+
+Expected<StringRef>
+FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
+ auto VarIter = GlobalVariableTable.find(VarName);
+ if (VarIter == GlobalVariableTable.end())
+ return make_error<FileCheckUndefVarError>(VarName);
+
+ return VarIter->second;
+}
+
+template <class... Types>
+FileCheckNumericVariable *
+FileCheckPatternContext::makeNumericVariable(Types... args) {
+ NumericVariables.push_back(
+ std::make_unique<FileCheckNumericVariable>(args...));
+ return NumericVariables.back().get();
+}
+
+FileCheckSubstitution *
+FileCheckPatternContext::makeStringSubstitution(StringRef VarName,
+ size_t InsertIdx) {
+ Substitutions.push_back(
+ std::make_unique<FileCheckStringSubstitution>(this, VarName, InsertIdx));
+ return Substitutions.back().get();
+}
+
+FileCheckSubstitution *FileCheckPatternContext::makeNumericSubstitution(
+ StringRef ExpressionStr,
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST, size_t InsertIdx) {
+ Substitutions.push_back(std::make_unique<FileCheckNumericSubstitution>(
+ this, ExpressionStr, std::move(ExpressionAST), InsertIdx));
+ return Substitutions.back().get();
+}
+
+size_t FileCheckPattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {
+ // Offset keeps track of the current offset within the input Str
+ size_t Offset = 0;
+ // [...] Nesting depth
+ size_t BracketDepth = 0;
+
+ while (!Str.empty()) {
+ if (Str.startswith("]]") && BracketDepth == 0)
+ return Offset;
+ if (Str[0] == '\\') {
+ // Backslash escapes the next char within regexes, so skip them both.
+ Str = Str.substr(2);
+ Offset += 2;
+ } else {
+ switch (Str[0]) {
+ default:
+ break;
+ case '[':
+ BracketDepth++;
+ break;
+ case ']':
+ if (BracketDepth == 0) {
+ SM.PrintMessage(SMLoc::getFromPointer(Str.data()),
+ SourceMgr::DK_Error,
+ "missing closing \"]\" for regex variable");
+ exit(1);
+ }
+ BracketDepth--;
+ break;
+ }
+ Str = Str.substr(1);
+ Offset++;
+ }
+ }
+
+ return StringRef::npos;
+}
+
+StringRef FileCheck::CanonicalizeFile(MemoryBuffer &MB,
+ SmallVectorImpl<char> &OutputBuffer) {
+ OutputBuffer.reserve(MB.getBufferSize());
+
+ for (const char *Ptr = MB.getBufferStart(), *End = MB.getBufferEnd();
+ Ptr != End; ++Ptr) {
+ // Eliminate trailing dosish \r.
+ if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') {
+ continue;
+ }
+
+ // If current char is not a horizontal whitespace or if horizontal
+ // whitespace canonicalization is disabled, dump it to output as is.
+ if (Req.NoCanonicalizeWhiteSpace || (*Ptr != ' ' && *Ptr != '\t')) {
+ OutputBuffer.push_back(*Ptr);
+ continue;
+ }
+
+ // Otherwise, add one space and advance over neighboring space.
+ OutputBuffer.push_back(' ');
+ while (Ptr + 1 != End && (Ptr[1] == ' ' || Ptr[1] == '\t'))
+ ++Ptr;
+ }
+
+ // Add a null byte and then return all but that byte.
+ OutputBuffer.push_back('\0');
+ return StringRef(OutputBuffer.data(), OutputBuffer.size() - 1);
+}
+
+FileCheckDiag::FileCheckDiag(const SourceMgr &SM,
+ const Check::FileCheckType &CheckTy,
+ SMLoc CheckLoc, MatchType MatchTy,
+ SMRange InputRange)
+ : CheckTy(CheckTy), MatchTy(MatchTy) {
+ auto Start = SM.getLineAndColumn(InputRange.Start);
+ auto End = SM.getLineAndColumn(InputRange.End);
+ InputStartLine = Start.first;
+ InputStartCol = Start.second;
+ InputEndLine = End.first;
+ InputEndCol = End.second;
+ Start = SM.getLineAndColumn(CheckLoc);
+ CheckLine = Start.first;
+ CheckCol = Start.second;
+}
+
+static bool IsPartOfWord(char c) {
+ return (isalnum(c) || c == '-' || c == '_');
+}
+
+Check::FileCheckType &Check::FileCheckType::setCount(int C) {
+ assert(Count > 0 && "zero and negative counts are not supported");
+ assert((C == 1 || Kind == CheckPlain) &&
+ "count supported only for plain CHECK directives");
+ Count = C;
+ return *this;
+}
+
+std::string Check::FileCheckType::getDescription(StringRef Prefix) const {
+ switch (Kind) {
+ case Check::CheckNone:
+ return "invalid";
+ case Check::CheckPlain:
+ if (Count > 1)
+ return Prefix.str() + "-COUNT";
+ return Prefix;
+ case Check::CheckNext:
+ return Prefix.str() + "-NEXT";
+ case Check::CheckSame:
+ return Prefix.str() + "-SAME";
+ case Check::CheckNot:
+ return Prefix.str() + "-NOT";
+ case Check::CheckDAG:
+ return Prefix.str() + "-DAG";
+ case Check::CheckLabel:
+ return Prefix.str() + "-LABEL";
+ case Check::CheckEmpty:
+ return Prefix.str() + "-EMPTY";
+ case Check::CheckEOF:
+ return "implicit EOF";
+ case Check::CheckBadNot:
+ return "bad NOT";
+ case Check::CheckBadCount:
+ return "bad COUNT";
+ }
+ llvm_unreachable("unknown FileCheckType");
+}
+
+static std::pair<Check::FileCheckType, StringRef>
+FindCheckType(StringRef Buffer, StringRef Prefix) {
+ if (Buffer.size() <= Prefix.size())
+ return {Check::CheckNone, StringRef()};
+
+ char NextChar = Buffer[Prefix.size()];
+
+ StringRef Rest = Buffer.drop_front(Prefix.size() + 1);
+ // Verify that the : is present after the prefix.
+ if (NextChar == ':')
+ return {Check::CheckPlain, Rest};
+
+ if (NextChar != '-')
+ return {Check::CheckNone, StringRef()};
+
+ if (Rest.consume_front("COUNT-")) {
+ int64_t Count;
+ if (Rest.consumeInteger(10, Count))
+ // Error happened in parsing integer.
+ return {Check::CheckBadCount, Rest};
+ if (Count <= 0 || Count > INT32_MAX)
+ return {Check::CheckBadCount, Rest};
+ if (!Rest.consume_front(":"))
+ return {Check::CheckBadCount, Rest};
+ return {Check::FileCheckType(Check::CheckPlain).setCount(Count), Rest};
+ }
+
+ if (Rest.consume_front("NEXT:"))
+ return {Check::CheckNext, Rest};
+
+ if (Rest.consume_front("SAME:"))
+ return {Check::CheckSame, Rest};
+
+ if (Rest.consume_front("NOT:"))
+ return {Check::CheckNot, Rest};
+
+ if (Rest.consume_front("DAG:"))
+ return {Check::CheckDAG, Rest};
+
+ if (Rest.consume_front("LABEL:"))
+ return {Check::CheckLabel, Rest};
+
+ if (Rest.consume_front("EMPTY:"))
+ return {Check::CheckEmpty, Rest};
+
+ // You can't combine -NOT with another suffix.
+ if (Rest.startswith("DAG-NOT:") || Rest.startswith("NOT-DAG:") ||
+ Rest.startswith("NEXT-NOT:") || Rest.startswith("NOT-NEXT:") ||
+ Rest.startswith("SAME-NOT:") || Rest.startswith("NOT-SAME:") ||
+ Rest.startswith("EMPTY-NOT:") || Rest.startswith("NOT-EMPTY:"))
+ return {Check::CheckBadNot, Rest};
+
+ return {Check::CheckNone, Rest};
+}
+
+// From the given position, find the next character after the word.
+static size_t SkipWord(StringRef Str, size_t Loc) {
+ while (Loc < Str.size() && IsPartOfWord(Str[Loc]))
+ ++Loc;
+ return Loc;
+}
+
+/// Searches the buffer for the first prefix in the prefix regular expression.
+///
+/// This searches the buffer using the provided regular expression, however it
+/// enforces constraints beyond that:
+/// 1) The found prefix must not be a suffix of something that looks like
+/// a valid prefix.
+/// 2) The found prefix must be followed by a valid check type suffix using \c
+/// FindCheckType above.
+///
+/// \returns a pair of StringRefs into the Buffer, which combines:
+/// - the first match of the regular expression to satisfy these two is
+/// returned,
+/// otherwise an empty StringRef is returned to indicate failure.
+/// - buffer rewound to the location right after parsed suffix, for parsing
+/// to continue from
+///
+/// If this routine returns a valid prefix, it will also shrink \p Buffer to
+/// start at the beginning of the returned prefix, increment \p LineNumber for
+/// each new line consumed from \p Buffer, and set \p CheckTy to the type of
+/// check found by examining the suffix.
+///
+/// If no valid prefix is found, the state of Buffer, LineNumber, and CheckTy
+/// is unspecified.
+static std::pair<StringRef, StringRef>
+FindFirstMatchingPrefix(Regex &PrefixRE, StringRef &Buffer,
+ unsigned &LineNumber, Check::FileCheckType &CheckTy) {
+ SmallVector<StringRef, 2> Matches;
+
+ while (!Buffer.empty()) {
+ // Find the first (longest) match using the RE.
+ if (!PrefixRE.match(Buffer, &Matches))
+ // No match at all, bail.
+ return {StringRef(), StringRef()};
+
+ StringRef Prefix = Matches[0];
+ Matches.clear();
+
+ assert(Prefix.data() >= Buffer.data() &&
+ Prefix.data() < Buffer.data() + Buffer.size() &&
+ "Prefix doesn't start inside of buffer!");
+ size_t Loc = Prefix.data() - Buffer.data();
+ StringRef Skipped = Buffer.substr(0, Loc);
+ Buffer = Buffer.drop_front(Loc);
+ LineNumber += Skipped.count('\n');
+
+ // Check that the matched prefix isn't a suffix of some other check-like
+ // word.
+ // FIXME: This is a very ad-hoc check. it would be better handled in some
+ // other way. Among other things it seems hard to distinguish between
+ // intentional and unintentional uses of this feature.
+ if (Skipped.empty() || !IsPartOfWord(Skipped.back())) {
+ // Now extract the type.
+ StringRef AfterSuffix;
+ std::tie(CheckTy, AfterSuffix) = FindCheckType(Buffer, Prefix);
+
+ // If we've found a valid check type for this prefix, we're done.
+ if (CheckTy != Check::CheckNone)
+ return {Prefix, AfterSuffix};
+ }
+
+ // If we didn't successfully find a prefix, we need to skip this invalid
+ // prefix and continue scanning. We directly skip the prefix that was
+ // matched and any additional parts of that check-like word.
+ Buffer = Buffer.drop_front(SkipWord(Buffer, Prefix.size()));
+ }
+
+ // We ran out of buffer while skipping partial matches so give up.
+ return {StringRef(), StringRef()};
+}
+
+void FileCheckPatternContext::createLineVariable() {
+ assert(!LineVariable && "@LINE pseudo numeric variable already created");
+ StringRef LineName = "@LINE";
+ LineVariable = makeNumericVariable(LineName);
+ GlobalNumericVariableTable[LineName] = LineVariable;
+}
+
+FileCheck::FileCheck(FileCheckRequest Req)
+ : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),
+ CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}
+
+FileCheck::~FileCheck() = default;
+
+bool FileCheck::readCheckFile(SourceMgr &SM, StringRef Buffer,
+ Regex &PrefixRE) {
+ Error DefineError =
+ PatternContext->defineCmdlineVariables(Req.GlobalDefines, SM);
+ if (DefineError) {
+ logAllUnhandledErrors(std::move(DefineError), errs());
+ return true;
+ }
+
+ PatternContext->createLineVariable();
+
+ std::vector<FileCheckPattern> ImplicitNegativeChecks;
+ for (const auto &PatternString : Req.ImplicitCheckNot) {
+ // Create a buffer with fake command line content in order to display the
+ // command line option responsible for the specific implicit CHECK-NOT.
+ std::string Prefix = "-implicit-check-not='";
+ std::string Suffix = "'";
+ std::unique_ptr<MemoryBuffer> CmdLine = MemoryBuffer::getMemBufferCopy(
+ Prefix + PatternString + Suffix, "command line");
+
+ StringRef PatternInBuffer =
+ CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());
+ SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());
+
+ ImplicitNegativeChecks.push_back(
+ FileCheckPattern(Check::CheckNot, PatternContext.get()));
+ ImplicitNegativeChecks.back().parsePattern(PatternInBuffer,
+ "IMPLICIT-CHECK", SM, Req);
+ }
+
+ std::vector<FileCheckPattern> DagNotMatches = ImplicitNegativeChecks;
+
+ // LineNumber keeps track of the line on which CheckPrefix instances are
+ // found.
+ unsigned LineNumber = 1;
+
+ while (1) {
+ Check::FileCheckType CheckTy;
+
+ // See if a prefix occurs in the memory buffer.
+ StringRef UsedPrefix;
+ StringRef AfterSuffix;
+ std::tie(UsedPrefix, AfterSuffix) =
+ FindFirstMatchingPrefix(PrefixRE, Buffer, LineNumber, CheckTy);
+ if (UsedPrefix.empty())
+ break;
+ assert(UsedPrefix.data() == Buffer.data() &&
+ "Failed to move Buffer's start forward, or pointed prefix outside "
+ "of the buffer!");
+ assert(AfterSuffix.data() >= Buffer.data() &&
+ AfterSuffix.data() < Buffer.data() + Buffer.size() &&
+ "Parsing after suffix doesn't start inside of buffer!");
+
+ // Location to use for error messages.
+ const char *UsedPrefixStart = UsedPrefix.data();
+
+ // Skip the buffer to the end of parsed suffix (or just prefix, if no good
+ // suffix was processed).
+ Buffer = AfterSuffix.empty() ? Buffer.drop_front(UsedPrefix.size())
+ : AfterSuffix;
+
+ // Complain about useful-looking but unsupported suffixes.
+ if (CheckTy == Check::CheckBadNot) {
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,
+ "unsupported -NOT combo on prefix '" + UsedPrefix + "'");
+ return true;
+ }
+
+ // Complain about invalid count specification.
+ if (CheckTy == Check::CheckBadCount) {
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,
+ "invalid count in -COUNT specification on prefix '" +
+ UsedPrefix + "'");
+ return true;
+ }
+
+ // Okay, we found the prefix, yay. Remember the rest of the line, but ignore
+ // leading whitespace.
+ if (!(Req.NoCanonicalizeWhiteSpace && Req.MatchFullLines))
+ Buffer = Buffer.substr(Buffer.find_first_not_of(" \t"));
+
+ // Scan ahead to the end of line.
+ size_t EOL = Buffer.find_first_of("\n\r");
+
+ // Remember the location of the start of the pattern, for diagnostics.
+ SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());
+
+ // Parse the pattern.
+ FileCheckPattern P(CheckTy, PatternContext.get(), LineNumber);
+ if (P.parsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, Req))
+ return true;
+
+ // Verify that CHECK-LABEL lines do not define or use variables
+ if ((CheckTy == Check::CheckLabel) && P.hasVariable()) {
+ SM.PrintMessage(
+ SMLoc::getFromPointer(UsedPrefixStart), SourceMgr::DK_Error,
+ "found '" + UsedPrefix + "-LABEL:'"
+ " with variable definition or use");
+ return true;
+ }
+
+ Buffer = Buffer.substr(EOL);
+
+ // Verify that CHECK-NEXT/SAME/EMPTY lines have at least one CHECK line before them.
+ if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame ||
+ CheckTy == Check::CheckEmpty) &&
+ CheckStrings->empty()) {
+ StringRef Type = CheckTy == Check::CheckNext
+ ? "NEXT"
+ : CheckTy == Check::CheckEmpty ? "EMPTY" : "SAME";
+ SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
+ SourceMgr::DK_Error,
+ "found '" + UsedPrefix + "-" + Type +
+ "' without previous '" + UsedPrefix + ": line");
+ return true;
+ }
+
+ // Handle CHECK-DAG/-NOT.
+ if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) {
+ DagNotMatches.push_back(P);
+ continue;
+ }
+
+ // Okay, add the string we captured to the output vector and move on.
+ CheckStrings->emplace_back(P, UsedPrefix, PatternLoc);
+ std::swap(DagNotMatches, CheckStrings->back().DagNotStrings);
+ DagNotMatches = ImplicitNegativeChecks;
+ }
+
+ // Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first
+ // prefix as a filler for the error message.
+ if (!DagNotMatches.empty()) {
+ CheckStrings->emplace_back(
+ FileCheckPattern(Check::CheckEOF, PatternContext.get(), LineNumber + 1),
+ *Req.CheckPrefixes.begin(), SMLoc::getFromPointer(Buffer.data()));
+ std::swap(DagNotMatches, CheckStrings->back().DagNotStrings);
+ }
+
+ if (CheckStrings->empty()) {
+ errs() << "error: no check strings found with prefix"
+ << (Req.CheckPrefixes.size() > 1 ? "es " : " ");
+ auto I = Req.CheckPrefixes.begin();
+ auto E = Req.CheckPrefixes.end();
+ if (I != E) {
+ errs() << "\'" << *I << ":'";
+ ++I;
+ }
+ for (; I != E; ++I)
+ errs() << ", \'" << *I << ":'";
+
+ errs() << '\n';
+ return true;
+ }
+
+ return false;
+}
+
+static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,
+ StringRef Prefix, SMLoc Loc, const FileCheckPattern &Pat,
+ int MatchedCount, StringRef Buffer, size_t MatchPos,
+ size_t MatchLen, const FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) {
+ bool PrintDiag = true;
+ if (ExpectedMatch) {
+ if (!Req.Verbose)
+ return;
+ if (!Req.VerboseVerbose && Pat.getCheckTy() == Check::CheckEOF)
+ return;
+ // Due to their verbosity, we don't print verbose diagnostics here if we're
+ // gathering them for a different rendering, but we always print other
+ // diagnostics.
+ PrintDiag = !Diags;
+ }
+ SMRange MatchRange = ProcessMatchResult(
+ ExpectedMatch ? FileCheckDiag::MatchFoundAndExpected
+ : FileCheckDiag::MatchFoundButExcluded,
+ SM, Loc, Pat.getCheckTy(), Buffer, MatchPos, MatchLen, Diags);
+ if (!PrintDiag)
+ return;
+
+ std::string Message = formatv("{0}: {1} string found in input",
+ Pat.getCheckTy().getDescription(Prefix),
+ (ExpectedMatch ? "expected" : "excluded"))
+ .str();
+ if (Pat.getCount() > 1)
+ Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();
+
+ SM.PrintMessage(
+ Loc, ExpectedMatch ? SourceMgr::DK_Remark : SourceMgr::DK_Error, Message);
+ SM.PrintMessage(MatchRange.Start, SourceMgr::DK_Note, "found here",
+ {MatchRange});
+ Pat.printSubstitutions(SM, Buffer, MatchRange);
+}
+
+static void PrintMatch(bool ExpectedMatch, const SourceMgr &SM,
+ const FileCheckString &CheckStr, int MatchedCount,
+ StringRef Buffer, size_t MatchPos, size_t MatchLen,
+ FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) {
+ PrintMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,
+ MatchedCount, Buffer, MatchPos, MatchLen, Req, Diags);
+}
+
+static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,
+ StringRef Prefix, SMLoc Loc,
+ const FileCheckPattern &Pat, int MatchedCount,
+ StringRef Buffer, bool VerboseVerbose,
+ std::vector<FileCheckDiag> *Diags, Error MatchErrors) {
+ assert(MatchErrors && "Called on successful match");
+ bool PrintDiag = true;
+ if (!ExpectedMatch) {
+ if (!VerboseVerbose) {
+ consumeError(std::move(MatchErrors));
+ return;
+ }
+ // Due to their verbosity, we don't print verbose diagnostics here if we're
+ // gathering them for a different rendering, but we always print other
+ // diagnostics.
+ PrintDiag = !Diags;
+ }
+
+ // If the current position is at the end of a line, advance to the start of
+ // the next line.
+ Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r"));
+ SMRange SearchRange = ProcessMatchResult(
+ ExpectedMatch ? FileCheckDiag::MatchNoneButExpected
+ : FileCheckDiag::MatchNoneAndExcluded,
+ SM, Loc, Pat.getCheckTy(), Buffer, 0, Buffer.size(), Diags);
+ if (!PrintDiag) {
+ consumeError(std::move(MatchErrors));
+ return;
+ }
+
+ MatchErrors =
+ handleErrors(std::move(MatchErrors),
+ [](const FileCheckErrorDiagnostic &E) { E.log(errs()); });
+
+ // No problem matching the string per se.
+ if (!MatchErrors)
+ return;
+ consumeError(std::move(MatchErrors));
+
+ // Print "not found" diagnostic.
+ std::string Message = formatv("{0}: {1} string not found in input",
+ Pat.getCheckTy().getDescription(Prefix),
+ (ExpectedMatch ? "expected" : "excluded"))
+ .str();
+ if (Pat.getCount() > 1)
+ Message += formatv(" ({0} out of {1})", MatchedCount, Pat.getCount()).str();
+ SM.PrintMessage(
+ Loc, ExpectedMatch ? SourceMgr::DK_Error : SourceMgr::DK_Remark, Message);
+
+ // Print the "scanning from here" line.
+ SM.PrintMessage(SearchRange.Start, SourceMgr::DK_Note, "scanning from here");
+
+ // Allow the pattern to print additional information if desired.
+ Pat.printSubstitutions(SM, Buffer);
+
+ if (ExpectedMatch)
+ Pat.printFuzzyMatch(SM, Buffer, Diags);
+}
+
+static void PrintNoMatch(bool ExpectedMatch, const SourceMgr &SM,
+ const FileCheckString &CheckStr, int MatchedCount,
+ StringRef Buffer, bool VerboseVerbose,
+ std::vector<FileCheckDiag> *Diags, Error MatchErrors) {
+ PrintNoMatch(ExpectedMatch, SM, CheckStr.Prefix, CheckStr.Loc, CheckStr.Pat,
+ MatchedCount, Buffer, VerboseVerbose, Diags,
+ std::move(MatchErrors));
+}
+
+/// Counts the number of newlines in the specified range.
+static unsigned CountNumNewlinesBetween(StringRef Range,
+ const char *&FirstNewLine) {
+ unsigned NumNewLines = 0;
+ while (1) {
+ // Scan for newline.
+ Range = Range.substr(Range.find_first_of("\n\r"));
+ if (Range.empty())
+ return NumNewLines;
+
+ ++NumNewLines;
+
+ // Handle \n\r and \r\n as a single newline.
+ if (Range.size() > 1 && (Range[1] == '\n' || Range[1] == '\r') &&
+ (Range[0] != Range[1]))
+ Range = Range.substr(1);
+ Range = Range.substr(1);
+
+ if (NumNewLines == 1)
+ FirstNewLine = Range.begin();
+ }
+}
+
+size_t FileCheckString::Check(const SourceMgr &SM, StringRef Buffer,
+ bool IsLabelScanMode, size_t &MatchLen,
+ FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) const {
+ size_t LastPos = 0;
+ std::vector<const FileCheckPattern *> NotStrings;
+
+ // IsLabelScanMode is true when we are scanning forward to find CHECK-LABEL
+ // bounds; we have not processed variable definitions within the bounded block
+ // yet so cannot handle any final CHECK-DAG yet; this is handled when going
+ // over the block again (including the last CHECK-LABEL) in normal mode.
+ if (!IsLabelScanMode) {
+ // Match "dag strings" (with mixed "not strings" if any).
+ LastPos = CheckDag(SM, Buffer, NotStrings, Req, Diags);
+ if (LastPos == StringRef::npos)
+ return StringRef::npos;
+ }
+
+ // Match itself from the last position after matching CHECK-DAG.
+ size_t LastMatchEnd = LastPos;
+ size_t FirstMatchPos = 0;
+ // Go match the pattern Count times. Majority of patterns only match with
+ // count 1 though.
+ assert(Pat.getCount() != 0 && "pattern count can not be zero");
+ for (int i = 1; i <= Pat.getCount(); i++) {
+ StringRef MatchBuffer = Buffer.substr(LastMatchEnd);
+ size_t CurrentMatchLen;
+ // get a match at current start point
+ Expected<size_t> MatchResult = Pat.match(MatchBuffer, CurrentMatchLen, SM);
+
+ // report
+ if (!MatchResult) {
+ PrintNoMatch(true, SM, *this, i, MatchBuffer, Req.VerboseVerbose, Diags,
+ MatchResult.takeError());
+ return StringRef::npos;
+ }
+ size_t MatchPos = *MatchResult;
+ PrintMatch(true, SM, *this, i, MatchBuffer, MatchPos, CurrentMatchLen, Req,
+ Diags);
+ if (i == 1)
+ FirstMatchPos = LastPos + MatchPos;
+
+ // move start point after the match
+ LastMatchEnd += MatchPos + CurrentMatchLen;
+ }
+ // Full match len counts from first match pos.
+ MatchLen = LastMatchEnd - FirstMatchPos;
+
+ // Similar to the above, in "label-scan mode" we can't yet handle CHECK-NEXT
+ // or CHECK-NOT
+ if (!IsLabelScanMode) {
+ size_t MatchPos = FirstMatchPos - LastPos;
+ StringRef MatchBuffer = Buffer.substr(LastPos);
+ StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos);
+
+ // If this check is a "CHECK-NEXT", verify that the previous match was on
+ // the previous line (i.e. that there is one newline between them).
+ if (CheckNext(SM, SkippedRegion)) {
+ ProcessMatchResult(FileCheckDiag::MatchFoundButWrongLine, SM, Loc,
+ Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,
+ Diags, Req.Verbose);
+ return StringRef::npos;
+ }
+
+ // If this check is a "CHECK-SAME", verify that the previous match was on
+ // the same line (i.e. that there is no newline between them).
+ if (CheckSame(SM, SkippedRegion)) {
+ ProcessMatchResult(FileCheckDiag::MatchFoundButWrongLine, SM, Loc,
+ Pat.getCheckTy(), MatchBuffer, MatchPos, MatchLen,
+ Diags, Req.Verbose);
+ return StringRef::npos;
+ }
+
+ // If this match had "not strings", verify that they don't exist in the
+ // skipped region.
+ if (CheckNot(SM, SkippedRegion, NotStrings, Req, Diags))
+ return StringRef::npos;
+ }
+
+ return FirstMatchPos;
+}
+
+bool FileCheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const {
+ if (Pat.getCheckTy() != Check::CheckNext &&
+ Pat.getCheckTy() != Check::CheckEmpty)
+ return false;
+
+ Twine CheckName =
+ Prefix +
+ Twine(Pat.getCheckTy() == Check::CheckEmpty ? "-EMPTY" : "-NEXT");
+
+ // Count the number of newlines between the previous match and this one.
+ const char *FirstNewLine = nullptr;
+ unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine);
+
+ if (NumNewLines == 0) {
+ SM.PrintMessage(Loc, SourceMgr::DK_Error,
+ CheckName + ": is on the same line as previous match");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
+ "'next' match was here");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
+ "previous match ended here");
+ return true;
+ }
+
+ if (NumNewLines != 1) {
+ SM.PrintMessage(Loc, SourceMgr::DK_Error,
+ CheckName +
+ ": is not on the line after the previous match");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
+ "'next' match was here");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
+ "previous match ended here");
+ SM.PrintMessage(SMLoc::getFromPointer(FirstNewLine), SourceMgr::DK_Note,
+ "non-matching line after previous match is here");
+ return true;
+ }
+
+ return false;
+}
+
+bool FileCheckString::CheckSame(const SourceMgr &SM, StringRef Buffer) const {
+ if (Pat.getCheckTy() != Check::CheckSame)
+ return false;
+
+ // Count the number of newlines between the previous match and this one.
+ const char *FirstNewLine = nullptr;
+ unsigned NumNewLines = CountNumNewlinesBetween(Buffer, FirstNewLine);
+
+ if (NumNewLines != 0) {
+ SM.PrintMessage(Loc, SourceMgr::DK_Error,
+ Prefix +
+ "-SAME: is not on the same line as the previous match");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.end()), SourceMgr::DK_Note,
+ "'next' match was here");
+ SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,
+ "previous match ended here");
+ return true;
+ }
+
+ return false;
+}
+
+bool FileCheckString::CheckNot(
+ const SourceMgr &SM, StringRef Buffer,
+ const std::vector<const FileCheckPattern *> &NotStrings,
+ const FileCheckRequest &Req, std::vector<FileCheckDiag> *Diags) const {
+ for (const FileCheckPattern *Pat : NotStrings) {
+ assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!");
+
+ size_t MatchLen = 0;
+ Expected<size_t> MatchResult = Pat->match(Buffer, MatchLen, SM);
+
+ if (!MatchResult) {
+ PrintNoMatch(false, SM, Prefix, Pat->getLoc(), *Pat, 1, Buffer,
+ Req.VerboseVerbose, Diags, MatchResult.takeError());
+ continue;
+ }
+ size_t Pos = *MatchResult;
+
+ PrintMatch(false, SM, Prefix, Pat->getLoc(), *Pat, 1, Buffer, Pos, MatchLen,
+ Req, Diags);
+
+ return true;
+ }
+
+ return false;
+}
+
+size_t
+FileCheckString::CheckDag(const SourceMgr &SM, StringRef Buffer,
+ std::vector<const FileCheckPattern *> &NotStrings,
+ const FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) const {
+ if (DagNotStrings.empty())
+ return 0;
+
+ // The start of the search range.
+ size_t StartPos = 0;
+
+ struct MatchRange {
+ size_t Pos;
+ size_t End;
+ };
+ // A sorted list of ranges for non-overlapping CHECK-DAG matches. Match
+ // ranges are erased from this list once they are no longer in the search
+ // range.
+ std::list<MatchRange> MatchRanges;
+
+ // We need PatItr and PatEnd later for detecting the end of a CHECK-DAG
+ // group, so we don't use a range-based for loop here.
+ for (auto PatItr = DagNotStrings.begin(), PatEnd = DagNotStrings.end();
+ PatItr != PatEnd; ++PatItr) {
+ const FileCheckPattern &Pat = *PatItr;
+ assert((Pat.getCheckTy() == Check::CheckDAG ||
+ Pat.getCheckTy() == Check::CheckNot) &&
+ "Invalid CHECK-DAG or CHECK-NOT!");
+
+ if (Pat.getCheckTy() == Check::CheckNot) {
+ NotStrings.push_back(&Pat);
+ continue;
+ }
+
+ assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!");
+
+ // CHECK-DAG always matches from the start.
+ size_t MatchLen = 0, MatchPos = StartPos;
+
+ // Search for a match that doesn't overlap a previous match in this
+ // CHECK-DAG group.
+ for (auto MI = MatchRanges.begin(), ME = MatchRanges.end(); true; ++MI) {
+ StringRef MatchBuffer = Buffer.substr(MatchPos);
+ Expected<size_t> MatchResult = Pat.match(MatchBuffer, MatchLen, SM);
+ // With a group of CHECK-DAGs, a single mismatching means the match on
+ // that group of CHECK-DAGs fails immediately.
+ if (!MatchResult) {
+ PrintNoMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, MatchBuffer,
+ Req.VerboseVerbose, Diags, MatchResult.takeError());
+ return StringRef::npos;
+ }
+ size_t MatchPosBuf = *MatchResult;
+ // Re-calc it as the offset relative to the start of the original string.
+ MatchPos += MatchPosBuf;
+ if (Req.VerboseVerbose)
+ PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, Buffer, MatchPos,
+ MatchLen, Req, Diags);
+ MatchRange M{MatchPos, MatchPos + MatchLen};
+ if (Req.AllowDeprecatedDagOverlap) {
+ // We don't need to track all matches in this mode, so we just maintain
+ // one match range that encompasses the current CHECK-DAG group's
+ // matches.
+ if (MatchRanges.empty())
+ MatchRanges.insert(MatchRanges.end(), M);
+ else {
+ auto Block = MatchRanges.begin();
+ Block->Pos = std::min(Block->Pos, M.Pos);
+ Block->End = std::max(Block->End, M.End);
+ }
+ break;
+ }
+ // Iterate previous matches until overlapping match or insertion point.
+ bool Overlap = false;
+ for (; MI != ME; ++MI) {
+ if (M.Pos < MI->End) {
+ // !Overlap => New match has no overlap and is before this old match.
+ // Overlap => New match overlaps this old match.
+ Overlap = MI->Pos < M.End;
+ break;
+ }
+ }
+ if (!Overlap) {
+ // Insert non-overlapping match into list.
+ MatchRanges.insert(MI, M);
+ break;
+ }
+ if (Req.VerboseVerbose) {
+ // Due to their verbosity, we don't print verbose diagnostics here if
+ // we're gathering them for a different rendering, but we always print
+ // other diagnostics.
+ if (!Diags) {
+ SMLoc OldStart = SMLoc::getFromPointer(Buffer.data() + MI->Pos);
+ SMLoc OldEnd = SMLoc::getFromPointer(Buffer.data() + MI->End);
+ SMRange OldRange(OldStart, OldEnd);
+ SM.PrintMessage(OldStart, SourceMgr::DK_Note,
+ "match discarded, overlaps earlier DAG match here",
+ {OldRange});
+ } else
+ Diags->rbegin()->MatchTy = FileCheckDiag::MatchFoundButDiscarded;
+ }
+ MatchPos = MI->End;
+ }
+ if (!Req.VerboseVerbose)
+ PrintMatch(true, SM, Prefix, Pat.getLoc(), Pat, 1, Buffer, MatchPos,
+ MatchLen, Req, Diags);
+
+ // Handle the end of a CHECK-DAG group.
+ if (std::next(PatItr) == PatEnd ||
+ std::next(PatItr)->getCheckTy() == Check::CheckNot) {
+ if (!NotStrings.empty()) {
+ // If there are CHECK-NOTs between two CHECK-DAGs or from CHECK to
+ // CHECK-DAG, verify that there are no 'not' strings occurred in that
+ // region.
+ StringRef SkippedRegion =
+ Buffer.slice(StartPos, MatchRanges.begin()->Pos);
+ if (CheckNot(SM, SkippedRegion, NotStrings, Req, Diags))
+ return StringRef::npos;
+ // Clear "not strings".
+ NotStrings.clear();
+ }
+ // All subsequent CHECK-DAGs and CHECK-NOTs should be matched from the
+ // end of this CHECK-DAG group's match range.
+ StartPos = MatchRanges.rbegin()->End;
+ // Don't waste time checking for (impossible) overlaps before that.
+ MatchRanges.clear();
+ }
+ }
+
+ return StartPos;
+}
+
+// A check prefix must contain only alphanumeric, hyphens and underscores.
+static bool ValidateCheckPrefix(StringRef CheckPrefix) {
+ static const Regex Validator("^[a-zA-Z0-9_-]*$");
+ return Validator.match(CheckPrefix);
+}
+
+bool FileCheck::ValidateCheckPrefixes() {
+ StringSet<> PrefixSet;
+
+ for (StringRef Prefix : Req.CheckPrefixes) {
+ // Reject empty prefixes.
+ if (Prefix == "")
+ return false;
+
+ if (!PrefixSet.insert(Prefix).second)
+ return false;
+
+ if (!ValidateCheckPrefix(Prefix))
+ return false;
+ }
+
+ return true;
+}
+
+Regex FileCheck::buildCheckPrefixRegex() {
+ // I don't think there's a way to specify an initial value for cl::list,
+ // so if nothing was specified, add the default
+ if (Req.CheckPrefixes.empty())
+ Req.CheckPrefixes.push_back("CHECK");
+
+ // We already validated the contents of CheckPrefixes so just concatenate
+ // them as alternatives.
+ SmallString<32> PrefixRegexStr;
+ for (StringRef Prefix : Req.CheckPrefixes) {
+ if (Prefix != Req.CheckPrefixes.front())
+ PrefixRegexStr.push_back('|');
+
+ PrefixRegexStr.append(Prefix);
+ }
+
+ return Regex(PrefixRegexStr);
+}
+
+Error FileCheckPatternContext::defineCmdlineVariables(
+ std::vector<std::string> &CmdlineDefines, SourceMgr &SM) {
+ assert(GlobalVariableTable.empty() && GlobalNumericVariableTable.empty() &&
+ "Overriding defined variable with command-line variable definitions");
+
+ if (CmdlineDefines.empty())
+ return Error::success();
+
+ // Create a string representing the vector of command-line definitions. Each
+ // definition is on its own line and prefixed with a definition number to
+ // clarify which definition a given diagnostic corresponds to.
+ unsigned I = 0;
+ Error Errs = Error::success();
+ std::string CmdlineDefsDiag;
+ SmallVector<std::pair<size_t, size_t>, 4> CmdlineDefsIndices;
+ for (StringRef CmdlineDef : CmdlineDefines) {
+ std::string DefPrefix = ("Global define #" + Twine(++I) + ": ").str();
+ size_t EqIdx = CmdlineDef.find('=');
+ if (EqIdx == StringRef::npos) {
+ CmdlineDefsIndices.push_back(std::make_pair(CmdlineDefsDiag.size(), 0));
+ continue;
+ }
+ // Numeric variable definition.
+ if (CmdlineDef[0] == '#') {
+ // Append a copy of the command-line definition adapted to use the same
+ // format as in the input file to be able to reuse
+ // parseNumericSubstitutionBlock.
+ CmdlineDefsDiag += (DefPrefix + CmdlineDef + " (parsed as: [[").str();
+ std::string SubstitutionStr = CmdlineDef;
+ SubstitutionStr[EqIdx] = ':';
+ CmdlineDefsIndices.push_back(
+ std::make_pair(CmdlineDefsDiag.size(), SubstitutionStr.size()));
+ CmdlineDefsDiag += (SubstitutionStr + Twine("]])\n")).str();
+ } else {
+ CmdlineDefsDiag += DefPrefix;
+ CmdlineDefsIndices.push_back(
+ std::make_pair(CmdlineDefsDiag.size(), CmdlineDef.size()));
+ CmdlineDefsDiag += (CmdlineDef + "\n").str();
+ }
+ }
+
+ // Create a buffer with fake command line content in order to display
+ // parsing diagnostic with location information and point to the
+ // global definition with invalid syntax.
+ std::unique_ptr<MemoryBuffer> CmdLineDefsDiagBuffer =
+ MemoryBuffer::getMemBufferCopy(CmdlineDefsDiag, "Global defines");
+ StringRef CmdlineDefsDiagRef = CmdLineDefsDiagBuffer->getBuffer();
+ SM.AddNewSourceBuffer(std::move(CmdLineDefsDiagBuffer), SMLoc());
+
+ for (std::pair<size_t, size_t> CmdlineDefIndices : CmdlineDefsIndices) {
+ StringRef CmdlineDef = CmdlineDefsDiagRef.substr(CmdlineDefIndices.first,
+ CmdlineDefIndices.second);
+ if (CmdlineDef.empty()) {
+ Errs = joinErrors(
+ std::move(Errs),
+ FileCheckErrorDiagnostic::get(
+ SM, CmdlineDef, "missing equal sign in global definition"));
+ continue;
+ }
+
+ // Numeric variable definition.
+ if (CmdlineDef[0] == '#') {
+ // Now parse the definition both to check that the syntax is correct and
+ // to create the necessary class instance.
+ StringRef CmdlineDefExpr = CmdlineDef.substr(1);
+ Optional<FileCheckNumericVariable *> DefinedNumericVariable;
+ Expected<std::unique_ptr<FileCheckExpressionAST>> ExpressionASTResult =
+ FileCheckPattern::parseNumericSubstitutionBlock(
+ CmdlineDefExpr, DefinedNumericVariable, false, None, this, SM);
+ if (!ExpressionASTResult) {
+ Errs = joinErrors(std::move(Errs), ExpressionASTResult.takeError());
+ continue;
+ }
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST =
+ std::move(*ExpressionASTResult);
+ // Now evaluate the expression whose value this variable should be set
+ // to, since the expression of a command-line variable definition should
+ // only use variables defined earlier on the command-line. If not, this
+ // is an error and we report it.
+ Expected<uint64_t> Value = ExpressionAST->eval();
+ if (!Value) {
+ Errs = joinErrors(std::move(Errs), Value.takeError());
+ continue;
+ }
+
+ assert(DefinedNumericVariable && "No variable defined");
+ (*DefinedNumericVariable)->setValue(*Value);
+
+ // Record this variable definition.
+ GlobalNumericVariableTable[(*DefinedNumericVariable)->getName()] =
+ *DefinedNumericVariable;
+ } else {
+ // String variable definition.
+ std::pair<StringRef, StringRef> CmdlineNameVal = CmdlineDef.split('=');
+ StringRef CmdlineName = CmdlineNameVal.first;
+ StringRef OrigCmdlineName = CmdlineName;
+ Expected<FileCheckPattern::VariableProperties> ParseVarResult =
+ FileCheckPattern::parseVariable(CmdlineName, SM);
+ if (!ParseVarResult) {
+ Errs = joinErrors(std::move(Errs), ParseVarResult.takeError());
+ continue;
+ }
+ // Check that CmdlineName does not denote a pseudo variable is only
+ // composed of the parsed numeric variable. This catches cases like
+ // "FOO+2" in a "FOO+2=10" definition.
+ if (ParseVarResult->IsPseudo || !CmdlineName.empty()) {
+ Errs = joinErrors(std::move(Errs),
+ FileCheckErrorDiagnostic::get(
+ SM, OrigCmdlineName,
+ "invalid name in string variable definition '" +
+ OrigCmdlineName + "'"));
+ continue;
+ }
+ StringRef Name = ParseVarResult->Name;
+
+ // Detect collisions between string and numeric variables when the former
+ // is created later than the latter.
+ if (GlobalNumericVariableTable.find(Name) !=
+ GlobalNumericVariableTable.end()) {
+ Errs = joinErrors(std::move(Errs), FileCheckErrorDiagnostic::get(
+ SM, Name,
+ "numeric variable with name '" +
+ Name + "' already exists"));
+ continue;
+ }
+ GlobalVariableTable.insert(CmdlineNameVal);
+ // Mark the string variable as defined to detect collisions between
+ // string and numeric variables in defineCmdlineVariables when the latter
+ // is created later than the former. We cannot reuse GlobalVariableTable
+ // for this by populating it with an empty string since we would then
+ // lose the ability to detect the use of an undefined variable in
+ // match().
+ DefinedVariableTable[Name] = true;
+ }
+ }
+
+ return Errs;
+}
+
+void FileCheckPatternContext::clearLocalVars() {
+ SmallVector<StringRef, 16> LocalPatternVars, LocalNumericVars;
+ for (const StringMapEntry<StringRef> &Var : GlobalVariableTable)
+ if (Var.first()[0] != '$')
+ LocalPatternVars.push_back(Var.first());
+
+ // Numeric substitution reads the value of a variable directly, not via
+ // GlobalNumericVariableTable. Therefore, we clear local variables by
+ // clearing their value which will lead to a numeric substitution failure. We
+ // also mark the variable for removal from GlobalNumericVariableTable since
+ // this is what defineCmdlineVariables checks to decide that no global
+ // variable has been defined.
+ for (const auto &Var : GlobalNumericVariableTable)
+ if (Var.first()[0] != '$') {
+ Var.getValue()->clearValue();
+ LocalNumericVars.push_back(Var.first());
+ }
+
+ for (const auto &Var : LocalPatternVars)
+ GlobalVariableTable.erase(Var);
+ for (const auto &Var : LocalNumericVars)
+ GlobalNumericVariableTable.erase(Var);
+}
+
+bool FileCheck::checkInput(SourceMgr &SM, StringRef Buffer,
+ std::vector<FileCheckDiag> *Diags) {
+ bool ChecksFailed = false;
+
+ unsigned i = 0, j = 0, e = CheckStrings->size();
+ while (true) {
+ StringRef CheckRegion;
+ if (j == e) {
+ CheckRegion = Buffer;
+ } else {
+ const FileCheckString &CheckLabelStr = (*CheckStrings)[j];
+ if (CheckLabelStr.Pat.getCheckTy() != Check::CheckLabel) {
+ ++j;
+ continue;
+ }
+
+ // Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG
+ size_t MatchLabelLen = 0;
+ size_t MatchLabelPos =
+ CheckLabelStr.Check(SM, Buffer, true, MatchLabelLen, Req, Diags);
+ if (MatchLabelPos == StringRef::npos)
+ // Immediately bail if CHECK-LABEL fails, nothing else we can do.
+ return false;
+
+ CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen);
+ Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen);
+ ++j;
+ }
+
+ // Do not clear the first region as it's the one before the first
+ // CHECK-LABEL and it would clear variables defined on the command-line
+ // before they get used.
+ if (i != 0 && Req.EnableVarScope)
+ PatternContext->clearLocalVars();
+
+ for (; i != j; ++i) {
+ const FileCheckString &CheckStr = (*CheckStrings)[i];
+
+ // Check each string within the scanned region, including a second check
+ // of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG)
+ size_t MatchLen = 0;
+ size_t MatchPos =
+ CheckStr.Check(SM, CheckRegion, false, MatchLen, Req, Diags);
+
+ if (MatchPos == StringRef::npos) {
+ ChecksFailed = true;
+ i = j;
+ break;
+ }
+
+ CheckRegion = CheckRegion.substr(MatchPos + MatchLen);
+ }
+
+ if (j == e)
+ break;
+ }
+
+ // Success if no checks failed.
+ return !ChecksFailed;
+}
-//===-- FileCheckImpl.h - Private FileCheck Interface ------------*- C++ -*-==//\r
-//\r
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.\r
-// See https://llvm.org/LICENSE.txt for license information.\r
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\r
-//\r
-//===----------------------------------------------------------------------===//\r
-//\r
-// This file defines the private interfaces of FileCheck. Its purpose is to\r
-// allow unit testing of FileCheck and to separate the interface from the\r
-// implementation. It is only meant to be used by FileCheck.\r
-//\r
-//===----------------------------------------------------------------------===//\r
-\r
-#ifndef LLVM_LIB_SUPPORT_FILECHECKIMPL_H\r
-#define LLVM_LIB_SUPPORT_FILECHECKIMPL_H\r
-\r
-#include "llvm/ADT/Optional.h"\r
-#include "llvm/ADT/StringMap.h"\r
-#include "llvm/ADT/StringRef.h"\r
-#include "llvm/Support/Error.h"\r
-#include "llvm/Support/SourceMgr.h"\r
-#include <map>\r
-#include <string>\r
-#include <vector>\r
-\r
-namespace llvm {\r
-\r
-//===----------------------------------------------------------------------===//\r
-// Numeric substitution handling code.\r
-//===----------------------------------------------------------------------===//\r
-\r
-/// Base class representing the AST of a given expression.\r
-class FileCheckExpressionAST {\r
-public:\r
- virtual ~FileCheckExpressionAST() = default;\r
-\r
- /// Evaluates and \returns the value of the expression represented by this\r
- /// AST or an error if evaluation fails.\r
- virtual Expected<uint64_t> eval() const = 0;\r
-};\r
-\r
-/// Class representing an unsigned literal in the AST of an expression.\r
-class FileCheckExpressionLiteral : public FileCheckExpressionAST {\r
-private:\r
- /// Actual value of the literal.\r
- uint64_t Value;\r
-\r
-public:\r
- /// Constructs a literal with the specified value.\r
- FileCheckExpressionLiteral(uint64_t Val) : Value(Val) {}\r
-\r
- /// \returns the literal's value.\r
- Expected<uint64_t> eval() const { return Value; }\r
-};\r
-\r
-/// Class to represent an undefined variable error, which quotes that\r
-/// variable's name when printed.\r
-class FileCheckUndefVarError : public ErrorInfo<FileCheckUndefVarError> {\r
-private:\r
- StringRef VarName;\r
-\r
-public:\r
- static char ID;\r
-\r
- FileCheckUndefVarError(StringRef VarName) : VarName(VarName) {}\r
-\r
- StringRef getVarName() const { return VarName; }\r
-\r
- std::error_code convertToErrorCode() const override {\r
- return inconvertibleErrorCode();\r
- }\r
-\r
- /// Print name of variable associated with this error.\r
- void log(raw_ostream &OS) const override {\r
- OS << "\"";\r
- OS.write_escaped(VarName) << "\"";\r
- }\r
-};\r
-\r
-/// Class representing a numeric variable and its associated current value.\r
-class FileCheckNumericVariable {\r
-private:\r
- /// Name of the numeric variable.\r
- StringRef Name;\r
-\r
- /// Value of numeric variable, if defined, or None otherwise.\r
- Optional<uint64_t> Value;\r
-\r
- /// Line number where this variable is defined, or None if defined before\r
- /// input is parsed. Used to determine whether a variable is defined on the\r
- /// same line as a given use.\r
- Optional<size_t> DefLineNumber;\r
-\r
-public:\r
- /// Constructor for a variable \p Name defined at line \p DefLineNumber or\r
- /// defined before input is parsed if \p DefLineNumber is None.\r
- explicit FileCheckNumericVariable(StringRef Name,\r
- Optional<size_t> DefLineNumber = None)\r
- : Name(Name), DefLineNumber(DefLineNumber) {}\r
-\r
- /// \returns name of this numeric variable.\r
- StringRef getName() const { return Name; }\r
-\r
- /// \returns this variable's value.\r
- Optional<uint64_t> getValue() const { return Value; }\r
-\r
- /// Sets value of this numeric variable to \p NewValue.\r
- void setValue(uint64_t NewValue) { Value = NewValue; }\r
-\r
- /// Clears value of this numeric variable, regardless of whether it is\r
- /// currently defined or not.\r
- void clearValue() { Value = None; }\r
-\r
- /// \returns the line number where this variable is defined, if any, or None\r
- /// if defined before input is parsed.\r
- Optional<size_t> getDefLineNumber() { return DefLineNumber; }\r
-};\r
-\r
-/// Class representing the use of a numeric variable in the AST of an\r
-/// expression.\r
-class FileCheckNumericVariableUse : public FileCheckExpressionAST {\r
-private:\r
- /// Name of the numeric variable.\r
- StringRef Name;\r
-\r
- /// Pointer to the class instance for the variable this use is about.\r
- FileCheckNumericVariable *NumericVariable;\r
-\r
-public:\r
- FileCheckNumericVariableUse(StringRef Name,\r
- FileCheckNumericVariable *NumericVariable)\r
- : Name(Name), NumericVariable(NumericVariable) {}\r
-\r
- /// \returns the value of the variable referenced by this instance.\r
- Expected<uint64_t> eval() const;\r
-};\r
-\r
-/// Type of functions evaluating a given binary operation.\r
-using binop_eval_t = uint64_t (*)(uint64_t, uint64_t);\r
-\r
-/// Class representing a single binary operation in the AST of an expression.\r
-class FileCheckASTBinop : public FileCheckExpressionAST {\r
-private:\r
- /// Left operand.\r
- std::unique_ptr<FileCheckExpressionAST> LeftOperand;\r
-\r
- /// Right operand.\r
- std::unique_ptr<FileCheckExpressionAST> RightOperand;\r
-\r
- /// Pointer to function that can evaluate this binary operation.\r
- binop_eval_t EvalBinop;\r
-\r
-public:\r
- FileCheckASTBinop(binop_eval_t EvalBinop,\r
- std::unique_ptr<FileCheckExpressionAST> LeftOp,\r
- std::unique_ptr<FileCheckExpressionAST> RightOp)\r
- : EvalBinop(EvalBinop) {\r
- LeftOperand = std::move(LeftOp);\r
- RightOperand = std::move(RightOp);\r
- }\r
-\r
- /// Evaluates the value of the binary operation represented by this AST,\r
- /// using EvalBinop on the result of recursively evaluating the operands.\r
- /// \returns the expression value or an error if an undefined numeric\r
- /// variable is used in one of the operands.\r
- Expected<uint64_t> eval() const;\r
-};\r
-\r
-class FileCheckPatternContext;\r
-\r
-/// Class representing a substitution to perform in the RegExStr string.\r
-class FileCheckSubstitution {\r
-protected:\r
- /// Pointer to a class instance holding, among other things, the table with\r
- /// the values of live string variables at the start of any given CHECK line.\r
- /// Used for substituting string variables with the text they were defined\r
- /// as. Expressions are linked to the numeric variables they use at\r
- /// parse time and directly access the value of the numeric variable to\r
- /// evaluate their value.\r
- FileCheckPatternContext *Context;\r
-\r
- /// The string that needs to be substituted for something else. For a\r
- /// string variable this is its name, otherwise this is the whole expression.\r
- StringRef FromStr;\r
-\r
- // Index in RegExStr of where to do the substitution.\r
- size_t InsertIdx;\r
-\r
-public:\r
- FileCheckSubstitution(FileCheckPatternContext *Context, StringRef VarName,\r
- size_t InsertIdx)\r
- : Context(Context), FromStr(VarName), InsertIdx(InsertIdx) {}\r
-\r
- virtual ~FileCheckSubstitution() = default;\r
-\r
- /// \returns the string to be substituted for something else.\r
- StringRef getFromString() const { return FromStr; }\r
-\r
- /// \returns the index where the substitution is to be performed in RegExStr.\r
- size_t getIndex() const { return InsertIdx; }\r
-\r
- /// \returns a string containing the result of the substitution represented\r
- /// by this class instance or an error if substitution failed.\r
- virtual Expected<std::string> getResult() const = 0;\r
-};\r
-\r
-class FileCheckStringSubstitution : public FileCheckSubstitution {\r
-public:\r
- FileCheckStringSubstitution(FileCheckPatternContext *Context,\r
- StringRef VarName, size_t InsertIdx)\r
- : FileCheckSubstitution(Context, VarName, InsertIdx) {}\r
-\r
- /// \returns the text that the string variable in this substitution matched\r
- /// when defined, or an error if the variable is undefined.\r
- Expected<std::string> getResult() const override;\r
-};\r
-\r
-class FileCheckNumericSubstitution : public FileCheckSubstitution {\r
-private:\r
- /// Pointer to the class representing the expression whose value is to be\r
- /// substituted.\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST;\r
-\r
-public:\r
- FileCheckNumericSubstitution(FileCheckPatternContext *Context, StringRef Expr,\r
- std::unique_ptr<FileCheckExpressionAST> ExprAST,\r
- size_t InsertIdx)\r
- : FileCheckSubstitution(Context, Expr, InsertIdx) {\r
- ExpressionAST = std::move(ExprAST);\r
- }\r
-\r
- /// \returns a string containing the result of evaluating the expression in\r
- /// this substitution, or an error if evaluation failed.\r
- Expected<std::string> getResult() const override;\r
-};\r
-\r
-//===----------------------------------------------------------------------===//\r
-// Pattern handling code.\r
-//===----------------------------------------------------------------------===//\r
-\r
-struct FileCheckDiag;\r
-\r
-/// Class holding the FileCheckPattern global state, shared by all patterns:\r
-/// tables holding values of variables and whether they are defined or not at\r
-/// any given time in the matching process.\r
-class FileCheckPatternContext {\r
- friend class FileCheckPattern;\r
-\r
-private:\r
- /// When matching a given pattern, this holds the value of all the string\r
- /// variables defined in previous patterns. In a pattern, only the last\r
- /// definition for a given variable is recorded in this table.\r
- /// Back-references are used for uses after any the other definition.\r
- StringMap<StringRef> GlobalVariableTable;\r
-\r
- /// Map of all string variables defined so far. Used at parse time to detect\r
- /// a name conflict between a numeric variable and a string variable when\r
- /// the former is defined on a later line than the latter.\r
- StringMap<bool> DefinedVariableTable;\r
-\r
- /// When matching a given pattern, this holds the pointers to the classes\r
- /// representing the numeric variables defined in previous patterns. When\r
- /// matching a pattern all definitions for that pattern are recorded in the\r
- /// NumericVariableDefs table in the FileCheckPattern instance of that\r
- /// pattern.\r
- StringMap<FileCheckNumericVariable *> GlobalNumericVariableTable;\r
-\r
- /// Pointer to the class instance representing the @LINE pseudo variable for\r
- /// easily updating its value.\r
- FileCheckNumericVariable *LineVariable = nullptr;\r
-\r
- /// Vector holding pointers to all parsed numeric variables. Used to\r
- /// automatically free them once they are guaranteed to no longer be used.\r
- std::vector<std::unique_ptr<FileCheckNumericVariable>> NumericVariables;\r
-\r
- /// Vector holding pointers to all substitutions. Used to automatically free\r
- /// them once they are guaranteed to no longer be used.\r
- std::vector<std::unique_ptr<FileCheckSubstitution>> Substitutions;\r
-\r
-public:\r
- /// \returns the value of string variable \p VarName or an error if no such\r
- /// variable has been defined.\r
- Expected<StringRef> getPatternVarValue(StringRef VarName);\r
-\r
- /// Defines string and numeric variables from definitions given on the\r
- /// command line, passed as a vector of [#]VAR=VAL strings in\r
- /// \p CmdlineDefines. \returns an error list containing diagnostics against\r
- /// \p SM for all definition parsing failures, if any, or Success otherwise.\r
- Error defineCmdlineVariables(std::vector<std::string> &CmdlineDefines,\r
- SourceMgr &SM);\r
-\r
- /// Create @LINE pseudo variable. Value is set when pattern are being\r
- /// matched.\r
- void createLineVariable();\r
-\r
- /// Undefines local variables (variables whose name does not start with a '$'\r
- /// sign), i.e. removes them from GlobalVariableTable and from\r
- /// GlobalNumericVariableTable and also clears the value of numeric\r
- /// variables.\r
- void clearLocalVars();\r
-\r
-private:\r
- /// Makes a new numeric variable and registers it for destruction when the\r
- /// context is destroyed.\r
- template <class... Types>\r
- FileCheckNumericVariable *makeNumericVariable(Types... args);\r
-\r
- /// Makes a new string substitution and registers it for destruction when the\r
- /// context is destroyed.\r
- FileCheckSubstitution *makeStringSubstitution(StringRef VarName,\r
- size_t InsertIdx);\r
-\r
- /// Makes a new numeric substitution and registers it for destruction when\r
- /// the context is destroyed.\r
- FileCheckSubstitution *\r
- makeNumericSubstitution(StringRef ExpressionStr,\r
- std::unique_ptr<FileCheckExpressionAST> ExpressionAST,\r
- size_t InsertIdx);\r
-};\r
-\r
-/// Class to represent an error holding a diagnostic with location information\r
-/// used when printing it.\r
-class FileCheckErrorDiagnostic : public ErrorInfo<FileCheckErrorDiagnostic> {\r
-private:\r
- SMDiagnostic Diagnostic;\r
-\r
-public:\r
- static char ID;\r
-\r
- FileCheckErrorDiagnostic(SMDiagnostic &&Diag) : Diagnostic(Diag) {}\r
-\r
- std::error_code convertToErrorCode() const override {\r
- return inconvertibleErrorCode();\r
- }\r
-\r
- /// Print diagnostic associated with this error when printing the error.\r
- void log(raw_ostream &OS) const override { Diagnostic.print(nullptr, OS); }\r
-\r
- static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg) {\r
- return make_error<FileCheckErrorDiagnostic>(\r
- SM.GetMessage(Loc, SourceMgr::DK_Error, ErrMsg));\r
- }\r
-\r
- static Error get(const SourceMgr &SM, StringRef Buffer, const Twine &ErrMsg) {\r
- return get(SM, SMLoc::getFromPointer(Buffer.data()), ErrMsg);\r
- }\r
-};\r
-\r
-class FileCheckNotFoundError : public ErrorInfo<FileCheckNotFoundError> {\r
-public:\r
- static char ID;\r
-\r
- std::error_code convertToErrorCode() const override {\r
- return inconvertibleErrorCode();\r
- }\r
-\r
- /// Print diagnostic associated with this error when printing the error.\r
- void log(raw_ostream &OS) const override {\r
- OS << "String not found in input";\r
- }\r
-};\r
-\r
-class FileCheckPattern {\r
- SMLoc PatternLoc;\r
-\r
- /// A fixed string to match as the pattern or empty if this pattern requires\r
- /// a regex match.\r
- StringRef FixedStr;\r
-\r
- /// A regex string to match as the pattern or empty if this pattern requires\r
- /// a fixed string to match.\r
- std::string RegExStr;\r
-\r
- /// Entries in this vector represent a substitution of a string variable or\r
- /// an expression in the RegExStr regex at match time. For example, in the\r
- /// case of a CHECK directive with the pattern "foo[[bar]]baz[[#N+1]]",\r
- /// RegExStr will contain "foobaz" and we'll get two entries in this vector\r
- /// that tells us to insert the value of string variable "bar" at offset 3\r
- /// and the value of expression "N+1" at offset 6.\r
- std::vector<FileCheckSubstitution *> Substitutions;\r
-\r
- /// Maps names of string variables defined in a pattern to the number of\r
- /// their parenthesis group in RegExStr capturing their last definition.\r
- ///\r
- /// E.g. for the pattern "foo[[bar:.*]]baz([[bar]][[QUUX]][[bar:.*]])",\r
- /// RegExStr will be "foo(.*)baz(\1<quux value>(.*))" where <quux value> is\r
- /// the value captured for QUUX on the earlier line where it was defined, and\r
- /// VariableDefs will map "bar" to the third parenthesis group which captures\r
- /// the second definition of "bar".\r
- ///\r
- /// Note: uses std::map rather than StringMap to be able to get the key when\r
- /// iterating over values.\r
- std::map<StringRef, unsigned> VariableDefs;\r
-\r
- /// Structure representing the definition of a numeric variable in a pattern.\r
- /// It holds the pointer to the class representing the numeric variable whose\r
- /// value is being defined and the number of the parenthesis group in\r
- /// RegExStr to capture that value.\r
- struct FileCheckNumericVariableMatch {\r
- /// Pointer to class representing the numeric variable whose value is being\r
- /// defined.\r
- FileCheckNumericVariable *DefinedNumericVariable;\r
-\r
- /// Number of the parenthesis group in RegExStr that captures the value of\r
- /// this numeric variable definition.\r
- unsigned CaptureParenGroup;\r
- };\r
-\r
- /// Holds the number of the parenthesis group in RegExStr and pointer to the\r
- /// corresponding FileCheckNumericVariable class instance of all numeric\r
- /// variable definitions. Used to set the matched value of all those\r
- /// variables.\r
- StringMap<FileCheckNumericVariableMatch> NumericVariableDefs;\r
-\r
- /// Pointer to a class instance holding the global state shared by all\r
- /// patterns:\r
- /// - separate tables with the values of live string and numeric variables\r
- /// respectively at the start of any given CHECK line;\r
- /// - table holding whether a string variable has been defined at any given\r
- /// point during the parsing phase.\r
- FileCheckPatternContext *Context;\r
-\r
- Check::FileCheckType CheckTy;\r
-\r
- /// Line number for this CHECK pattern or None if it is an implicit pattern.\r
- /// Used to determine whether a variable definition is made on an earlier\r
- /// line to the one with this CHECK.\r
- Optional<size_t> LineNumber;\r
-\r
- /// Ignore case while matching if set to true.\r
- bool IgnoreCase = false;\r
-\r
-public:\r
- FileCheckPattern(Check::FileCheckType Ty, FileCheckPatternContext *Context,\r
- Optional<size_t> Line = None)\r
- : Context(Context), CheckTy(Ty), LineNumber(Line) {}\r
-\r
- /// \returns the location in source code.\r
- SMLoc getLoc() const { return PatternLoc; }\r
-\r
- /// \returns the pointer to the global state for all patterns in this\r
- /// FileCheck instance.\r
- FileCheckPatternContext *getContext() const { return Context; }\r
-\r
- /// \returns whether \p C is a valid first character for a variable name.\r
- static bool isValidVarNameStart(char C);\r
-\r
- /// Parsing information about a variable.\r
- struct VariableProperties {\r
- StringRef Name;\r
- bool IsPseudo;\r
- };\r
-\r
- /// Parses the string at the start of \p Str for a variable name. \returns\r
- /// a VariableProperties structure holding the variable name and whether it\r
- /// is the name of a pseudo variable, or an error holding a diagnostic\r
- /// against \p SM if parsing fail. If parsing was successful, also strips\r
- /// \p Str from the variable name.\r
- static Expected<VariableProperties> parseVariable(StringRef &Str,\r
- const SourceMgr &SM);\r
- /// Parses \p Expr for a numeric substitution block at line \p LineNumber,\r
- /// or before input is parsed if \p LineNumber is None. Parameter\r
- /// \p IsLegacyLineExpr indicates whether \p Expr should be a legacy @LINE\r
- /// expression and \p Context points to the class instance holding the live\r
- /// string and numeric variables. \returns a pointer to the class instance\r
- /// representing the AST of the expression whose value must be substitued, or\r
- /// an error holding a diagnostic against \p SM if parsing fails. If\r
- /// substitution was successful, sets \p DefinedNumericVariable to point to\r
- /// the class representing the numeric variable defined in this numeric\r
- /// substitution block, or None if this block does not define any variable.\r
- static Expected<std::unique_ptr<FileCheckExpressionAST>>\r
- parseNumericSubstitutionBlock(\r
- StringRef Expr,\r
- Optional<FileCheckNumericVariable *> &DefinedNumericVariable,\r
- bool IsLegacyLineExpr, Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context, const SourceMgr &SM);\r
- /// Parses the pattern in \p PatternStr and initializes this FileCheckPattern\r
- /// instance accordingly.\r
- ///\r
- /// \p Prefix provides which prefix is being matched, \p Req describes the\r
- /// global options that influence the parsing such as whitespace\r
- /// canonicalization, \p SM provides the SourceMgr used for error reports.\r
- /// \returns true in case of an error, false otherwise.\r
- bool parsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM,\r
- const FileCheckRequest &Req);\r
- /// Matches the pattern string against the input buffer \p Buffer\r
- ///\r
- /// \returns the position that is matched or an error indicating why matching\r
- /// failed. If there is a match, updates \p MatchLen with the size of the\r
- /// matched string.\r
- ///\r
- /// The GlobalVariableTable StringMap in the FileCheckPatternContext class\r
- /// instance provides the current values of FileCheck string variables and\r
- /// is updated if this match defines new values. Likewise, the\r
- /// GlobalNumericVariableTable StringMap in the same class provides the\r
- /// current values of FileCheck numeric variables and is updated if this\r
- /// match defines new numeric values.\r
- Expected<size_t> match(StringRef Buffer, size_t &MatchLen,\r
- const SourceMgr &SM) const;\r
- /// Prints the value of successful substitutions or the name of the undefined\r
- /// string or numeric variables preventing a successful substitution.\r
- void printSubstitutions(const SourceMgr &SM, StringRef Buffer,\r
- SMRange MatchRange = None) const;\r
- void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,\r
- std::vector<FileCheckDiag> *Diags) const;\r
-\r
- bool hasVariable() const {\r
- return !(Substitutions.empty() && VariableDefs.empty());\r
- }\r
-\r
- Check::FileCheckType getCheckTy() const { return CheckTy; }\r
-\r
- int getCount() const { return CheckTy.getCount(); }\r
-\r
-private:\r
- bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);\r
- void AddBackrefToRegEx(unsigned BackrefNum);\r
- /// Computes an arbitrary estimate for the quality of matching this pattern\r
- /// at the start of \p Buffer; a distance of zero should correspond to a\r
- /// perfect match.\r
- unsigned computeMatchDistance(StringRef Buffer) const;\r
- /// Finds the closing sequence of a regex variable usage or definition.\r
- ///\r
- /// \p Str has to point in the beginning of the definition (right after the\r
- /// opening sequence). \p SM holds the SourceMgr used for error repporting.\r
- /// \returns the offset of the closing sequence within Str, or npos if it\r
- /// was not found.\r
- size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);\r
-\r
- /// Parses \p Expr for the name of a numeric variable to be defined at line\r
- /// \p LineNumber, or before input is parsed if \p LineNumber is None.\r
- /// \returns a pointer to the class instance representing that variable,\r
- /// creating it if needed, or an error holding a diagnostic against \p SM\r
- /// should defining such a variable be invalid.\r
- static Expected<FileCheckNumericVariable *> parseNumericVariableDefinition(\r
- StringRef &Expr, FileCheckPatternContext *Context,\r
- Optional<size_t> LineNumber, const SourceMgr &SM);\r
- /// Parses \p Name as a (pseudo if \p IsPseudo is true) numeric variable use\r
- /// at line \p LineNumber, or before input is parsed if \p LineNumber is\r
- /// None. Parameter \p Context points to the class instance holding the live\r
- /// string and numeric variables. \returns the pointer to the class instance\r
- /// representing that variable if successful, or an error holding a\r
- /// diagnostic against \p SM otherwise.\r
- static Expected<std::unique_ptr<FileCheckNumericVariableUse>>\r
- parseNumericVariableUse(StringRef Name, bool IsPseudo,\r
- Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context,\r
- const SourceMgr &SM);\r
- enum class AllowedOperand { LineVar, Literal, Any };\r
- /// Parses \p Expr for use of a numeric operand at line \p LineNumber, or\r
- /// before input is parsed if \p LineNumber is None. Accepts both literal\r
- /// values and numeric variables, depending on the value of \p AO. Parameter\r
- /// \p Context points to the class instance holding the live string and\r
- /// numeric variables. \returns the class representing that operand in the\r
- /// AST of the expression or an error holding a diagnostic against \p SM\r
- /// otherwise.\r
- static Expected<std::unique_ptr<FileCheckExpressionAST>>\r
- parseNumericOperand(StringRef &Expr, AllowedOperand AO,\r
- Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context, const SourceMgr &SM);\r
- /// Parses \p Expr for a binary operation at line \p LineNumber, or before\r
- /// input is parsed if \p LineNumber is None. The left operand of this binary\r
- /// operation is given in \p LeftOp and \p IsLegacyLineExpr indicates whether\r
- /// we are parsing a legacy @LINE expression. Parameter \p Context points to\r
- /// the class instance holding the live string and numeric variables.\r
- /// \returns the class representing the binary operation in the AST of the\r
- /// expression, or an error holding a diagnostic against \p SM otherwise.\r
- static Expected<std::unique_ptr<FileCheckExpressionAST>>\r
- parseBinop(StringRef &Expr, std::unique_ptr<FileCheckExpressionAST> LeftOp,\r
- bool IsLegacyLineExpr, Optional<size_t> LineNumber,\r
- FileCheckPatternContext *Context, const SourceMgr &SM);\r
-};\r
-\r
-//===----------------------------------------------------------------------===//\r
-// Check Strings.\r
-//===----------------------------------------------------------------------===//\r
-\r
-/// A check that we found in the input file.\r
-struct FileCheckString {\r
- /// The pattern to match.\r
- FileCheckPattern Pat;\r
-\r
- /// Which prefix name this check matched.\r
- StringRef Prefix;\r
-\r
- /// The location in the match file that the check string was specified.\r
- SMLoc Loc;\r
-\r
- /// All of the strings that are disallowed from occurring between this match\r
- /// string and the previous one (or start of file).\r
- std::vector<FileCheckPattern> DagNotStrings;\r
-\r
- FileCheckString(const FileCheckPattern &P, StringRef S, SMLoc L)\r
- : Pat(P), Prefix(S), Loc(L) {}\r
-\r
- /// Matches check string and its "not strings" and/or "dag strings".\r
- size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode,\r
- size_t &MatchLen, FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) const;\r
-\r
- /// Verifies that there is a single line in the given \p Buffer. Errors are\r
- /// reported against \p SM.\r
- bool CheckNext(const SourceMgr &SM, StringRef Buffer) const;\r
- /// Verifies that there is no newline in the given \p Buffer. Errors are\r
- /// reported against \p SM.\r
- bool CheckSame(const SourceMgr &SM, StringRef Buffer) const;\r
- /// Verifies that none of the strings in \p NotStrings are found in the given\r
- /// \p Buffer. Errors are reported against \p SM and diagnostics recorded in\r
- /// \p Diags according to the verbosity level set in \p Req.\r
- bool CheckNot(const SourceMgr &SM, StringRef Buffer,\r
- const std::vector<const FileCheckPattern *> &NotStrings,\r
- const FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) const;\r
- /// Matches "dag strings" and their mixed "not strings".\r
- size_t CheckDag(const SourceMgr &SM, StringRef Buffer,\r
- std::vector<const FileCheckPattern *> &NotStrings,\r
- const FileCheckRequest &Req,\r
- std::vector<FileCheckDiag> *Diags) const;\r
-};\r
-\r
-} // namespace llvm\r
-\r
-#endif\r
+//===-- FileCheckImpl.h - Private FileCheck Interface ------------*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the private interfaces of FileCheck. Its purpose is to
+// allow unit testing of FileCheck and to separate the interface from the
+// implementation. It is only meant to be used by FileCheck.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_SUPPORT_FILECHECKIMPL_H
+#define LLVM_LIB_SUPPORT_FILECHECKIMPL_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/SourceMgr.h"
+#include <map>
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+// Numeric substitution handling code.
+//===----------------------------------------------------------------------===//
+
+/// Base class representing the AST of a given expression.
+class FileCheckExpressionAST {
+public:
+ virtual ~FileCheckExpressionAST() = default;
+
+ /// Evaluates and \returns the value of the expression represented by this
+ /// AST or an error if evaluation fails.
+ virtual Expected<uint64_t> eval() const = 0;
+};
+
+/// Class representing an unsigned literal in the AST of an expression.
+class FileCheckExpressionLiteral : public FileCheckExpressionAST {
+private:
+ /// Actual value of the literal.
+ uint64_t Value;
+
+public:
+ /// Constructs a literal with the specified value.
+ FileCheckExpressionLiteral(uint64_t Val) : Value(Val) {}
+
+ /// \returns the literal's value.
+ Expected<uint64_t> eval() const { return Value; }
+};
+
+/// Class to represent an undefined variable error, which quotes that
+/// variable's name when printed.
+class FileCheckUndefVarError : public ErrorInfo<FileCheckUndefVarError> {
+private:
+ StringRef VarName;
+
+public:
+ static char ID;
+
+ FileCheckUndefVarError(StringRef VarName) : VarName(VarName) {}
+
+ StringRef getVarName() const { return VarName; }
+
+ std::error_code convertToErrorCode() const override {
+ return inconvertibleErrorCode();
+ }
+
+ /// Print name of variable associated with this error.
+ void log(raw_ostream &OS) const override {
+ OS << "\"";
+ OS.write_escaped(VarName) << "\"";
+ }
+};
+
+/// Class representing a numeric variable and its associated current value.
+class FileCheckNumericVariable {
+private:
+ /// Name of the numeric variable.
+ StringRef Name;
+
+ /// Value of numeric variable, if defined, or None otherwise.
+ Optional<uint64_t> Value;
+
+ /// Line number where this variable is defined, or None if defined before
+ /// input is parsed. Used to determine whether a variable is defined on the
+ /// same line as a given use.
+ Optional<size_t> DefLineNumber;
+
+public:
+ /// Constructor for a variable \p Name defined at line \p DefLineNumber or
+ /// defined before input is parsed if \p DefLineNumber is None.
+ explicit FileCheckNumericVariable(StringRef Name,
+ Optional<size_t> DefLineNumber = None)
+ : Name(Name), DefLineNumber(DefLineNumber) {}
+
+ /// \returns name of this numeric variable.
+ StringRef getName() const { return Name; }
+
+ /// \returns this variable's value.
+ Optional<uint64_t> getValue() const { return Value; }
+
+ /// Sets value of this numeric variable to \p NewValue.
+ void setValue(uint64_t NewValue) { Value = NewValue; }
+
+ /// Clears value of this numeric variable, regardless of whether it is
+ /// currently defined or not.
+ void clearValue() { Value = None; }
+
+ /// \returns the line number where this variable is defined, if any, or None
+ /// if defined before input is parsed.
+ Optional<size_t> getDefLineNumber() { return DefLineNumber; }
+};
+
+/// Class representing the use of a numeric variable in the AST of an
+/// expression.
+class FileCheckNumericVariableUse : public FileCheckExpressionAST {
+private:
+ /// Name of the numeric variable.
+ StringRef Name;
+
+ /// Pointer to the class instance for the variable this use is about.
+ FileCheckNumericVariable *NumericVariable;
+
+public:
+ FileCheckNumericVariableUse(StringRef Name,
+ FileCheckNumericVariable *NumericVariable)
+ : Name(Name), NumericVariable(NumericVariable) {}
+
+ /// \returns the value of the variable referenced by this instance.
+ Expected<uint64_t> eval() const;
+};
+
+/// Type of functions evaluating a given binary operation.
+using binop_eval_t = uint64_t (*)(uint64_t, uint64_t);
+
+/// Class representing a single binary operation in the AST of an expression.
+class FileCheckASTBinop : public FileCheckExpressionAST {
+private:
+ /// Left operand.
+ std::unique_ptr<FileCheckExpressionAST> LeftOperand;
+
+ /// Right operand.
+ std::unique_ptr<FileCheckExpressionAST> RightOperand;
+
+ /// Pointer to function that can evaluate this binary operation.
+ binop_eval_t EvalBinop;
+
+public:
+ FileCheckASTBinop(binop_eval_t EvalBinop,
+ std::unique_ptr<FileCheckExpressionAST> LeftOp,
+ std::unique_ptr<FileCheckExpressionAST> RightOp)
+ : EvalBinop(EvalBinop) {
+ LeftOperand = std::move(LeftOp);
+ RightOperand = std::move(RightOp);
+ }
+
+ /// Evaluates the value of the binary operation represented by this AST,
+ /// using EvalBinop on the result of recursively evaluating the operands.
+ /// \returns the expression value or an error if an undefined numeric
+ /// variable is used in one of the operands.
+ Expected<uint64_t> eval() const;
+};
+
+class FileCheckPatternContext;
+
+/// Class representing a substitution to perform in the RegExStr string.
+class FileCheckSubstitution {
+protected:
+ /// Pointer to a class instance holding, among other things, the table with
+ /// the values of live string variables at the start of any given CHECK line.
+ /// Used for substituting string variables with the text they were defined
+ /// as. Expressions are linked to the numeric variables they use at
+ /// parse time and directly access the value of the numeric variable to
+ /// evaluate their value.
+ FileCheckPatternContext *Context;
+
+ /// The string that needs to be substituted for something else. For a
+ /// string variable this is its name, otherwise this is the whole expression.
+ StringRef FromStr;
+
+ // Index in RegExStr of where to do the substitution.
+ size_t InsertIdx;
+
+public:
+ FileCheckSubstitution(FileCheckPatternContext *Context, StringRef VarName,
+ size_t InsertIdx)
+ : Context(Context), FromStr(VarName), InsertIdx(InsertIdx) {}
+
+ virtual ~FileCheckSubstitution() = default;
+
+ /// \returns the string to be substituted for something else.
+ StringRef getFromString() const { return FromStr; }
+
+ /// \returns the index where the substitution is to be performed in RegExStr.
+ size_t getIndex() const { return InsertIdx; }
+
+ /// \returns a string containing the result of the substitution represented
+ /// by this class instance or an error if substitution failed.
+ virtual Expected<std::string> getResult() const = 0;
+};
+
+class FileCheckStringSubstitution : public FileCheckSubstitution {
+public:
+ FileCheckStringSubstitution(FileCheckPatternContext *Context,
+ StringRef VarName, size_t InsertIdx)
+ : FileCheckSubstitution(Context, VarName, InsertIdx) {}
+
+ /// \returns the text that the string variable in this substitution matched
+ /// when defined, or an error if the variable is undefined.
+ Expected<std::string> getResult() const override;
+};
+
+class FileCheckNumericSubstitution : public FileCheckSubstitution {
+private:
+ /// Pointer to the class representing the expression whose value is to be
+ /// substituted.
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST;
+
+public:
+ FileCheckNumericSubstitution(FileCheckPatternContext *Context, StringRef Expr,
+ std::unique_ptr<FileCheckExpressionAST> ExprAST,
+ size_t InsertIdx)
+ : FileCheckSubstitution(Context, Expr, InsertIdx) {
+ ExpressionAST = std::move(ExprAST);
+ }
+
+ /// \returns a string containing the result of evaluating the expression in
+ /// this substitution, or an error if evaluation failed.
+ Expected<std::string> getResult() const override;
+};
+
+//===----------------------------------------------------------------------===//
+// Pattern handling code.
+//===----------------------------------------------------------------------===//
+
+struct FileCheckDiag;
+
+/// Class holding the FileCheckPattern global state, shared by all patterns:
+/// tables holding values of variables and whether they are defined or not at
+/// any given time in the matching process.
+class FileCheckPatternContext {
+ friend class FileCheckPattern;
+
+private:
+ /// When matching a given pattern, this holds the value of all the string
+ /// variables defined in previous patterns. In a pattern, only the last
+ /// definition for a given variable is recorded in this table.
+ /// Back-references are used for uses after any the other definition.
+ StringMap<StringRef> GlobalVariableTable;
+
+ /// Map of all string variables defined so far. Used at parse time to detect
+ /// a name conflict between a numeric variable and a string variable when
+ /// the former is defined on a later line than the latter.
+ StringMap<bool> DefinedVariableTable;
+
+ /// When matching a given pattern, this holds the pointers to the classes
+ /// representing the numeric variables defined in previous patterns. When
+ /// matching a pattern all definitions for that pattern are recorded in the
+ /// NumericVariableDefs table in the FileCheckPattern instance of that
+ /// pattern.
+ StringMap<FileCheckNumericVariable *> GlobalNumericVariableTable;
+
+ /// Pointer to the class instance representing the @LINE pseudo variable for
+ /// easily updating its value.
+ FileCheckNumericVariable *LineVariable = nullptr;
+
+ /// Vector holding pointers to all parsed numeric variables. Used to
+ /// automatically free them once they are guaranteed to no longer be used.
+ std::vector<std::unique_ptr<FileCheckNumericVariable>> NumericVariables;
+
+ /// Vector holding pointers to all substitutions. Used to automatically free
+ /// them once they are guaranteed to no longer be used.
+ std::vector<std::unique_ptr<FileCheckSubstitution>> Substitutions;
+
+public:
+ /// \returns the value of string variable \p VarName or an error if no such
+ /// variable has been defined.
+ Expected<StringRef> getPatternVarValue(StringRef VarName);
+
+ /// Defines string and numeric variables from definitions given on the
+ /// command line, passed as a vector of [#]VAR=VAL strings in
+ /// \p CmdlineDefines. \returns an error list containing diagnostics against
+ /// \p SM for all definition parsing failures, if any, or Success otherwise.
+ Error defineCmdlineVariables(std::vector<std::string> &CmdlineDefines,
+ SourceMgr &SM);
+
+ /// Create @LINE pseudo variable. Value is set when pattern are being
+ /// matched.
+ void createLineVariable();
+
+ /// Undefines local variables (variables whose name does not start with a '$'
+ /// sign), i.e. removes them from GlobalVariableTable and from
+ /// GlobalNumericVariableTable and also clears the value of numeric
+ /// variables.
+ void clearLocalVars();
+
+private:
+ /// Makes a new numeric variable and registers it for destruction when the
+ /// context is destroyed.
+ template <class... Types>
+ FileCheckNumericVariable *makeNumericVariable(Types... args);
+
+ /// Makes a new string substitution and registers it for destruction when the
+ /// context is destroyed.
+ FileCheckSubstitution *makeStringSubstitution(StringRef VarName,
+ size_t InsertIdx);
+
+ /// Makes a new numeric substitution and registers it for destruction when
+ /// the context is destroyed.
+ FileCheckSubstitution *
+ makeNumericSubstitution(StringRef ExpressionStr,
+ std::unique_ptr<FileCheckExpressionAST> ExpressionAST,
+ size_t InsertIdx);
+};
+
+/// Class to represent an error holding a diagnostic with location information
+/// used when printing it.
+class FileCheckErrorDiagnostic : public ErrorInfo<FileCheckErrorDiagnostic> {
+private:
+ SMDiagnostic Diagnostic;
+
+public:
+ static char ID;
+
+ FileCheckErrorDiagnostic(SMDiagnostic &&Diag) : Diagnostic(Diag) {}
+
+ std::error_code convertToErrorCode() const override {
+ return inconvertibleErrorCode();
+ }
+
+ /// Print diagnostic associated with this error when printing the error.
+ void log(raw_ostream &OS) const override { Diagnostic.print(nullptr, OS); }
+
+ static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg) {
+ return make_error<FileCheckErrorDiagnostic>(
+ SM.GetMessage(Loc, SourceMgr::DK_Error, ErrMsg));
+ }
+
+ static Error get(const SourceMgr &SM, StringRef Buffer, const Twine &ErrMsg) {
+ return get(SM, SMLoc::getFromPointer(Buffer.data()), ErrMsg);
+ }
+};
+
+class FileCheckNotFoundError : public ErrorInfo<FileCheckNotFoundError> {
+public:
+ static char ID;
+
+ std::error_code convertToErrorCode() const override {
+ return inconvertibleErrorCode();
+ }
+
+ /// Print diagnostic associated with this error when printing the error.
+ void log(raw_ostream &OS) const override {
+ OS << "String not found in input";
+ }
+};
+
+class FileCheckPattern {
+ SMLoc PatternLoc;
+
+ /// A fixed string to match as the pattern or empty if this pattern requires
+ /// a regex match.
+ StringRef FixedStr;
+
+ /// A regex string to match as the pattern or empty if this pattern requires
+ /// a fixed string to match.
+ std::string RegExStr;
+
+ /// Entries in this vector represent a substitution of a string variable or
+ /// an expression in the RegExStr regex at match time. For example, in the
+ /// case of a CHECK directive with the pattern "foo[[bar]]baz[[#N+1]]",
+ /// RegExStr will contain "foobaz" and we'll get two entries in this vector
+ /// that tells us to insert the value of string variable "bar" at offset 3
+ /// and the value of expression "N+1" at offset 6.
+ std::vector<FileCheckSubstitution *> Substitutions;
+
+ /// Maps names of string variables defined in a pattern to the number of
+ /// their parenthesis group in RegExStr capturing their last definition.
+ ///
+ /// E.g. for the pattern "foo[[bar:.*]]baz([[bar]][[QUUX]][[bar:.*]])",
+ /// RegExStr will be "foo(.*)baz(\1<quux value>(.*))" where <quux value> is
+ /// the value captured for QUUX on the earlier line where it was defined, and
+ /// VariableDefs will map "bar" to the third parenthesis group which captures
+ /// the second definition of "bar".
+ ///
+ /// Note: uses std::map rather than StringMap to be able to get the key when
+ /// iterating over values.
+ std::map<StringRef, unsigned> VariableDefs;
+
+ /// Structure representing the definition of a numeric variable in a pattern.
+ /// It holds the pointer to the class representing the numeric variable whose
+ /// value is being defined and the number of the parenthesis group in
+ /// RegExStr to capture that value.
+ struct FileCheckNumericVariableMatch {
+ /// Pointer to class representing the numeric variable whose value is being
+ /// defined.
+ FileCheckNumericVariable *DefinedNumericVariable;
+
+ /// Number of the parenthesis group in RegExStr that captures the value of
+ /// this numeric variable definition.
+ unsigned CaptureParenGroup;
+ };
+
+ /// Holds the number of the parenthesis group in RegExStr and pointer to the
+ /// corresponding FileCheckNumericVariable class instance of all numeric
+ /// variable definitions. Used to set the matched value of all those
+ /// variables.
+ StringMap<FileCheckNumericVariableMatch> NumericVariableDefs;
+
+ /// Pointer to a class instance holding the global state shared by all
+ /// patterns:
+ /// - separate tables with the values of live string and numeric variables
+ /// respectively at the start of any given CHECK line;
+ /// - table holding whether a string variable has been defined at any given
+ /// point during the parsing phase.
+ FileCheckPatternContext *Context;
+
+ Check::FileCheckType CheckTy;
+
+ /// Line number for this CHECK pattern or None if it is an implicit pattern.
+ /// Used to determine whether a variable definition is made on an earlier
+ /// line to the one with this CHECK.
+ Optional<size_t> LineNumber;
+
+public:
+ FileCheckPattern(Check::FileCheckType Ty, FileCheckPatternContext *Context,
+ Optional<size_t> Line = None)
+ : Context(Context), CheckTy(Ty), LineNumber(Line) {}
+
+ /// \returns the location in source code.
+ SMLoc getLoc() const { return PatternLoc; }
+
+ /// \returns the pointer to the global state for all patterns in this
+ /// FileCheck instance.
+ FileCheckPatternContext *getContext() const { return Context; }
+
+ /// \returns whether \p C is a valid first character for a variable name.
+ static bool isValidVarNameStart(char C);
+
+ /// Parsing information about a variable.
+ struct VariableProperties {
+ StringRef Name;
+ bool IsPseudo;
+ };
+
+ /// Parses the string at the start of \p Str for a variable name. \returns
+ /// a VariableProperties structure holding the variable name and whether it
+ /// is the name of a pseudo variable, or an error holding a diagnostic
+ /// against \p SM if parsing fail. If parsing was successful, also strips
+ /// \p Str from the variable name.
+ static Expected<VariableProperties> parseVariable(StringRef &Str,
+ const SourceMgr &SM);
+ /// Parses \p Expr for a numeric substitution block at line \p LineNumber,
+ /// or before input is parsed if \p LineNumber is None. Parameter
+ /// \p IsLegacyLineExpr indicates whether \p Expr should be a legacy @LINE
+ /// expression and \p Context points to the class instance holding the live
+ /// string and numeric variables. \returns a pointer to the class instance
+ /// representing the AST of the expression whose value must be substitued, or
+ /// an error holding a diagnostic against \p SM if parsing fails. If
+ /// substitution was successful, sets \p DefinedNumericVariable to point to
+ /// the class representing the numeric variable defined in this numeric
+ /// substitution block, or None if this block does not define any variable.
+ static Expected<std::unique_ptr<FileCheckExpressionAST>>
+ parseNumericSubstitutionBlock(
+ StringRef Expr,
+ Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
+ bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context, const SourceMgr &SM);
+ /// Parses the pattern in \p PatternStr and initializes this FileCheckPattern
+ /// instance accordingly.
+ ///
+ /// \p Prefix provides which prefix is being matched, \p Req describes the
+ /// global options that influence the parsing such as whitespace
+ /// canonicalization, \p SM provides the SourceMgr used for error reports.
+ /// \returns true in case of an error, false otherwise.
+ bool parsePattern(StringRef PatternStr, StringRef Prefix, SourceMgr &SM,
+ const FileCheckRequest &Req);
+ /// Matches the pattern string against the input buffer \p Buffer
+ ///
+ /// \returns the position that is matched or an error indicating why matching
+ /// failed. If there is a match, updates \p MatchLen with the size of the
+ /// matched string.
+ ///
+ /// The GlobalVariableTable StringMap in the FileCheckPatternContext class
+ /// instance provides the current values of FileCheck string variables and
+ /// is updated if this match defines new values. Likewise, the
+ /// GlobalNumericVariableTable StringMap in the same class provides the
+ /// current values of FileCheck numeric variables and is updated if this
+ /// match defines new numeric values.
+ Expected<size_t> match(StringRef Buffer, size_t &MatchLen,
+ const SourceMgr &SM) const;
+ /// Prints the value of successful substitutions or the name of the undefined
+ /// string or numeric variables preventing a successful substitution.
+ void printSubstitutions(const SourceMgr &SM, StringRef Buffer,
+ SMRange MatchRange = None) const;
+ void printFuzzyMatch(const SourceMgr &SM, StringRef Buffer,
+ std::vector<FileCheckDiag> *Diags) const;
+
+ bool hasVariable() const {
+ return !(Substitutions.empty() && VariableDefs.empty());
+ }
+
+ Check::FileCheckType getCheckTy() const { return CheckTy; }
+
+ int getCount() const { return CheckTy.getCount(); }
+
+private:
+ bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);
+ void AddBackrefToRegEx(unsigned BackrefNum);
+ /// Computes an arbitrary estimate for the quality of matching this pattern
+ /// at the start of \p Buffer; a distance of zero should correspond to a
+ /// perfect match.
+ unsigned computeMatchDistance(StringRef Buffer) const;
+ /// Finds the closing sequence of a regex variable usage or definition.
+ ///
+ /// \p Str has to point in the beginning of the definition (right after the
+ /// opening sequence). \p SM holds the SourceMgr used for error repporting.
+ /// \returns the offset of the closing sequence within Str, or npos if it
+ /// was not found.
+ size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
+
+ /// Parses \p Expr for the name of a numeric variable to be defined at line
+ /// \p LineNumber, or before input is parsed if \p LineNumber is None.
+ /// \returns a pointer to the class instance representing that variable,
+ /// creating it if needed, or an error holding a diagnostic against \p SM
+ /// should defining such a variable be invalid.
+ static Expected<FileCheckNumericVariable *> parseNumericVariableDefinition(
+ StringRef &Expr, FileCheckPatternContext *Context,
+ Optional<size_t> LineNumber, const SourceMgr &SM);
+ /// Parses \p Name as a (pseudo if \p IsPseudo is true) numeric variable use
+ /// at line \p LineNumber, or before input is parsed if \p LineNumber is
+ /// None. Parameter \p Context points to the class instance holding the live
+ /// string and numeric variables. \returns the pointer to the class instance
+ /// representing that variable if successful, or an error holding a
+ /// diagnostic against \p SM otherwise.
+ static Expected<std::unique_ptr<FileCheckNumericVariableUse>>
+ parseNumericVariableUse(StringRef Name, bool IsPseudo,
+ Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context,
+ const SourceMgr &SM);
+ enum class AllowedOperand { LineVar, Literal, Any };
+ /// Parses \p Expr for use of a numeric operand at line \p LineNumber, or
+ /// before input is parsed if \p LineNumber is None. Accepts both literal
+ /// values and numeric variables, depending on the value of \p AO. Parameter
+ /// \p Context points to the class instance holding the live string and
+ /// numeric variables. \returns the class representing that operand in the
+ /// AST of the expression or an error holding a diagnostic against \p SM
+ /// otherwise.
+ static Expected<std::unique_ptr<FileCheckExpressionAST>>
+ parseNumericOperand(StringRef &Expr, AllowedOperand AO,
+ Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context, const SourceMgr &SM);
+ /// Parses \p Expr for a binary operation at line \p LineNumber, or before
+ /// input is parsed if \p LineNumber is None. The left operand of this binary
+ /// operation is given in \p LeftOp and \p IsLegacyLineExpr indicates whether
+ /// we are parsing a legacy @LINE expression. Parameter \p Context points to
+ /// the class instance holding the live string and numeric variables.
+ /// \returns the class representing the binary operation in the AST of the
+ /// expression, or an error holding a diagnostic against \p SM otherwise.
+ static Expected<std::unique_ptr<FileCheckExpressionAST>>
+ parseBinop(StringRef &Expr, std::unique_ptr<FileCheckExpressionAST> LeftOp,
+ bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+ FileCheckPatternContext *Context, const SourceMgr &SM);
+};
+
+//===----------------------------------------------------------------------===//
+// Check Strings.
+//===----------------------------------------------------------------------===//
+
+/// A check that we found in the input file.
+struct FileCheckString {
+ /// The pattern to match.
+ FileCheckPattern Pat;
+
+ /// Which prefix name this check matched.
+ StringRef Prefix;
+
+ /// The location in the match file that the check string was specified.
+ SMLoc Loc;
+
+ /// All of the strings that are disallowed from occurring between this match
+ /// string and the previous one (or start of file).
+ std::vector<FileCheckPattern> DagNotStrings;
+
+ FileCheckString(const FileCheckPattern &P, StringRef S, SMLoc L)
+ : Pat(P), Prefix(S), Loc(L) {}
+
+ /// Matches check string and its "not strings" and/or "dag strings".
+ size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabelScanMode,
+ size_t &MatchLen, FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) const;
+
+ /// Verifies that there is a single line in the given \p Buffer. Errors are
+ /// reported against \p SM.
+ bool CheckNext(const SourceMgr &SM, StringRef Buffer) const;
+ /// Verifies that there is no newline in the given \p Buffer. Errors are
+ /// reported against \p SM.
+ bool CheckSame(const SourceMgr &SM, StringRef Buffer) const;
+ /// Verifies that none of the strings in \p NotStrings are found in the given
+ /// \p Buffer. Errors are reported against \p SM and diagnostics recorded in
+ /// \p Diags according to the verbosity level set in \p Req.
+ bool CheckNot(const SourceMgr &SM, StringRef Buffer,
+ const std::vector<const FileCheckPattern *> &NotStrings,
+ const FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) const;
+ /// Matches "dag strings" and their mixed "not strings".
+ size_t CheckDag(const SourceMgr &SM, StringRef Buffer,
+ std::vector<const FileCheckPattern *> &NotStrings,
+ const FileCheckRequest &Req,
+ std::vector<FileCheckDiag> *Diags) const;
+};
+
+} // namespace llvm
+
+#endif
+++ /dev/null
-## Check that a full line is matched case insensitively.\r
-# RUN: FileCheck --ignore-case --match-full-lines --check-prefix=FULL --input-file=%s %s\r
-\r
-## Check that a regular expression matches case insensitively.\r
-# RUN: FileCheck --ignore-case --check-prefix=REGEX --input-file=%s %s\r
-\r
-## Check that a pattern from command line matches case insensitively.\r
-# RUN: FileCheck --ignore-case --check-prefix=PAT --DPATTERN="THIS is the" --input-file=%s %s\r
-\r
-## Check that COUNT and NEXT work case insensitively.\r
-# RUN: FileCheck --ignore-case --check-prefix=CNT --input-file=%s %s\r
-\r
-## Check that match on same line works case insensitively.\r
-# RUN: FileCheck --ignore-case --check-prefix=LINE --input-file=%s %s\r
-\r
-## Check that option --implicit-not works case insensitively.\r
-# RUN: sed '/^#/d' %s | FileCheck --implicit-check-not=sTrInG %s\r
-# RUN: sed '/^#/d' %s | not FileCheck --ignore-case --implicit-check-not=sTrInG %s 2>&1 | FileCheck --check-prefix=ERROR %s\r
-\r
-this is the STRING to be matched\r
-\r
-# FULL: tHis iS The String TO be matched\r
-# REGEX: s{{TRing}}\r
-# PAT: [[PATTERN]] string\r
-\r
-Loop 1\r
-lOop 2\r
-loOp 3\r
-looP 4\r
-loop 5\r
-LOOP 6\r
-BREAK\r
-\r
-# CNT-COUNT-6: LOop {{[0-9]}}\r
-# CNT-NOT: loop\r
-# CNT-NEXT: break\r
-\r
-One Line To Match\r
-\r
-# LINE: {{o}}ne line\r
-# LINE-SAME: {{t}}o match\r
-\r
-# ERROR: command line:1:{{[0-9]+]}}: error: CHECK-NOT: excluded string found in input\r
-# ERROR-NEXT: -implicit-check-not='sTrInG'\r
-# ERROR: note: found here\r
-//===- FileCheck.cpp - Check that File's Contents match what is expected --===//\r
-//\r
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.\r
-// See https://llvm.org/LICENSE.txt for license information.\r
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\r
-//\r
-//===----------------------------------------------------------------------===//\r
-//\r
-// FileCheck does a line-by line check of a file that validates whether it\r
-// contains the expected content. This is useful for regression tests etc.\r
-//\r
-// This program exits with an exit status of 2 on error, exit status of 0 if\r
-// the file matched the expected contents, and exit status of 1 if it did not\r
-// contain the expected contents.\r
-//\r
-//===----------------------------------------------------------------------===//\r
-\r
-#include "llvm/Support/CommandLine.h"\r
-#include "llvm/Support/InitLLVM.h"\r
-#include "llvm/Support/Process.h"\r
-#include "llvm/Support/WithColor.h"\r
-#include "llvm/Support/raw_ostream.h"\r
-#include "llvm/Support/FileCheck.h"\r
-#include <cmath>\r
-using namespace llvm;\r
-\r
-static cl::extrahelp FileCheckOptsEnv(\r
- "\nOptions are parsed from the environment variable FILECHECK_OPTS and\n"\r
- "from the command line.\n");\r
-\r
-static cl::opt<std::string>\r
- CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Optional);\r
-\r
-static cl::opt<std::string>\r
- InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),\r
- cl::init("-"), cl::value_desc("filename"));\r
-\r
-static cl::list<std::string> CheckPrefixes(\r
- "check-prefix",\r
- cl::desc("Prefix to use from check file (defaults to 'CHECK')"));\r
-static cl::alias CheckPrefixesAlias(\r
- "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated,\r
- cl::NotHidden,\r
- cl::desc(\r
- "Alias for -check-prefix permitting multiple comma separated values"));\r
-\r
-static cl::opt<bool> NoCanonicalizeWhiteSpace(\r
- "strict-whitespace",\r
- cl::desc("Do not treat all horizontal whitespace as equivalent"));\r
-\r
-static cl::opt<bool> IgnoreCase(\r
- "ignore-case",\r
- cl::desc("Use case-insensitive matching"));\r
-\r
-static cl::list<std::string> ImplicitCheckNot(\r
- "implicit-check-not",\r
- cl::desc("Add an implicit negative check with this pattern to every\n"\r
- "positive check. This can be used to ensure that no instances of\n"\r
- "this pattern occur which are not matched by a positive pattern"),\r
- cl::value_desc("pattern"));\r
-\r
-static cl::list<std::string>\r
- GlobalDefines("D", cl::AlwaysPrefix,\r
- cl::desc("Define a variable to be used in capture patterns."),\r
- cl::value_desc("VAR=VALUE"));\r
-\r
-static cl::opt<bool> AllowEmptyInput(\r
- "allow-empty", cl::init(false),\r
- cl::desc("Allow the input file to be empty. This is useful when making\n"\r
- "checks that some error message does not occur, for example."));\r
-\r
-static cl::opt<bool> MatchFullLines(\r
- "match-full-lines", cl::init(false),\r
- cl::desc("Require all positive matches to cover an entire input line.\n"\r
- "Allows leading and trailing whitespace if --strict-whitespace\n"\r
- "is not also passed."));\r
-\r
-static cl::opt<bool> EnableVarScope(\r
- "enable-var-scope", cl::init(false),\r
- cl::desc("Enables scope for regex variables. Variables with names that\n"\r
- "do not start with '$' will be reset at the beginning of\n"\r
- "each CHECK-LABEL block."));\r
-\r
-static cl::opt<bool> AllowDeprecatedDagOverlap(\r
- "allow-deprecated-dag-overlap", cl::init(false),\r
- cl::desc("Enable overlapping among matches in a group of consecutive\n"\r
- "CHECK-DAG directives. This option is deprecated and is only\n"\r
- "provided for convenience as old tests are migrated to the new\n"\r
- "non-overlapping CHECK-DAG implementation.\n"));\r
-\r
-static cl::opt<bool> Verbose(\r
- "v", cl::init(false),\r
- cl::desc("Print directive pattern matches, or add them to the input dump\n"\r
- "if enabled.\n"));\r
-\r
-static cl::opt<bool> VerboseVerbose(\r
- "vv", cl::init(false),\r
- cl::desc("Print information helpful in diagnosing internal FileCheck\n"\r
- "issues, or add it to the input dump if enabled. Implies\n"\r
- "-v.\n"));\r
-static const char * DumpInputEnv = "FILECHECK_DUMP_INPUT_ON_FAILURE";\r
-\r
-static cl::opt<bool> DumpInputOnFailure(\r
- "dump-input-on-failure",\r
- cl::init(std::getenv(DumpInputEnv) && *std::getenv(DumpInputEnv)),\r
- cl::desc("Dump original input to stderr before failing.\n"\r
- "The value can be also controlled using\n"\r
- "FILECHECK_DUMP_INPUT_ON_FAILURE environment variable.\n"\r
- "This option is deprecated in favor of -dump-input=fail.\n"));\r
-\r
-enum DumpInputValue {\r
- DumpInputDefault,\r
- DumpInputHelp,\r
- DumpInputNever,\r
- DumpInputFail,\r
- DumpInputAlways\r
-};\r
-\r
-static cl::opt<DumpInputValue> DumpInput(\r
- "dump-input", cl::init(DumpInputDefault),\r
- cl::desc("Dump input to stderr, adding annotations representing\n"\r
- " currently enabled diagnostics\n"),\r
- cl::value_desc("mode"),\r
- cl::values(clEnumValN(DumpInputHelp, "help",\r
- "Explain dump format and quit"),\r
- clEnumValN(DumpInputNever, "never", "Never dump input"),\r
- clEnumValN(DumpInputFail, "fail", "Dump input on failure"),\r
- clEnumValN(DumpInputAlways, "always", "Always dump input")));\r
-\r
-typedef cl::list<std::string>::const_iterator prefix_iterator;\r
-\r
-\r
-\r
-\r
-\r
-\r
-\r
-static void DumpCommandLine(int argc, char **argv) {\r
- errs() << "FileCheck command line: ";\r
- for (int I = 0; I < argc; I++)\r
- errs() << " " << argv[I];\r
- errs() << "\n";\r
-}\r
-\r
-struct MarkerStyle {\r
- /// The starting char (before tildes) for marking the line.\r
- char Lead;\r
- /// What color to use for this annotation.\r
- raw_ostream::Colors Color;\r
- /// A note to follow the marker, or empty string if none.\r
- std::string Note;\r
- MarkerStyle() {}\r
- MarkerStyle(char Lead, raw_ostream::Colors Color,\r
- const std::string &Note = "")\r
- : Lead(Lead), Color(Color), Note(Note) {}\r
-};\r
-\r
-static MarkerStyle GetMarker(FileCheckDiag::MatchType MatchTy) {\r
- switch (MatchTy) {\r
- case FileCheckDiag::MatchFoundAndExpected:\r
- return MarkerStyle('^', raw_ostream::GREEN);\r
- case FileCheckDiag::MatchFoundButExcluded:\r
- return MarkerStyle('!', raw_ostream::RED, "error: no match expected");\r
- case FileCheckDiag::MatchFoundButWrongLine:\r
- return MarkerStyle('!', raw_ostream::RED, "error: match on wrong line");\r
- case FileCheckDiag::MatchFoundButDiscarded:\r
- return MarkerStyle('!', raw_ostream::CYAN,\r
- "discard: overlaps earlier match");\r
- case FileCheckDiag::MatchNoneAndExcluded:\r
- return MarkerStyle('X', raw_ostream::GREEN);\r
- case FileCheckDiag::MatchNoneButExpected:\r
- return MarkerStyle('X', raw_ostream::RED, "error: no match found");\r
- case FileCheckDiag::MatchFuzzy:\r
- return MarkerStyle('?', raw_ostream::MAGENTA, "possible intended match");\r
- }\r
- llvm_unreachable_internal("unexpected match type");\r
-}\r
-\r
-static void DumpInputAnnotationHelp(raw_ostream &OS) {\r
- OS << "The following description was requested by -dump-input=help to\n"\r
- << "explain the input annotations printed by -dump-input=always and\n"\r
- << "-dump-input=fail:\n\n";\r
-\r
- // Labels for input lines.\r
- OS << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "L:";\r
- OS << " labels line number L of the input file\n";\r
-\r
- // Labels for annotation lines.\r
- OS << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L";\r
- OS << " labels the only match result for a pattern of type T from "\r
- << "line L of\n"\r
- << " the check file\n";\r
- OS << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L'N";\r
- OS << " labels the Nth match result for a pattern of type T from line "\r
- << "L of\n"\r
- << " the check file\n";\r
-\r
- // Markers on annotation lines.\r
- OS << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "^~~";\r
- OS << " marks good match (reported if -v)\n"\r
- << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "!~~";\r
- OS << " marks bad match, such as:\n"\r
- << " - CHECK-NEXT on same line as previous match (error)\n"\r
- << " - CHECK-NOT found (error)\n"\r
- << " - CHECK-DAG overlapping match (discarded, reported if "\r
- << "-vv)\n"\r
- << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "X~~";\r
- OS << " marks search range when no match is found, such as:\n"\r
- << " - CHECK-NEXT not found (error)\n"\r
- << " - CHECK-NOT not found (success, reported if -vv)\n"\r
- << " - CHECK-DAG not found after discarded matches (error)\n"\r
- << " - ";\r
- WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";\r
- OS << " marks fuzzy match when no match is found\n";\r
-\r
- // Colors.\r
- OS << " - colors ";\r
- WithColor(OS, raw_ostream::GREEN, true) << "success";\r
- OS << ", ";\r
- WithColor(OS, raw_ostream::RED, true) << "error";\r
- OS << ", ";\r
- WithColor(OS, raw_ostream::MAGENTA, true) << "fuzzy match";\r
- OS << ", ";\r
- WithColor(OS, raw_ostream::CYAN, true, false) << "discarded match";\r
- OS << ", ";\r
- WithColor(OS, raw_ostream::CYAN, true, true) << "unmatched input";\r
- OS << "\n\n"\r
- << "If you are not seeing color above or in input dumps, try: -color\n";\r
-}\r
-\r
-/// An annotation for a single input line.\r
-struct InputAnnotation {\r
- /// The check file line (one-origin indexing) where the directive that\r
- /// produced this annotation is located.\r
- unsigned CheckLine;\r
- /// The index of the match result for this check.\r
- unsigned CheckDiagIndex;\r
- /// The label for this annotation.\r
- std::string Label;\r
- /// What input line (one-origin indexing) this annotation marks. This might\r
- /// be different from the starting line of the original diagnostic if this is\r
- /// a non-initial fragment of a diagnostic that has been broken across\r
- /// multiple lines.\r
- unsigned InputLine;\r
- /// The column range (one-origin indexing, open end) in which to to mark the\r
- /// input line. If InputEndCol is UINT_MAX, treat it as the last column\r
- /// before the newline.\r
- unsigned InputStartCol, InputEndCol;\r
- /// The marker to use.\r
- MarkerStyle Marker;\r
- /// Whether this annotation represents a good match for an expected pattern.\r
- bool FoundAndExpectedMatch;\r
-};\r
-\r
-/// Get an abbreviation for the check type.\r
-std::string GetCheckTypeAbbreviation(Check::FileCheckType Ty) {\r
- switch (Ty) {\r
- case Check::CheckPlain:\r
- if (Ty.getCount() > 1)\r
- return "count";\r
- return "check";\r
- case Check::CheckNext:\r
- return "next";\r
- case Check::CheckSame:\r
- return "same";\r
- case Check::CheckNot:\r
- return "not";\r
- case Check::CheckDAG:\r
- return "dag";\r
- case Check::CheckLabel:\r
- return "label";\r
- case Check::CheckEmpty:\r
- return "empty";\r
- case Check::CheckEOF:\r
- return "eof";\r
- case Check::CheckBadNot:\r
- return "bad-not";\r
- case Check::CheckBadCount:\r
- return "bad-count";\r
- case Check::CheckNone:\r
- llvm_unreachable("invalid FileCheckType");\r
- }\r
- llvm_unreachable("unknown FileCheckType");\r
-}\r
-\r
-static void BuildInputAnnotations(const std::vector<FileCheckDiag> &Diags,\r
- std::vector<InputAnnotation> &Annotations,\r
- unsigned &LabelWidth) {\r
- // How many diagnostics has the current check seen so far?\r
- unsigned CheckDiagCount = 0;\r
- // What's the widest label?\r
- LabelWidth = 0;\r
- for (auto DiagItr = Diags.begin(), DiagEnd = Diags.end(); DiagItr != DiagEnd;\r
- ++DiagItr) {\r
- InputAnnotation A;\r
-\r
- // Build label, which uniquely identifies this check result.\r
- A.CheckLine = DiagItr->CheckLine;\r
- llvm::raw_string_ostream Label(A.Label);\r
- Label << GetCheckTypeAbbreviation(DiagItr->CheckTy) << ":"\r
- << DiagItr->CheckLine;\r
- A.CheckDiagIndex = UINT_MAX;\r
- auto DiagNext = std::next(DiagItr);\r
- if (DiagNext != DiagEnd && DiagItr->CheckTy == DiagNext->CheckTy &&\r
- DiagItr->CheckLine == DiagNext->CheckLine)\r
- A.CheckDiagIndex = CheckDiagCount++;\r
- else if (CheckDiagCount) {\r
- A.CheckDiagIndex = CheckDiagCount;\r
- CheckDiagCount = 0;\r
- }\r
- if (A.CheckDiagIndex != UINT_MAX)\r
- Label << "'" << A.CheckDiagIndex;\r
- else\r
- A.CheckDiagIndex = 0;\r
- Label.flush();\r
- LabelWidth = std::max((std::string::size_type)LabelWidth, A.Label.size());\r
-\r
- A.Marker = GetMarker(DiagItr->MatchTy);\r
- A.FoundAndExpectedMatch =\r
- DiagItr->MatchTy == FileCheckDiag::MatchFoundAndExpected;\r
-\r
- // Compute the mark location, and break annotation into multiple\r
- // annotations if it spans multiple lines.\r
- A.InputLine = DiagItr->InputStartLine;\r
- A.InputStartCol = DiagItr->InputStartCol;\r
- if (DiagItr->InputStartLine == DiagItr->InputEndLine) {\r
- // Sometimes ranges are empty in order to indicate a specific point, but\r
- // that would mean nothing would be marked, so adjust the range to\r
- // include the following character.\r
- A.InputEndCol =\r
- std::max(DiagItr->InputStartCol + 1, DiagItr->InputEndCol);\r
- Annotations.push_back(A);\r
- } else {\r
- assert(DiagItr->InputStartLine < DiagItr->InputEndLine &&\r
- "expected input range not to be inverted");\r
- A.InputEndCol = UINT_MAX;\r
- Annotations.push_back(A);\r
- for (unsigned L = DiagItr->InputStartLine + 1, E = DiagItr->InputEndLine;\r
- L <= E; ++L) {\r
- // If a range ends before the first column on a line, then it has no\r
- // characters on that line, so there's nothing to render.\r
- if (DiagItr->InputEndCol == 1 && L == E)\r
- break;\r
- InputAnnotation B;\r
- B.CheckLine = A.CheckLine;\r
- B.CheckDiagIndex = A.CheckDiagIndex;\r
- B.Label = A.Label;\r
- B.InputLine = L;\r
- B.Marker = A.Marker;\r
- B.Marker.Lead = '~';\r
- B.Marker.Note = "";\r
- B.InputStartCol = 1;\r
- if (L != E)\r
- B.InputEndCol = UINT_MAX;\r
- else\r
- B.InputEndCol = DiagItr->InputEndCol;\r
- B.FoundAndExpectedMatch = A.FoundAndExpectedMatch;\r
- Annotations.push_back(B);\r
- }\r
- }\r
- }\r
-}\r
-\r
-static void DumpAnnotatedInput(raw_ostream &OS, const FileCheckRequest &Req,\r
- StringRef InputFileText,\r
- std::vector<InputAnnotation> &Annotations,\r
- unsigned LabelWidth) {\r
- OS << "Full input was:\n<<<<<<\n";\r
-\r
- // Sort annotations.\r
- //\r
- // First, sort in the order of input lines to make it easier to find relevant\r
- // annotations while iterating input lines in the implementation below.\r
- // FileCheck diagnostics are not always reported and recorded in the order of\r
- // input lines due to, for example, CHECK-DAG and CHECK-NOT.\r
- //\r
- // Second, for annotations for the same input line, sort in the order of the\r
- // FileCheck directive's line in the check file (where there's at most one\r
- // directive per line) and then by the index of the match result for that\r
- // directive. The rationale of this choice is that, for any input line, this\r
- // sort establishes a total order of annotations that, with respect to match\r
- // results, is consistent across multiple lines, thus making match results\r
- // easier to track from one line to the next when they span multiple lines.\r
- std::sort(Annotations.begin(), Annotations.end(),\r
- [](const InputAnnotation &A, const InputAnnotation &B) {\r
- if (A.InputLine != B.InputLine)\r
- return A.InputLine < B.InputLine;\r
- if (A.CheckLine != B.CheckLine)\r
- return A.CheckLine < B.CheckLine;\r
- // FIXME: Sometimes CHECK-LABEL reports its match twice with\r
- // other diagnostics in between, and then diag index incrementing\r
- // fails to work properly, and then this assert fails. We should\r
- // suppress one of those diagnostics or do a better job of\r
- // computing this index. For now, we just produce a redundant\r
- // CHECK-LABEL annotation.\r
- // assert(A.CheckDiagIndex != B.CheckDiagIndex &&\r
- // "expected diagnostic indices to be unique within a "\r
- // " check line");\r
- return A.CheckDiagIndex < B.CheckDiagIndex;\r
- });\r
-\r
- // Compute the width of the label column.\r
- const unsigned char *InputFilePtr = InputFileText.bytes_begin(),\r
- *InputFileEnd = InputFileText.bytes_end();\r
- unsigned LineCount = InputFileText.count('\n');\r
- if (InputFileEnd[-1] != '\n')\r
- ++LineCount;\r
- unsigned LineNoWidth = std::log10(LineCount) + 1;\r
- // +3 below adds spaces (1) to the left of the (right-aligned) line numbers\r
- // on input lines and (2) to the right of the (left-aligned) labels on\r
- // annotation lines so that input lines and annotation lines are more\r
- // visually distinct. For example, the spaces on the annotation lines ensure\r
- // that input line numbers and check directive line numbers never align\r
- // horizontally. Those line numbers might not even be for the same file.\r
- // One space would be enough to achieve that, but more makes it even easier\r
- // to see.\r
- LabelWidth = std::max(LabelWidth, LineNoWidth) + 3;\r
-\r
- // Print annotated input lines.\r
- auto AnnotationItr = Annotations.begin(), AnnotationEnd = Annotations.end();\r
- for (unsigned Line = 1;\r
- InputFilePtr != InputFileEnd || AnnotationItr != AnnotationEnd;\r
- ++Line) {\r
- const unsigned char *InputFileLine = InputFilePtr;\r
-\r
- // Print right-aligned line number.\r
- WithColor(OS, raw_ostream::BLACK, true)\r
- << format_decimal(Line, LabelWidth) << ": ";\r
-\r
- // For the case where -v and colors are enabled, find the annotations for\r
- // good matches for expected patterns in order to highlight everything\r
- // else in the line. There are no such annotations if -v is disabled.\r
- std::vector<InputAnnotation> FoundAndExpectedMatches;\r
- if (Req.Verbose && WithColor(OS).colorsEnabled()) {\r
- for (auto I = AnnotationItr; I != AnnotationEnd && I->InputLine == Line;\r
- ++I) {\r
- if (I->FoundAndExpectedMatch)\r
- FoundAndExpectedMatches.push_back(*I);\r
- }\r
- }\r
-\r
- // Print numbered line with highlighting where there are no matches for\r
- // expected patterns.\r
- bool Newline = false;\r
- {\r
- WithColor COS(OS);\r
- bool InMatch = false;\r
- if (Req.Verbose)\r
- COS.changeColor(raw_ostream::CYAN, true, true);\r
- for (unsigned Col = 1; InputFilePtr != InputFileEnd && !Newline; ++Col) {\r
- bool WasInMatch = InMatch;\r
- InMatch = false;\r
- for (auto M : FoundAndExpectedMatches) {\r
- if (M.InputStartCol <= Col && Col < M.InputEndCol) {\r
- InMatch = true;\r
- break;\r
- }\r
- }\r
- if (!WasInMatch && InMatch)\r
- COS.resetColor();\r
- else if (WasInMatch && !InMatch)\r
- COS.changeColor(raw_ostream::CYAN, true, true);\r
- if (*InputFilePtr == '\n')\r
- Newline = true;\r
- else\r
- COS << *InputFilePtr;\r
- ++InputFilePtr;\r
- }\r
- }\r
- OS << '\n';\r
- unsigned InputLineWidth = InputFilePtr - InputFileLine - Newline;\r
-\r
- // Print any annotations.\r
- while (AnnotationItr != AnnotationEnd &&\r
- AnnotationItr->InputLine == Line) {\r
- WithColor COS(OS, AnnotationItr->Marker.Color, true);\r
- // The two spaces below are where the ": " appears on input lines.\r
- COS << left_justify(AnnotationItr->Label, LabelWidth) << " ";\r
- unsigned Col;\r
- for (Col = 1; Col < AnnotationItr->InputStartCol; ++Col)\r
- COS << ' ';\r
- COS << AnnotationItr->Marker.Lead;\r
- // If InputEndCol=UINT_MAX, stop at InputLineWidth.\r
- for (++Col; Col < AnnotationItr->InputEndCol && Col <= InputLineWidth;\r
- ++Col)\r
- COS << '~';\r
- const std::string &Note = AnnotationItr->Marker.Note;\r
- if (!Note.empty()) {\r
- // Put the note at the end of the input line. If we were to instead\r
- // put the note right after the marker, subsequent annotations for the\r
- // same input line might appear to mark this note instead of the input\r
- // line.\r
- for (; Col <= InputLineWidth; ++Col)\r
- COS << ' ';\r
- COS << ' ' << Note;\r
- }\r
- COS << '\n';\r
- ++AnnotationItr;\r
- }\r
- }\r
-\r
- OS << ">>>>>>\n";\r
-}\r
-\r
-int main(int argc, char **argv) {\r
- // Enable use of ANSI color codes because FileCheck is using them to\r
- // highlight text.\r
- llvm::sys::Process::UseANSIEscapeCodes(true);\r
-\r
- InitLLVM X(argc, argv);\r
- cl::ParseCommandLineOptions(argc, argv, /*Overview*/ "", /*Errs*/ nullptr,\r
- "FILECHECK_OPTS");\r
- if (DumpInput == DumpInputHelp) {\r
- DumpInputAnnotationHelp(outs());\r
- return 0;\r
- }\r
- if (CheckFilename.empty()) {\r
- errs() << "<check-file> not specified\n";\r
- return 2;\r
- }\r
-\r
- FileCheckRequest Req;\r
- for (auto Prefix : CheckPrefixes)\r
- Req.CheckPrefixes.push_back(Prefix);\r
-\r
- for (auto CheckNot : ImplicitCheckNot)\r
- Req.ImplicitCheckNot.push_back(CheckNot);\r
-\r
- bool GlobalDefineError = false;\r
- for (auto G : GlobalDefines) {\r
- size_t EqIdx = G.find('=');\r
- if (EqIdx == std::string::npos) {\r
- errs() << "Missing equal sign in command-line definition '-D" << G\r
- << "'\n";\r
- GlobalDefineError = true;\r
- continue;\r
- }\r
- if (EqIdx == 0) {\r
- errs() << "Missing variable name in command-line definition '-D" << G\r
- << "'\n";\r
- GlobalDefineError = true;\r
- continue;\r
- }\r
- Req.GlobalDefines.push_back(G);\r
- }\r
- if (GlobalDefineError)\r
- return 2;\r
-\r
- Req.AllowEmptyInput = AllowEmptyInput;\r
- Req.EnableVarScope = EnableVarScope;\r
- Req.AllowDeprecatedDagOverlap = AllowDeprecatedDagOverlap;\r
- Req.Verbose = Verbose;\r
- Req.VerboseVerbose = VerboseVerbose;\r
- Req.NoCanonicalizeWhiteSpace = NoCanonicalizeWhiteSpace;\r
- Req.MatchFullLines = MatchFullLines;\r
- Req.IgnoreCase = IgnoreCase;\r
-\r
- if (VerboseVerbose)\r
- Req.Verbose = true;\r
-\r
- FileCheck FC(Req);\r
- if (!FC.ValidateCheckPrefixes()) {\r
- errs() << "Supplied check-prefix is invalid! Prefixes must be unique and "\r
- "start with a letter and contain only alphanumeric characters, "\r
- "hyphens and underscores\n";\r
- return 2;\r
- }\r
-\r
- Regex PrefixRE = FC.buildCheckPrefixRegex();\r
- std::string REError;\r
- if (!PrefixRE.isValid(REError)) {\r
- errs() << "Unable to combine check-prefix strings into a prefix regular "\r
- "expression! This is likely a bug in FileCheck's verification of "\r
- "the check-prefix strings. Regular expression parsing failed "\r
- "with the following error: "\r
- << REError << "\n";\r
- return 2;\r
- }\r
-\r
- SourceMgr SM;\r
-\r
- // Read the expected strings from the check file.\r
- ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =\r
- MemoryBuffer::getFileOrSTDIN(CheckFilename);\r
- if (std::error_code EC = CheckFileOrErr.getError()) {\r
- errs() << "Could not open check file '" << CheckFilename\r
- << "': " << EC.message() << '\n';\r
- return 2;\r
- }\r
- MemoryBuffer &CheckFile = *CheckFileOrErr.get();\r
-\r
- SmallString<4096> CheckFileBuffer;\r
- StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);\r
-\r
- SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(\r
- CheckFileText, CheckFile.getBufferIdentifier()),\r
- SMLoc());\r
-\r
- if (FC.readCheckFile(SM, CheckFileText, PrefixRE))\r
- return 2;\r
-\r
- // Open the file to check and add it to SourceMgr.\r
- ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =\r
- MemoryBuffer::getFileOrSTDIN(InputFilename);\r
- if (std::error_code EC = InputFileOrErr.getError()) {\r
- errs() << "Could not open input file '" << InputFilename\r
- << "': " << EC.message() << '\n';\r
- return 2;\r
- }\r
- MemoryBuffer &InputFile = *InputFileOrErr.get();\r
-\r
- if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) {\r
- errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";\r
- DumpCommandLine(argc, argv);\r
- return 2;\r
- }\r
-\r
- SmallString<4096> InputFileBuffer;\r
- StringRef InputFileText = FC.CanonicalizeFile(InputFile, InputFileBuffer);\r
-\r
- SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(\r
- InputFileText, InputFile.getBufferIdentifier()),\r
- SMLoc());\r
-\r
- if (DumpInput == DumpInputDefault)\r
- DumpInput = DumpInputOnFailure ? DumpInputFail : DumpInputNever;\r
-\r
- std::vector<FileCheckDiag> Diags;\r
- int ExitCode = FC.checkInput(SM, InputFileText,\r
- DumpInput == DumpInputNever ? nullptr : &Diags)\r
- ? EXIT_SUCCESS\r
- : 1;\r
- if (DumpInput == DumpInputAlways ||\r
- (ExitCode == 1 && DumpInput == DumpInputFail)) {\r
- errs() << "\n"\r
- << "Input file: "\r
- << (InputFilename == "-" ? "<stdin>" : InputFilename.getValue())\r
- << "\n"\r
- << "Check file: " << CheckFilename << "\n"\r
- << "\n"\r
- << "-dump-input=help describes the format of the following dump.\n"\r
- << "\n";\r
- std::vector<InputAnnotation> Annotations;\r
- unsigned LabelWidth;\r
- BuildInputAnnotations(Diags, Annotations, LabelWidth);\r
- DumpAnnotatedInput(errs(), Req, InputFileText, Annotations, LabelWidth);\r
- }\r
-\r
- return ExitCode;\r
-}\r
+//===- FileCheck.cpp - Check that File's Contents match what is expected --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// FileCheck does a line-by line check of a file that validates whether it
+// contains the expected content. This is useful for regression tests etc.
+//
+// This program exits with an exit status of 2 on error, exit status of 0 if
+// the file matched the expected contents, and exit status of 1 if it did not
+// contain the expected contents.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/FileCheck.h"
+#include <cmath>
+using namespace llvm;
+
+static cl::extrahelp FileCheckOptsEnv(
+ "\nOptions are parsed from the environment variable FILECHECK_OPTS and\n"
+ "from the command line.\n");
+
+static cl::opt<std::string>
+ CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Optional);
+
+static cl::opt<std::string>
+ InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),
+ cl::init("-"), cl::value_desc("filename"));
+
+static cl::list<std::string> CheckPrefixes(
+ "check-prefix",
+ cl::desc("Prefix to use from check file (defaults to 'CHECK')"));
+static cl::alias CheckPrefixesAlias(
+ "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated,
+ cl::NotHidden,
+ cl::desc(
+ "Alias for -check-prefix permitting multiple comma separated values"));
+
+static cl::opt<bool> NoCanonicalizeWhiteSpace(
+ "strict-whitespace",
+ cl::desc("Do not treat all horizontal whitespace as equivalent"));
+
+static cl::list<std::string> ImplicitCheckNot(
+ "implicit-check-not",
+ cl::desc("Add an implicit negative check with this pattern to every\n"
+ "positive check. This can be used to ensure that no instances of\n"
+ "this pattern occur which are not matched by a positive pattern"),
+ cl::value_desc("pattern"));
+
+static cl::list<std::string>
+ GlobalDefines("D", cl::AlwaysPrefix,
+ cl::desc("Define a variable to be used in capture patterns."),
+ cl::value_desc("VAR=VALUE"));
+
+static cl::opt<bool> AllowEmptyInput(
+ "allow-empty", cl::init(false),
+ cl::desc("Allow the input file to be empty. This is useful when making\n"
+ "checks that some error message does not occur, for example."));
+
+static cl::opt<bool> MatchFullLines(
+ "match-full-lines", cl::init(false),
+ cl::desc("Require all positive matches to cover an entire input line.\n"
+ "Allows leading and trailing whitespace if --strict-whitespace\n"
+ "is not also passed."));
+
+static cl::opt<bool> EnableVarScope(
+ "enable-var-scope", cl::init(false),
+ cl::desc("Enables scope for regex variables. Variables with names that\n"
+ "do not start with '$' will be reset at the beginning of\n"
+ "each CHECK-LABEL block."));
+
+static cl::opt<bool> AllowDeprecatedDagOverlap(
+ "allow-deprecated-dag-overlap", cl::init(false),
+ cl::desc("Enable overlapping among matches in a group of consecutive\n"
+ "CHECK-DAG directives. This option is deprecated and is only\n"
+ "provided for convenience as old tests are migrated to the new\n"
+ "non-overlapping CHECK-DAG implementation.\n"));
+
+static cl::opt<bool> Verbose(
+ "v", cl::init(false),
+ cl::desc("Print directive pattern matches, or add them to the input dump\n"
+ "if enabled.\n"));
+
+static cl::opt<bool> VerboseVerbose(
+ "vv", cl::init(false),
+ cl::desc("Print information helpful in diagnosing internal FileCheck\n"
+ "issues, or add it to the input dump if enabled. Implies\n"
+ "-v.\n"));
+static const char * DumpInputEnv = "FILECHECK_DUMP_INPUT_ON_FAILURE";
+
+static cl::opt<bool> DumpInputOnFailure(
+ "dump-input-on-failure",
+ cl::init(std::getenv(DumpInputEnv) && *std::getenv(DumpInputEnv)),
+ cl::desc("Dump original input to stderr before failing.\n"
+ "The value can be also controlled using\n"
+ "FILECHECK_DUMP_INPUT_ON_FAILURE environment variable.\n"
+ "This option is deprecated in favor of -dump-input=fail.\n"));
+
+enum DumpInputValue {
+ DumpInputDefault,
+ DumpInputHelp,
+ DumpInputNever,
+ DumpInputFail,
+ DumpInputAlways
+};
+
+static cl::opt<DumpInputValue> DumpInput(
+ "dump-input", cl::init(DumpInputDefault),
+ cl::desc("Dump input to stderr, adding annotations representing\n"
+ " currently enabled diagnostics\n"),
+ cl::value_desc("mode"),
+ cl::values(clEnumValN(DumpInputHelp, "help",
+ "Explain dump format and quit"),
+ clEnumValN(DumpInputNever, "never", "Never dump input"),
+ clEnumValN(DumpInputFail, "fail", "Dump input on failure"),
+ clEnumValN(DumpInputAlways, "always", "Always dump input")));
+
+typedef cl::list<std::string>::const_iterator prefix_iterator;
+
+
+
+
+
+
+
+static void DumpCommandLine(int argc, char **argv) {
+ errs() << "FileCheck command line: ";
+ for (int I = 0; I < argc; I++)
+ errs() << " " << argv[I];
+ errs() << "\n";
+}
+
+struct MarkerStyle {
+ /// The starting char (before tildes) for marking the line.
+ char Lead;
+ /// What color to use for this annotation.
+ raw_ostream::Colors Color;
+ /// A note to follow the marker, or empty string if none.
+ std::string Note;
+ MarkerStyle() {}
+ MarkerStyle(char Lead, raw_ostream::Colors Color,
+ const std::string &Note = "")
+ : Lead(Lead), Color(Color), Note(Note) {}
+};
+
+static MarkerStyle GetMarker(FileCheckDiag::MatchType MatchTy) {
+ switch (MatchTy) {
+ case FileCheckDiag::MatchFoundAndExpected:
+ return MarkerStyle('^', raw_ostream::GREEN);
+ case FileCheckDiag::MatchFoundButExcluded:
+ return MarkerStyle('!', raw_ostream::RED, "error: no match expected");
+ case FileCheckDiag::MatchFoundButWrongLine:
+ return MarkerStyle('!', raw_ostream::RED, "error: match on wrong line");
+ case FileCheckDiag::MatchFoundButDiscarded:
+ return MarkerStyle('!', raw_ostream::CYAN,
+ "discard: overlaps earlier match");
+ case FileCheckDiag::MatchNoneAndExcluded:
+ return MarkerStyle('X', raw_ostream::GREEN);
+ case FileCheckDiag::MatchNoneButExpected:
+ return MarkerStyle('X', raw_ostream::RED, "error: no match found");
+ case FileCheckDiag::MatchFuzzy:
+ return MarkerStyle('?', raw_ostream::MAGENTA, "possible intended match");
+ }
+ llvm_unreachable_internal("unexpected match type");
+}
+
+static void DumpInputAnnotationHelp(raw_ostream &OS) {
+ OS << "The following description was requested by -dump-input=help to\n"
+ << "explain the input annotations printed by -dump-input=always and\n"
+ << "-dump-input=fail:\n\n";
+
+ // Labels for input lines.
+ OS << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "L:";
+ OS << " labels line number L of the input file\n";
+
+ // Labels for annotation lines.
+ OS << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L";
+ OS << " labels the only match result for a pattern of type T from "
+ << "line L of\n"
+ << " the check file\n";
+ OS << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L'N";
+ OS << " labels the Nth match result for a pattern of type T from line "
+ << "L of\n"
+ << " the check file\n";
+
+ // Markers on annotation lines.
+ OS << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "^~~";
+ OS << " marks good match (reported if -v)\n"
+ << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "!~~";
+ OS << " marks bad match, such as:\n"
+ << " - CHECK-NEXT on same line as previous match (error)\n"
+ << " - CHECK-NOT found (error)\n"
+ << " - CHECK-DAG overlapping match (discarded, reported if "
+ << "-vv)\n"
+ << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "X~~";
+ OS << " marks search range when no match is found, such as:\n"
+ << " - CHECK-NEXT not found (error)\n"
+ << " - CHECK-NOT not found (success, reported if -vv)\n"
+ << " - CHECK-DAG not found after discarded matches (error)\n"
+ << " - ";
+ WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";
+ OS << " marks fuzzy match when no match is found\n";
+
+ // Colors.
+ OS << " - colors ";
+ WithColor(OS, raw_ostream::GREEN, true) << "success";
+ OS << ", ";
+ WithColor(OS, raw_ostream::RED, true) << "error";
+ OS << ", ";
+ WithColor(OS, raw_ostream::MAGENTA, true) << "fuzzy match";
+ OS << ", ";
+ WithColor(OS, raw_ostream::CYAN, true, false) << "discarded match";
+ OS << ", ";
+ WithColor(OS, raw_ostream::CYAN, true, true) << "unmatched input";
+ OS << "\n\n"
+ << "If you are not seeing color above or in input dumps, try: -color\n";
+}
+
+/// An annotation for a single input line.
+struct InputAnnotation {
+ /// The check file line (one-origin indexing) where the directive that
+ /// produced this annotation is located.
+ unsigned CheckLine;
+ /// The index of the match result for this check.
+ unsigned CheckDiagIndex;
+ /// The label for this annotation.
+ std::string Label;
+ /// What input line (one-origin indexing) this annotation marks. This might
+ /// be different from the starting line of the original diagnostic if this is
+ /// a non-initial fragment of a diagnostic that has been broken across
+ /// multiple lines.
+ unsigned InputLine;
+ /// The column range (one-origin indexing, open end) in which to to mark the
+ /// input line. If InputEndCol is UINT_MAX, treat it as the last column
+ /// before the newline.
+ unsigned InputStartCol, InputEndCol;
+ /// The marker to use.
+ MarkerStyle Marker;
+ /// Whether this annotation represents a good match for an expected pattern.
+ bool FoundAndExpectedMatch;
+};
+
+/// Get an abbreviation for the check type.
+std::string GetCheckTypeAbbreviation(Check::FileCheckType Ty) {
+ switch (Ty) {
+ case Check::CheckPlain:
+ if (Ty.getCount() > 1)
+ return "count";
+ return "check";
+ case Check::CheckNext:
+ return "next";
+ case Check::CheckSame:
+ return "same";
+ case Check::CheckNot:
+ return "not";
+ case Check::CheckDAG:
+ return "dag";
+ case Check::CheckLabel:
+ return "label";
+ case Check::CheckEmpty:
+ return "empty";
+ case Check::CheckEOF:
+ return "eof";
+ case Check::CheckBadNot:
+ return "bad-not";
+ case Check::CheckBadCount:
+ return "bad-count";
+ case Check::CheckNone:
+ llvm_unreachable("invalid FileCheckType");
+ }
+ llvm_unreachable("unknown FileCheckType");
+}
+
+static void BuildInputAnnotations(const std::vector<FileCheckDiag> &Diags,
+ std::vector<InputAnnotation> &Annotations,
+ unsigned &LabelWidth) {
+ // How many diagnostics has the current check seen so far?
+ unsigned CheckDiagCount = 0;
+ // What's the widest label?
+ LabelWidth = 0;
+ for (auto DiagItr = Diags.begin(), DiagEnd = Diags.end(); DiagItr != DiagEnd;
+ ++DiagItr) {
+ InputAnnotation A;
+
+ // Build label, which uniquely identifies this check result.
+ A.CheckLine = DiagItr->CheckLine;
+ llvm::raw_string_ostream Label(A.Label);
+ Label << GetCheckTypeAbbreviation(DiagItr->CheckTy) << ":"
+ << DiagItr->CheckLine;
+ A.CheckDiagIndex = UINT_MAX;
+ auto DiagNext = std::next(DiagItr);
+ if (DiagNext != DiagEnd && DiagItr->CheckTy == DiagNext->CheckTy &&
+ DiagItr->CheckLine == DiagNext->CheckLine)
+ A.CheckDiagIndex = CheckDiagCount++;
+ else if (CheckDiagCount) {
+ A.CheckDiagIndex = CheckDiagCount;
+ CheckDiagCount = 0;
+ }
+ if (A.CheckDiagIndex != UINT_MAX)
+ Label << "'" << A.CheckDiagIndex;
+ else
+ A.CheckDiagIndex = 0;
+ Label.flush();
+ LabelWidth = std::max((std::string::size_type)LabelWidth, A.Label.size());
+
+ A.Marker = GetMarker(DiagItr->MatchTy);
+ A.FoundAndExpectedMatch =
+ DiagItr->MatchTy == FileCheckDiag::MatchFoundAndExpected;
+
+ // Compute the mark location, and break annotation into multiple
+ // annotations if it spans multiple lines.
+ A.InputLine = DiagItr->InputStartLine;
+ A.InputStartCol = DiagItr->InputStartCol;
+ if (DiagItr->InputStartLine == DiagItr->InputEndLine) {
+ // Sometimes ranges are empty in order to indicate a specific point, but
+ // that would mean nothing would be marked, so adjust the range to
+ // include the following character.
+ A.InputEndCol =
+ std::max(DiagItr->InputStartCol + 1, DiagItr->InputEndCol);
+ Annotations.push_back(A);
+ } else {
+ assert(DiagItr->InputStartLine < DiagItr->InputEndLine &&
+ "expected input range not to be inverted");
+ A.InputEndCol = UINT_MAX;
+ Annotations.push_back(A);
+ for (unsigned L = DiagItr->InputStartLine + 1, E = DiagItr->InputEndLine;
+ L <= E; ++L) {
+ // If a range ends before the first column on a line, then it has no
+ // characters on that line, so there's nothing to render.
+ if (DiagItr->InputEndCol == 1 && L == E)
+ break;
+ InputAnnotation B;
+ B.CheckLine = A.CheckLine;
+ B.CheckDiagIndex = A.CheckDiagIndex;
+ B.Label = A.Label;
+ B.InputLine = L;
+ B.Marker = A.Marker;
+ B.Marker.Lead = '~';
+ B.Marker.Note = "";
+ B.InputStartCol = 1;
+ if (L != E)
+ B.InputEndCol = UINT_MAX;
+ else
+ B.InputEndCol = DiagItr->InputEndCol;
+ B.FoundAndExpectedMatch = A.FoundAndExpectedMatch;
+ Annotations.push_back(B);
+ }
+ }
+ }
+}
+
+static void DumpAnnotatedInput(raw_ostream &OS, const FileCheckRequest &Req,
+ StringRef InputFileText,
+ std::vector<InputAnnotation> &Annotations,
+ unsigned LabelWidth) {
+ OS << "Full input was:\n<<<<<<\n";
+
+ // Sort annotations.
+ //
+ // First, sort in the order of input lines to make it easier to find relevant
+ // annotations while iterating input lines in the implementation below.
+ // FileCheck diagnostics are not always reported and recorded in the order of
+ // input lines due to, for example, CHECK-DAG and CHECK-NOT.
+ //
+ // Second, for annotations for the same input line, sort in the order of the
+ // FileCheck directive's line in the check file (where there's at most one
+ // directive per line) and then by the index of the match result for that
+ // directive. The rationale of this choice is that, for any input line, this
+ // sort establishes a total order of annotations that, with respect to match
+ // results, is consistent across multiple lines, thus making match results
+ // easier to track from one line to the next when they span multiple lines.
+ std::sort(Annotations.begin(), Annotations.end(),
+ [](const InputAnnotation &A, const InputAnnotation &B) {
+ if (A.InputLine != B.InputLine)
+ return A.InputLine < B.InputLine;
+ if (A.CheckLine != B.CheckLine)
+ return A.CheckLine < B.CheckLine;
+ // FIXME: Sometimes CHECK-LABEL reports its match twice with
+ // other diagnostics in between, and then diag index incrementing
+ // fails to work properly, and then this assert fails. We should
+ // suppress one of those diagnostics or do a better job of
+ // computing this index. For now, we just produce a redundant
+ // CHECK-LABEL annotation.
+ // assert(A.CheckDiagIndex != B.CheckDiagIndex &&
+ // "expected diagnostic indices to be unique within a "
+ // " check line");
+ return A.CheckDiagIndex < B.CheckDiagIndex;
+ });
+
+ // Compute the width of the label column.
+ const unsigned char *InputFilePtr = InputFileText.bytes_begin(),
+ *InputFileEnd = InputFileText.bytes_end();
+ unsigned LineCount = InputFileText.count('\n');
+ if (InputFileEnd[-1] != '\n')
+ ++LineCount;
+ unsigned LineNoWidth = std::log10(LineCount) + 1;
+ // +3 below adds spaces (1) to the left of the (right-aligned) line numbers
+ // on input lines and (2) to the right of the (left-aligned) labels on
+ // annotation lines so that input lines and annotation lines are more
+ // visually distinct. For example, the spaces on the annotation lines ensure
+ // that input line numbers and check directive line numbers never align
+ // horizontally. Those line numbers might not even be for the same file.
+ // One space would be enough to achieve that, but more makes it even easier
+ // to see.
+ LabelWidth = std::max(LabelWidth, LineNoWidth) + 3;
+
+ // Print annotated input lines.
+ auto AnnotationItr = Annotations.begin(), AnnotationEnd = Annotations.end();
+ for (unsigned Line = 1;
+ InputFilePtr != InputFileEnd || AnnotationItr != AnnotationEnd;
+ ++Line) {
+ const unsigned char *InputFileLine = InputFilePtr;
+
+ // Print right-aligned line number.
+ WithColor(OS, raw_ostream::BLACK, true)
+ << format_decimal(Line, LabelWidth) << ": ";
+
+ // For the case where -v and colors are enabled, find the annotations for
+ // good matches for expected patterns in order to highlight everything
+ // else in the line. There are no such annotations if -v is disabled.
+ std::vector<InputAnnotation> FoundAndExpectedMatches;
+ if (Req.Verbose && WithColor(OS).colorsEnabled()) {
+ for (auto I = AnnotationItr; I != AnnotationEnd && I->InputLine == Line;
+ ++I) {
+ if (I->FoundAndExpectedMatch)
+ FoundAndExpectedMatches.push_back(*I);
+ }
+ }
+
+ // Print numbered line with highlighting where there are no matches for
+ // expected patterns.
+ bool Newline = false;
+ {
+ WithColor COS(OS);
+ bool InMatch = false;
+ if (Req.Verbose)
+ COS.changeColor(raw_ostream::CYAN, true, true);
+ for (unsigned Col = 1; InputFilePtr != InputFileEnd && !Newline; ++Col) {
+ bool WasInMatch = InMatch;
+ InMatch = false;
+ for (auto M : FoundAndExpectedMatches) {
+ if (M.InputStartCol <= Col && Col < M.InputEndCol) {
+ InMatch = true;
+ break;
+ }
+ }
+ if (!WasInMatch && InMatch)
+ COS.resetColor();
+ else if (WasInMatch && !InMatch)
+ COS.changeColor(raw_ostream::CYAN, true, true);
+ if (*InputFilePtr == '\n')
+ Newline = true;
+ else
+ COS << *InputFilePtr;
+ ++InputFilePtr;
+ }
+ }
+ OS << '\n';
+ unsigned InputLineWidth = InputFilePtr - InputFileLine - Newline;
+
+ // Print any annotations.
+ while (AnnotationItr != AnnotationEnd &&
+ AnnotationItr->InputLine == Line) {
+ WithColor COS(OS, AnnotationItr->Marker.Color, true);
+ // The two spaces below are where the ": " appears on input lines.
+ COS << left_justify(AnnotationItr->Label, LabelWidth) << " ";
+ unsigned Col;
+ for (Col = 1; Col < AnnotationItr->InputStartCol; ++Col)
+ COS << ' ';
+ COS << AnnotationItr->Marker.Lead;
+ // If InputEndCol=UINT_MAX, stop at InputLineWidth.
+ for (++Col; Col < AnnotationItr->InputEndCol && Col <= InputLineWidth;
+ ++Col)
+ COS << '~';
+ const std::string &Note = AnnotationItr->Marker.Note;
+ if (!Note.empty()) {
+ // Put the note at the end of the input line. If we were to instead
+ // put the note right after the marker, subsequent annotations for the
+ // same input line might appear to mark this note instead of the input
+ // line.
+ for (; Col <= InputLineWidth; ++Col)
+ COS << ' ';
+ COS << ' ' << Note;
+ }
+ COS << '\n';
+ ++AnnotationItr;
+ }
+ }
+
+ OS << ">>>>>>\n";
+}
+
+int main(int argc, char **argv) {
+ // Enable use of ANSI color codes because FileCheck is using them to
+ // highlight text.
+ llvm::sys::Process::UseANSIEscapeCodes(true);
+
+ InitLLVM X(argc, argv);
+ cl::ParseCommandLineOptions(argc, argv, /*Overview*/ "", /*Errs*/ nullptr,
+ "FILECHECK_OPTS");
+ if (DumpInput == DumpInputHelp) {
+ DumpInputAnnotationHelp(outs());
+ return 0;
+ }
+ if (CheckFilename.empty()) {
+ errs() << "<check-file> not specified\n";
+ return 2;
+ }
+
+ FileCheckRequest Req;
+ for (auto Prefix : CheckPrefixes)
+ Req.CheckPrefixes.push_back(Prefix);
+
+ for (auto CheckNot : ImplicitCheckNot)
+ Req.ImplicitCheckNot.push_back(CheckNot);
+
+ bool GlobalDefineError = false;
+ for (auto G : GlobalDefines) {
+ size_t EqIdx = G.find('=');
+ if (EqIdx == std::string::npos) {
+ errs() << "Missing equal sign in command-line definition '-D" << G
+ << "'\n";
+ GlobalDefineError = true;
+ continue;
+ }
+ if (EqIdx == 0) {
+ errs() << "Missing variable name in command-line definition '-D" << G
+ << "'\n";
+ GlobalDefineError = true;
+ continue;
+ }
+ Req.GlobalDefines.push_back(G);
+ }
+ if (GlobalDefineError)
+ return 2;
+
+ Req.AllowEmptyInput = AllowEmptyInput;
+ Req.EnableVarScope = EnableVarScope;
+ Req.AllowDeprecatedDagOverlap = AllowDeprecatedDagOverlap;
+ Req.Verbose = Verbose;
+ Req.VerboseVerbose = VerboseVerbose;
+ Req.NoCanonicalizeWhiteSpace = NoCanonicalizeWhiteSpace;
+ Req.MatchFullLines = MatchFullLines;
+
+ if (VerboseVerbose)
+ Req.Verbose = true;
+
+ FileCheck FC(Req);
+ if (!FC.ValidateCheckPrefixes()) {
+ errs() << "Supplied check-prefix is invalid! Prefixes must be unique and "
+ "start with a letter and contain only alphanumeric characters, "
+ "hyphens and underscores\n";
+ return 2;
+ }
+
+ Regex PrefixRE = FC.buildCheckPrefixRegex();
+ std::string REError;
+ if (!PrefixRE.isValid(REError)) {
+ errs() << "Unable to combine check-prefix strings into a prefix regular "
+ "expression! This is likely a bug in FileCheck's verification of "
+ "the check-prefix strings. Regular expression parsing failed "
+ "with the following error: "
+ << REError << "\n";
+ return 2;
+ }
+
+ SourceMgr SM;
+
+ // Read the expected strings from the check file.
+ ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
+ MemoryBuffer::getFileOrSTDIN(CheckFilename);
+ if (std::error_code EC = CheckFileOrErr.getError()) {
+ errs() << "Could not open check file '" << CheckFilename
+ << "': " << EC.message() << '\n';
+ return 2;
+ }
+ MemoryBuffer &CheckFile = *CheckFileOrErr.get();
+
+ SmallString<4096> CheckFileBuffer;
+ StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);
+
+ SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
+ CheckFileText, CheckFile.getBufferIdentifier()),
+ SMLoc());
+
+ if (FC.readCheckFile(SM, CheckFileText, PrefixRE))
+ return 2;
+
+ // Open the file to check and add it to SourceMgr.
+ ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
+ MemoryBuffer::getFileOrSTDIN(InputFilename);
+ if (std::error_code EC = InputFileOrErr.getError()) {
+ errs() << "Could not open input file '" << InputFilename
+ << "': " << EC.message() << '\n';
+ return 2;
+ }
+ MemoryBuffer &InputFile = *InputFileOrErr.get();
+
+ if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) {
+ errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";
+ DumpCommandLine(argc, argv);
+ return 2;
+ }
+
+ SmallString<4096> InputFileBuffer;
+ StringRef InputFileText = FC.CanonicalizeFile(InputFile, InputFileBuffer);
+
+ SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
+ InputFileText, InputFile.getBufferIdentifier()),
+ SMLoc());
+
+ if (DumpInput == DumpInputDefault)
+ DumpInput = DumpInputOnFailure ? DumpInputFail : DumpInputNever;
+
+ std::vector<FileCheckDiag> Diags;
+ int ExitCode = FC.checkInput(SM, InputFileText,
+ DumpInput == DumpInputNever ? nullptr : &Diags)
+ ? EXIT_SUCCESS
+ : 1;
+ if (DumpInput == DumpInputAlways ||
+ (ExitCode == 1 && DumpInput == DumpInputFail)) {
+ errs() << "\n"
+ << "Input file: "
+ << (InputFilename == "-" ? "<stdin>" : InputFilename.getValue())
+ << "\n"
+ << "Check file: " << CheckFilename << "\n"
+ << "\n"
+ << "-dump-input=help describes the format of the following dump.\n"
+ << "\n";
+ std::vector<InputAnnotation> Annotations;
+ unsigned LabelWidth;
+ BuildInputAnnotations(Diags, Annotations, LabelWidth);
+ DumpAnnotatedInput(errs(), Req, InputFileText, Annotations, LabelWidth);
+ }
+
+ return ExitCode;
+}
projects / llvm / commitdiff