FileCheck Enhancement - pattern templates.

[eklepilkina]

Summary

This patch adds opportunity to describe some patterns as named template with or without parameters by using new directive CHECK-PATTERN.

[eklepilkina]

I'll glad if there will be some suggestions how make syntax better. The main idea of this syntax was to use characters with \ for avoiding escaping these characters in standart patterns.

[vsk]

This looks very useful!

My first round of comments do not really address the correctness of this patch (although I do think I found one correctness issue). Please clang-format the diff and upload a diff with more context (e.g git diff -U1000 ...). I can take a closer look once these issues are fixed up :).

test/FileCheck/check-pattern.txt

12

What are the exact semantics of "\:", "\#", and "\=" in the CHECK-PATTERN and CHECK contexts? Please document this and add the documentation to this patch.

I think I have "\#" figured out, but "\:" is confusing (does it make a captured word available via the specified label?). I can't really work out exactly what "\=" is doing -- I'd rather have a spec before picking through the patch :).

13

Could you add a test that shows this behaves properly when different prefixes are in use? E.g;

// RUN: FileCheck -input-file %s %s -check-prefix=FOO
// RUN: FileCheck -input-file %s %s -check-prefix=BAR

// FOO-PATTERN thing: foo-thing
// BAR-PATTERN thing: bar-thing

foo-thing
bar-thing

// FOO: {{\:(thing)}}
// BAR: {{\:(thing)}}

utils/FileCheck/FileCheck.cpp

136

Needs a doxygen comment.

220

I suggest calling this "getNumParameters", and dropping the redundant "\return" doxygen line.

241

Typo, "Parameter". The same typo occurs elsewhere in the diff.

247

Use emplace.

255

Return a StringRef or a const std::string &.

260

Use llvm::SmallSet.

261

I think braces around single-statement loops are usually dropped.

286

Instead of repeatedly re-writing Regex, I suggest creating a SmallVector of expression components and then doing llvm::join(Components).

290

This looks like you're setting yourself up for a use-after-free. This should return a std::string.

295

Avoid static class members.

311

Avoid globals. Also, use a llvm::StringMap<PatternTemplate*> here.

326

NULL is discouraged, use nullptr.

Also, this does 2 table lookups but only needs to do one. E.g something like;

const auto PatternIT = Templates.find(TemplateName);
if (PatternIT == Templates.end())
  return nullptr;
return *PatternIT;

823

Could you elaborate?

[eklepilkina]

test/FileCheck/check-pattern.txt

13

Thank you for this test! There was no problem with prefixes, but was problem with fixed strings instead of patterns. I fixed it.

[eklepilkina]

utils/FileCheck/FileCheck.cpp

823

This means that there may be used described before template as variable.

[aprantl]

docs/CommandGuide/FileCheck.rst

494

The CHECK-PATTERN directive is only mentioned in examples but never defined properly.

542

The new syntax should be introduced before the examples. This makes it easier to look up the syntax when you use the document as a reference.

[aprantl]

A couple of general remarks about the proposed syntax:

Using CHECK-lines to define meta-variables without checking anything diverges from FileCheck's usual behavior. I find the name CHECK-PATTERN (I know that CHECK can be renamed, but still) particularly misleading and confusing. I would expect something more like CHECK-DEFINE-PATTERN or even passing the patterns to FileCheck on the command line instead.

The syntax of \#, #:, \= is different from what we usually have in FileCheck where we usually use double-brackets "[[" to escape. Why is it so different? Is this borrowed from some other language that users can be expected to have some familiarity with?

docs/CommandGuide/FileCheck.rst

529

I don't understand this example. Is it really equivalent to the next example as claimed in the text, or does it have side-effects? If so, what are the side-effects?

[vsk]

More mostly surface-level comments. I think Adrian and I both have concerns over the syntax, so I'll wait a bit before diving into the code.

docs/CommandGuide/FileCheck.rst

522

mane -> many

529

Is the extra space in \#( reg_hex_num) necessary? I don't want to be too picky / focused on minutiae, but I think this could legitimately be a point of confusion.

529

Have you considered changing the syntax for parameter substitution? IMO \:(regName)\=(reg) has two problems: (1) it uses two separate syntactic constructs to do one thing, and (2) it overloads \:, making its meaning context-dependent. I suggest something like this: \=(regName:reg).

540

Specify whether or not this can occur in a CHECK-PATTERN line.

test/FileCheck/check-pattern-prefixes.txt

3 ↗

(On Diff #64480)

Check for conflicting parameter definitions:

// RUN: not FileCheck -input-file %s %s -check-prefixes=FOO,BAR

utils/FileCheck/FileCheck.cpp

139

Should return a StringRef. If the caller needs a mutable copy, it can then do: getRegExStr().str().

142

Ditto, return a StringRef (avoids a copy).

196

Since there is only one in-out parameter here, I think the API would be clearer as:

Expected<std::string> ReplaceTemplates(StringRef Str, SourceMgr &SM) (see llvm/Support/Error.h)

205

Use llvm/ADT/IndexedMap.h.

208

StringRef Name

214

Can drop StringReg(...) if getRegExStr() returns a StringRef.

222

Could you drop the \return doxygen line here? I don't think it adds very much.

275

Use std::unique_ptr<PatternTemplate>.

283

Can you find a way to instantiate a TemplatesCollection earlier, and to then pass it by reference into methods/classes which need it? I don't think a singleton approach is much better than having a global.

289

StringRef's are by nature already references. There's no need to pass them by-reference, just copy them.

1114

Use llvm::make_unique<PatternTemplate>.

[eklepilkina]

In D22403#488644, @aprantl wrote:

Using CHECK-lines to define meta-variables without checking anything diverges from FileCheck's usual behavior.

Execuse me, but I didn't understand what do you mean. FileCheck variables are defined in check strings too. And about "without checking": there is checking of earlier definition of this pattern. What do you want to check more?

I would expect something more like CHECK-DEFINE-PATTERN

There is no problem to rename.

or even passing the patterns to FileCheck on the command line instead.

There may be a lot of patterns. Do you mean passing file with patterns?

The syntax of \#, #:, \= is different from what we usually have in FileCheck where we usually use double-brackets "[[" to escape. Why is it so different? Is this borrowed from some other language that users can be expected to have some familiarity with?

This syntax was based on simple regular expressions where \ is escaping character. Syntax is a difficult question. Do you suggest using something like #pattern_name, [[:variable_name]], [[=variable_value]]?
I don't know how users will be better so I would like to know more opinions.

[eklepilkina]

docs/CommandGuide/FileCheck.rst

529

Ok. I'll change syntax when there is one decision, because there are more suggestions about changing it.

utils/FileCheck/FileCheck.cpp

205

"The index map template takes two types. The first is the mapped type and the second is a functor that maps its argument to a size_t.".
I need to remember variable position in string. As I uderstood functor should have constructor without parameters, but if I write functor it should have field with position. I can't define position using only parameter name.

[eklepilkina]

docs/CommandGuide/FileCheck.rst

529

There was extra space. Without it, test is equivalen.

test/FileCheck/check-pattern-prefixes.txt

3 ↗

(On Diff #64480)

Why should it fail? There will be warning that template with same name exists. And pattern will be assosiated with foo-thing.

utils/FileCheck/FileCheck.cpp

283

If I do so a lot of functions will get one more parameter although many functions will only pass this parameter further. Most of these functions get quite big number of parameters now.

[eklepilkina]

About syntax.
There is an idea to do as you advised.
Suggested new syntax:
[['#template_name]] - use of template 'template_name'. It can occur in CHECK-PATTERN line, when description of one template includes other templates described before. (Without quote, I don't know how escape # here)
[[:Variable_name]] - template variable with name 'variable_name'
[[:variable_name=value]] - current value of template variable(it's needed when you use template with variables).
Is this syntax better? Should I do such way?

[aprantl]

In D22403#489690, @eklepilkina wrote:

About syntax.
There is an idea to do as you advised.
Suggested new syntax:
[['#template_name]] - use of template 'template_name'. It can occur in CHECK-PATTERN line, when description of one template includes other templates described before. (Without quote, I don't know how escape # here)
[[:Variable_name]] - template variable with name 'variable_name'
[[:variable_name=value]] - current value of template variable(it's needed when you use template with variables).
Is this syntax better? Should I do such way?

Let me start off by saying thanks for working on this!

For reference, here is what I remember the syntax of FileCheck CHECK-lines to be currently:

ACTION <- CHECK ':' MATCH '\n' ;
MATCH <- ;
MATCH <- TEXT MATCH ;
MATCH <- REGEX MATCH ;
MATCH <- VAR MATCH ;
REGEX <- '{{' POSIX_REGEX '}}' ;
VAR <- '[[' IDENT ':' POSIX_REGEX ']]' ;
VAR <- '[[' IDENT ']]' ;

Is there a benefit in (or need for) distinguishing between variable uses and pattern uses, or could we piggyback the existing syntax?

As for pattern variables, I really think this review would benefit if we could split out pattern variables into a separate review. I didn't yet understand how pattern variables are supposed to work: Is \:(variable)\=(value) supposed to be an argument to a pattern use that immediately precedes it? Or is it modifying global state similar to regular variable definition in FileCheck? If the latter is the case, why does it come after the pattern in the example? In the former case, wouldn't it be better to have syntax that looks more like passing in an argument?

[eklepilkina]

In D22403#489895, @aprantl wrote:

Is there a benefit in (or need for) distinguishing between variable uses and pattern uses, or could we piggyback the existing syntax?

There is difference between patterns and variables so we should understand where variable is, where pattern is.

As for pattern variables, I really think this review would benefit if we could split out pattern variables into a separate review. I didn't yet understand how pattern variables are supposed to work: Is \:(variable)\=(value) supposed to be an argument to a pattern use that immediately precedes it? Or is it modifying global state similar to regular variable definition in FileCheck? If the latter is the case, why does it come after the pattern in the example? In the former case, wouldn't it be better to have syntax that looks more like passing in an argument?

I a bit misuderstand how can I split out pattern variables into a separate review, because this review need all these changes. We can't use pattern variable without patterns, so separate review will duplicate part of changes of pattern review.
Pattren variables supposed to help create one pattern when you have a lot of similar checks.
For example

CHECK-DEFINE-PATTERN reg: {{\:(RegName)0x[0-9a-fA-F]+}}

This is pattern for defining register, and name is parameter. Template is saved in such way.
Then you can use it.
CHECK: {{\#(reg)\:(RegName)\=(REG)}}
When you write such check, FileCheck will replace it with template where variable name is changed to it's value. Variable name is some kind of named spaceholder.
The previous check-line will be equivalent to
CHECK: {{REG0x[0-9a-fA-F]+}}
We should have difference between pattern variable and global variables because we can use global variable in pattern or as value of pattern variable.

[aprantl]

In D22403#490814, @eklepilkina wrote:

In D22403#489895, @aprantl wrote:

Is there a benefit in (or need for) distinguishing between variable uses and pattern uses, or could we piggyback the existing syntax?

There is difference between patterns and variables so we should understand where variable is, where pattern is.

They are also both placeholders for a pattern. Can you give an example where it is useful to tell the difference between a use of a pattern and a use of a plain old variable? Does it make the test more readable?
I'm not saying that we have to share the syntax, but adding more syntax increases the cognitive load on testcase authors and we should make sure we are doing it for the right reasons.

As for pattern variables, I really think this review would benefit if we could split out pattern variables into a separate review.

I a bit misuderstand how can I split out pattern variables into a separate review, because this review need all these changes.

If you feel like splitting out the pattern variables into a separate review ins't feasible that's fine with me.

Could you please answer the following questions specifically?

I didn't yet understand how pattern variables are supposed to work: Is \:(variable)\=(value) supposed to be an argument to a pattern use that immediately precedes it? Or is it modifying global state similar to regular variable definition in FileCheck? If the latter is the case, why does it come after the pattern in the example? In the former case, wouldn't it be better to have syntax that looks more like passing in an argument?

Pattren variables supposed to help create one pattern when you have a lot of similar checks.
For example

CHECK-DEFINE-PATTERN reg: {{\:(RegName)0x[0-9a-fA-F]+}}

This is pattern for defining register, and name is parameter. Template is saved in such way.
Then you can use it.
// CHECK: {{\#(reg)\:(RegName)\=(REG)}}
When you write such check, FileCheck will replace it with template where variable name is changed to it's value. Variable name is some kind of named spaceholder.

In the documentation the example showed a pattern use on its own, here it appears inside of a regexp. To make sure I understand the proposal correctly :-) it might help if you could add your new syntax to the grammar I posted earlier.

thanks!
adrian

[eklepilkina]

In D22403#491468, @aprantl wrote:

They are also both placeholders for a pattern. Can you give an example where it is useful to tell the difference between a use of a pattern and a use of a plain old variable? Does it make the test more readable?
I'm not saying that we have to share the syntax, but adding more syntax increases the cognitive load on testcase authors and we should make sure we are doing it for the right reasons.

Firstly, variables should be defined in some check-line. So we can't create variables separately. In case of patterns you can create a lot of frequently used patterns once (for example in separate file and then include this file where you need (see patch https://reviews.llvm.org/D22500)). Moreover pattern can have their own variables.

I didn't yet understand how pattern variables are supposed to work: Is \:(variable)\=(value) supposed to be an argument to a pattern use that immediately precedes it? Or is it modifying global state similar to regular variable definition in FileCheck?

Variables are arguments. I don't understand what the global state do you mean.

If the latter is the case, why does it come after the pattern in the example? In the former case, wouldn't it be better to have syntax that looks more like passing in an argument?

Do you mean something like \#pattern(a, b)? Or what? There is no order of variables during defining it. One variable can be used in pattern several times in different places. I just need variable name to find place in pattern and its value.

In the documentation the example showed a pattern use on its own, here it appears inside of a regexp. To make sure I understand the proposal correctly :-)

Yes, I have a mistake in documentation. Now pattern can be used only in regular expressions. But if we change syntax to use [[ ]], I'll can add possible use of them in fixed strings in line-checks.

it might help if you could add your new syntax to the grammar I posted earlier.

Syntax as is now.

ACTION <- CHECK-DEFINE-PATTERN IDENT ':' MATCH '\n' ;
ACTION <- CHECK-DEFINE-PATTERN IDENT ':' REGEX_DEF '\n' ;
PATTERN_VAR <-;
PATTERN_VAR <-' \:('IDENT')';
REGEX_VARS <- POSIX_REGEX;
REGEX_VARS <- REGEX_VARS PATTERN_VAR REGEX_VARS;
REGEX_DEF <- '{{' REGEX_VARS '}}';
VAR_VALUE <-;
VAR_VALUE <- '\:('IDENT')\=('TEXT')' VAR_VALUE;
PATTERN_USE <- POSIX_REGEX;
PATTERN_USE <- POSIX_REGEX '\#('IDENT')'VAR_VALUE PATTERN_USE;
REGEX <- '{{' PATTERN_USE '}}';

[eklepilkina]

Change syntax to new one suggested by Vedant Kumar.

ACTION <- CHECK ':' MATCH '\n' ;

ACTION <- CHECK-DEFINE-PATTERN ':' IDENT PARAMLIST? ':' PATTERN_ELEMENT* '\n' ;
PARAMLIST <- '(' IDENT (',' IDENT)* ')' ;
PATTERN_ELEMENT <- IDENT | REGEX;
MATCH <- (TEXT | REGEX | PATTERN_USE | VAR)* ;
REGEX <- '{{' POSIX_REGEX '}}' ;
PATTERN_USE <- '[[' '@' IDENT  ARGLIST? ']]' ;
VAR <- '[[' IDENT ':' POSIX_REGEX ']]' ;
VAR <- '[[' IDENT '@' IDENT ARGLIST? ']]' ;
ARGLIST <- '(' ARG (',' ARG)* ')' ;
ARG <- "([^"]|\\")*" ;

[vsk]

I've added a few comments inline which I hope will be useful. However, after looking this patch over a few times, I've found that it's too large for me to review constructively.

The main issue is that the grammar you've implemented doesn't correspond to the one we discussed. E.g your PATTERN_ELEMENT includes PATTERN_USE, and your ARG is not handled correctly. I don't want to say "no" to new features, but I would much rather have them land incrementally, with more testing for edge-cases and more documentation. Can you scale back this patch to just cover these new bits of the grammar?

ACTION <- CHECK-DEFINE-PATTERN ':' IDENT ':' PATTERN_ELEMENT* '\n' ;
PATTERN_ELEMENT <- IDENT | REGEX;
MATCH <- PATTERN_USE ;
PATTERN_USE <- '[[' '@' IDENT ']]' ;
VAR <- '[[' IDENT '@' IDENT ']]' ;

docs/CommandGuide/FileCheck.rst

488

Please use the same formatting rules as the rest of this document. Can you trim the twiddles ("~~~") to match the section name's length and line-wrap text that isn't in a code block?

495

Please summarize the new syntax in the paragraph above, and use small examples here instead.

test/FileCheck/check-pattern.txt

34

Add tests for:

1. All error messages you've introduced
2. Allow -check-prefix=FOO, FOO-DEFINE-PATTERN
3. Disallow BAR-DEFINE-PATTERN and FOO-DEFINE-PATTERN for the same definition name
4. Capture '@LINE' in a variable
5. Disallow using a pattern captured with a FOO-definition in a BAR check
6. Verify CHECK-{NEXT, SAME, DAG} etc. work with captured patterns

[eklepilkina]

Are quotes necessary for parameters? Everything is string in FileCheck.
Using patterns and variables was in old grammer. I thought that we only change syntax, so I added this feature too.
Ok, I'll remove this from this patch. But then I want to add using patterns and variables in definitions later. On my opinion these features are quite useful.

[vsk]

In D22403#539395, @eklepilkina wrote:

Are quotes necessary for parameters? Everything is string in FileCheck.

Yes, the quotes are necessary. Without them the grammar is ambiguous. Consider the string '@foo(a, b)'. Is there just one argument to foo (the string "a, b"), or are there two arguments ("a" and "b")?

Using patterns and variables was in old grammer. I thought that we only change syntax, so I added this feature too.
Ok, I'll remove this from this patch. But then I want to add using patterns and variables in definitions later. On my opinion these features are quite useful.

Sounds great :).

[eklepilkina]

test/FileCheck/check-pattern.txt

34

Capture '@LINE' in a variable

I don't understand what do you mean. How can I do this? CHECK: [[Number: [[@LINE]]]]?
Or do you mean text '@LINE'?

[eklepilkina]

Patch without modifiers for pattern parameters and using pattern and variables inside definition of other patterns.

[alexfh]

IIUC, there was no consensus about usefulness of this change.

docs/CommandGuide/FileCheck.rst

 
 .. code-block:: llvm
 
        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``".
+
+Templates
+~~~~~~~~~
+
+Some regular expressions are used very often. In this case directive for describing template 
+of regular expression may be used.
+
+Templates syntax:
+
+CHECK-DEFINE-PATTERN: [name of describing template]: [pattern of template] - directive to define pattern.
+
+
+CHECK-DEFINE-PATTERN directive is used for describing templates.
+
+ .. code-block:: c++
+
+    // CHECK-DEFINE-PATTERN: [name of describing template]: [pattern of template]
+    // CHECK-DEFINE-PATTERN: [name of describing template][list of parameters]: [pattern of template]
+
+For example
+
+.. code-block:: c++
+
+    // CHECK-DEFINE-PATTERN: hex_num: {{0x[0-9a-fA-F]+}}
+
+This directive only describes template and doesn’t match anything.
+
+Pattern of template should be a regular expression and should be writen as {{regex}}.
+
+Templates can have parameters for cases when there is same part, but also there are always 
+some changing parts. Parameters should be set in round brackets after name of pattern.
+For example, register(RegName). regName is parameter name. It will be placed by it's value 
+which should be defined in check string. There can be many parameters and parameters can be
+used some times in different parts of template.Parameters in pattern definition are all 
+words outside {{ }}.
+
+.. code-block:: c++
+
+  // CHECK-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+
+After describing new template it’s possible to use this regular expression by its template 
+name in any directive CHECK, CHECK-NEXT, CHECK-SAME  and etc.
+
+[[@pattern_name(param1, ..., paramN)]] - usage of pattern. If pattern doesn't have parameters,
+brackets aren't necessery.
+
+[[variable_name @pattern_name(param1, ..., paramN)]] - expression to capture pattern match value
+into variable.
+
+For example
+
+.. code-block:: c++
+
+    // CHECK :  reg[@hex_num]
+
+This check is equal to 
+
+.. code-block:: c++
+
+    // CHECK :  reg{{0x[0-9a-fA-F]+}}
+
+
+To use templates with parameters you need to set values for each parameter.
+
+Example
+
+.. code-block:: c++
+
+    // CHECK :  INC  [@reg_hex_num(reg)]
+
+This is equal to 
+
+.. code-block:: c++
+
+    // CHECK :  INC  reg{{0x[0-9a-fA-F]+}}
+
+Parameters are useful if there are a lot of similar checks in file.
 No newline at end of file

test/FileCheck/check-pattern.txt

+// RUN: FileCheck -input-file %s %s
+
+op0xA1;
+op0xc2;
+op0x33;
+// CHECK-DEFINE-PATTERN: hex_num: {{0x[0-9a-fA-F]+}}
+// CHECK-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// CHECK-DEFINE-PATTERN: operation(OpName): OpName{{ }}
+// CHECK-DEFINE-PATTERN: inc(VarName, Number): VarName{{ = }}VarName{{\+}}Number
+// CHECK-DEFINE-PATTERN: alt: {{x|y}}
+// CHECK-DEFINE-PATTERN: altincheck: {{check }}{{x|y}}
+
+// CHECK: op[[@hex_num]];
+reg0x0
+// CHECK: [[@reg("reg")]]
+
+ADD r0xA, reg0x10
+// CHECK: [[@operation("ADD")]][[@reg("r")]]{{, }}[[@reg("reg")]]
+
+TEMP = TEMP+4
+// CHECK: [[@inc("TEMP", "4")]]
+
+check y
+// CHECK: [[@altincheck]]
+
+SUB r0xA, reg0x10
+// CHECK: [[sub @operation("SUB")]]
+
+SUB r0xA, reg0x10
+// CHECK: [[sub]]
+
+test.cpp:33:6: error: expected ';' after top level declarator
+// CHECK: test.cpp:[[@LINE]]:6: error: expected ';' after top level declarator
 No newline at end of file

test/FileCheck/check-patterns-prefixes.txt

+// RUN: FileCheck -check-prefix=FOO -input-file %s %s
+
+// FOO-DEFINE-PATTERN: hex_num: {{0x[0-9a-fA-F]+}}
+// FOO-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// FOO-DEFINE-PATTERN: inc(VarName, Number): VarName{{ = }}VarName{{\+}}Number
+// FOO-DEFINE-PATTERN: block: {{block #[0-9]+}}
+
+block #2
+bar
+op0x33 0xA1;
+
+something
+
+TEMP = TEMP+4
+
+block #1
+T = T+2
+r0xFF;
+register0x2B;
+
+// FOO-LABEL: [[@block]]
+// FOO: bar
+// FOO-NEXT: op[[@hex_num]]
+// FOO-SAME: [[@hex_num]];
+// FOO-NOT: [[@reg("reg")]]
+// FOO: [[@inc("TEMP", "4")]]
+// FOO-LABEL: [[@block]]
+// FOO-DAG: [[@reg("r")]]
+// FOO-DAG: [[@reg("register")]]
+// FOO-DAG: [[@inc("T", "2")]]
 No newline at end of file

test/FileCheck/pattern-errors.txt

+// RUN: not FileCheck -check-prefix=NOT_DECLARED -input-file %s %s 2>&1 | FileCheck -check-prefix=NOT_DECLARED_CHECK %s
+// RUN: not FileCheck -check-prefix=NOT_STRING -input-file %s %s 2>&1 | FileCheck -check-prefix=NOT_STRING_CHECK %s
+// RUN: not FileCheck -check-prefix=NO_CLOSE -input-file %s %s 2>&1 | FileCheck -check-prefix=NO_CLOSE_CHECK %s
+// RUN: not FileCheck -check-prefix=EXTRA -input-file %s %s 2>&1 | FileCheck -check-prefix=EXTRA_CHECK %s
+// RUN: not FileCheck -check-prefix=PARAM_NUMBER -input-file %s %s 2>&1 | FileCheck -check-prefix=PARAM_NUMBER_CHECK %s
+// RUN: not FileCheck -check-prefix=REPEATED_NAME -input-file %s %s 2>&1 | FileCheck -check-prefix=REPEATED_NAME_CHECK %s
+// RUN: not FileCheck -check-prefix=WITHOUT_NAME -input-file %s %s 2>&1 | FileCheck -check-prefix=WITHOUT_NAME_CHECK %s
+// RUN: not FileCheck -check-prefix=UNDECLARED_PARAM -input-file %s %s 2>&1 | FileCheck -check-prefix=UNDECLARED_PARAM_CHECK %s
+// RUN: not FileCheck -check-prefix=REPEATED_PARAM -input-file %s %s 2>&1 | FileCheck -check-prefix=REPEATED_PARAM_CHECK %s
+
+// NOT_DECLARED: [[@sometemplate]]
+// NOT_DECLARED_CHECK: {{template sometemplate wasn't declared}}
+
+// NOT_STRING-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// NOT_STRING: [[@reg(reg)]]
+// NOT_STRING_CHECK:{{Pattern parameter should be quoted string}}
+
+// NO_CLOSE-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// NO_CLOSE: [[@reg("reg)]]
+// NO_CLOSE_CHECK:{{No close quote}}
+
+// EXTRA-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// EXTRA: [[@reg("reg"###)]]
+// EXTRA_CHECK:{{Extra characters in parameters list}}
+
+// PARAM_NUMBER-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// PARAM_NUMBER: [[@reg("reg", "extra")]]
+// PARAM_NUMBER_CHECK:{{Number of declared parameters differs from necessary}}
+
+// REPEATED_NAME-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// REPEATED_NAME-DEFINE-PATTERN: reg: {{0x[0-9a-fA-F]+}}
+// REPEATED_NAME_CHECK: {{the template name reg is already used}}
+
+// WITHOUT_NAME-DEFINE-PATTERN: (RegName): RegName{{0x[0-9a-fA-F]+}}
+// WITHOUT_NAME_CHECK: {{No name was defined for pattern}}
+
+// UNDECLARED_PARAM-DEFINE-PATTERN: reg: RegName{{0x[0-9a-fA-F]+}}
+// UNDECLARED_PARAM_CHECK: {{Parameter RegName wasn't declared}}
+
+// REPEATED_PARAM-DEFINE-PATTERN: reg(RegName, RegName): RegName{{0x[0-9a-fA-F]+}}
+// REPEATED_PARAM_CHECK: {{Parameter RegName is repeated}}
 No newline at end of file

test/FileCheck/pattern-usage-with-another-prefix.txt

+// RUN: not FileCheck -input-file %s %s -check-prefix=FOO -check-prefix=BAR 2>&1 | FileCheck %s
+
+
+// FOO-DEFINE-PATTERN: hex_num: {{0x[0-9a-fA-F]+}}
+// BAR-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// FOO-DEFINE-PATTERN: inc(VarName, Number): VarName{{ = }}VarName{{\+}}Number
+
+op0x33;
+// FOO: op[[@hex_num]];
+reg0x0
+// BAR: [[@reg("reg")]]
+
+TEMP = TEMP+4
+// BAR: [[@inc("TEMP", "4")]]
+// CHECK: {{template inc wasn't declared}}
 No newline at end of file

test/FileCheck/repeated-pattern-with-another-prefix.txt

+// RUN: not FileCheck -input-file %s %s -check-prefix=FOO -check-prefix=BAR 2>&1 | FileCheck -check-prefix=BAR %s
+
+// FOO-DEFINE-PATTERN: hex_num: {{0x[0-9a-fA-F]+}}
+// BAR-DEFINE-PATTERN: reg(RegName): RegName{{0x[0-9a-fA-F]+}}
+// FOO-DEFINE-PATTERN: inc(VarName, Number): VarName{{ = }}VarName{{\+}}Number
+// BAR-DEFINE-PATTERN: inc(VarName): VarName{{ = }}VarName
+
+// BAR: {{the template name inc is already used}}
+// BAR: {{BAR-DEFINE-PATTERN: inc\(VarName\)}}
 No newline at end of file

utils/FileCheck/FileCheck.cpp

 // contains the expected content.  This is useful for regression tests etc.
 //
 // This program exits with an error 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/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
namespace Check {
   enum CheckType {
     CheckNone = 0,
     CheckPlain,
     CheckNext,
     CheckSame,
     CheckNot,
     CheckDAG,
     CheckLabel,
+    CheckPattern,
 
     /// MatchEOF - When set, this pattern only matches the end of file. This is
     /// used for trailing CHECK-NOTs.
     CheckEOF,
     /// CheckBadNot - Found -NOT combined with another CHECK suffix.
     CheckBadNot
   };
 }
class Pattern {
   std::map<StringRef, unsigned> VariableDefs;
 
 public:
 
   Pattern(Check::CheckType Ty)
     : CheckTy(Ty) { }
 
   /// getLoc - Return the location in source code.
   SMLoc getLoc() const { return PatternLoc; }
 
+  /// getRegExStr - Return regex pattern.
+  StringRef getRegExStr() const { return StringRef(RegExStr); }
+
+  /// getFixedStr - Return fixed string.
+  StringRef getFixedStr() const { return FixedStr; }
+
   /// ParsePattern - Parse the given string into the Pattern. Prefix provides
   /// which prefix is being matched, SM provides the SourceMgr used for error
   /// reports, and LineNumber is the line number in the input file from which
   /// the pattern string was read.  Returns true in case of an error, false
   /// otherwise.
   bool ParsePattern(StringRef PatternStr,
                     StringRef Prefix,
                     SourceMgr &SM,
private:
   bool EvaluateExpression(StringRef Expr, std::string &Value) const;
 
   /// \brief Finds the closing sequence of a regex variable usage or
   /// definition. Str has to point in the beginning of the definition
   /// (right after the opening sequence).
   /// \return offset of the closing sequence within Str, or npos if it was not
   /// found.
   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
+
+  /// Replace templates if they are to associated with them regular expressions.
+  /// \return regular expression with replaced templates
+  Expected<std::string> ReplaceTemplates(StringRef TemplateName,
+                                         StringRef& Buffer, const StringRef Prefix, 
+                                         SourceMgr &SM);
+  /// Add defined variable.
+  bool AddVariable(StringRef Name, unsigned &CurParen, SourceMgr &SM,
+                   StringRef AddedRegex);
+};
+
+class PatternTemplate {
+  /// Name of template.
+  std::string TemplateName;
+  std::string TemplatePrefix;
+  /// Pattern which describes this template.
+  Pattern TemplatePattern;
+
+  SmallVector<StringRef, 8> DeclaredParameters;
+  /// Template parameters.
+  std::map<size_t, std::string> Parameters;
+
+
+public:
+  PatternTemplate(StringRef Name, StringRef Prefix,
+                  Check::CheckType Ty = Check::CheckType::CheckNone)
+      : TemplateName(Name.str()), TemplatePrefix(Prefix.str()), 
+        TemplatePattern(Pattern(Ty)) {}
+
+  PatternTemplate(Check::CheckType Ty = Check::CheckType::CheckNone)
+      : TemplatePattern(Pattern(Ty)) {}
+
+  /// Parse the given string for getting parameters of template.
+  /// \return true if string has error in description regular expression or
+  /// parameters.
+  bool ParseTemplate(StringRef TemplateString, StringRef Prefix, SourceMgr &SM,
+                     unsigned LineNumber);
+
+  /// Parse list of template parameters.
+  bool ParseParameters(StringRef ParametersList, SourceMgr &SM,
+                       StringRef Buffer);
+
+  /// Get template name.
+  const std::string &GetTemplateName() const;
+
+  bool DefinedForPrefix(const StringRef Prefix) const;
+
+  /// Get number of parameters which this template includes.
+  size_t getNumParameters() const;
+
+  /// Checks if this template has such parameter
+  /// \return true if template has.
+  bool HasParameter(StringRef ParameterName) const;
+
+  /// Generate result regular expression for matching with inserted parameters
+  /// values.
+  std::string GetRegularExpression(SmallVectorImpl<StringRef> &Values) const;
+
+  const Pattern *GetTemplatePattern() const { return &TemplatePattern; }
+};
+
+bool PatternTemplate::ParseTemplate(StringRef TemplateString, StringRef Prefix,
+                                    SourceMgr &SM, unsigned LineNumber) {
+  size_t NewLine = TemplateString.find_first_of("\n");
+  size_t CurPos = 0;
+  size_t NewPos = 0;
+  size_t DiffInLoc = 0;
+  bool IsOpen = false;
+  unsigned PatternsCount = 0;
+  while (CurPos < NewLine) {
+    if (!IsOpen) {
+      NewPos = TemplateString.find("{{", CurPos);
+      // Get substring with parameters.
+      if (CurPos < NewLine) {
+        IsOpen = true;
+        StringRef ParametersUsage = TemplateString.slice(CurPos, NewPos);
+        // Parse parameters.
+        SmallVector<StringRef, 2> Params;
+        bool FirstParam = true;
+        ParametersUsage.split(Params, ' ');
+        for (const auto &Param : Params) {
+          if (!Param.empty()) {
+            // Check if parameters was declared.
+            if (!HasParameter(Param)) {
+              SM.PrintMessage(SMLoc::getFromPointer(TemplateString.data() +
+                                                    CurPos + DiffInLoc),
+                              SourceMgr::DK_Error,
+                              "Parameter " + Param + " wasn't declared");
+              return true;
+            }
+
+            Parameters.emplace(CurPos + DiffInLoc - PatternsCount * 2,
+                               Param.str());
+          }
+          if (!FirstParam) {
+            DiffInLoc++;
+          }
+          FirstParam = false;
+        }
+      }
+    } else {
+      NewPos = TemplateString.find_first_of("}}", CurPos) + 2;
+      IsOpen = false;
+      PatternsCount++;
+    }
+    CurPos = NewPos;
+  }
+
+  if (TemplatePattern.ParsePattern(TemplateString, Prefix, SM, LineNumber))
+    return true;
+
+  return false;
+}
+
+bool PatternTemplate::ParseParameters(StringRef ParametersList, SourceMgr &SM, 
+                                      StringRef Buffer) {
+  std::set<StringRef> UniqueParameters;
+  if (ParametersList.empty())
+    return false;
+  ParametersList.split(DeclaredParameters, ',');
+
+  // Remove extra spaces.
+  for (auto &Param : DeclaredParameters) {
+    Param = Param.ltrim();
+    Param = Param.rtrim();
+    if (UniqueParameters.find(Param) != UniqueParameters.end()) {
+      SM.PrintMessage(
+          SMLoc::getFromPointer(Buffer.data() + Buffer.find_first_of(Param)),
+          SourceMgr::DK_Error, "Parameter " + Param + " is repeated.");
+      return true;
+    }
+    UniqueParameters.insert(Param);
+  }
+
+  return false;
+}
+
+const std::string &PatternTemplate::GetTemplateName() const {
+  return TemplateName;
+}
+
+size_t PatternTemplate::getNumParameters() const {
+  return DeclaredParameters.size();
+}
+
+bool PatternTemplate::DefinedForPrefix(const StringRef Prefix) const {
+  return Prefix.str() == TemplatePrefix;
+}
+
+bool PatternTemplate::HasParameter(StringRef ParameterName) const {
+  for (const auto &Parameter : DeclaredParameters) {
+    if (Parameter == ParameterName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string PatternTemplate::GetRegularExpression(
+    SmallVectorImpl<StringRef> &Values) const {
+  // Cteate map with values of each parameter.
+  StringMap<StringRef> ParametersValues;
+  SmallVectorImpl<StringRef>::iterator It = Values.begin();
+  for (const auto &Parameter : DeclaredParameters) {
+    ParametersValues.insert(std::pair<StringRef, StringRef>(Parameter, *It));
+    ++It;
+  }
+  std::string Regex = TemplatePattern.getRegExStr().str();
+
+  int RegexWithoutParametersLoc =
+      0; // variable for place of regex part without variables.
+  SmallVector<std::string, 2> RegexComponents;
+  // Change all parameters to their values.
+  for (const auto &Parameter : Parameters) {
+    StringRef Value = ParametersValues[Parameter.second];
+    RegexComponents.push_back(
+        Regex.substr(RegexWithoutParametersLoc,
+                     Parameter.first - RegexWithoutParametersLoc));
+    
+
+    RegexWithoutParametersLoc = Parameter.first + Parameter.second.size();
+    RegexComponents.push_back("(" + Value.str() + ")");
+  }
+  RegexComponents.push_back(Regex.substr(RegexWithoutParametersLoc));
+
+  if (!Parameters.empty()) {
+    Regex = join(RegexComponents.begin(), RegexComponents.end(), "");
+  }
+  
+
+  return Regex;
+}
+
+class TemplatesCollection {
+  /// Described templates
+  StringMap<std::unique_ptr<PatternTemplate>> Templates;
+
+  TemplatesCollection();
+
+public:
+  static TemplatesCollection &Instance() {
+    static TemplatesCollection singleton;
+    return singleton;
+  }
+  /// Add template
+  PatternTemplate *AddTemplate(std::unique_ptr<PatternTemplate> AddedTemplate);
+  /// Get template by its name.
+  PatternTemplate *GetTemplate(StringRef TemplateName);
+  /// Check if there is current template in collection.
+  bool HasTemplate(const StringRef &TemplateName, const StringRef Prefix);
 };
 
+TemplatesCollection::TemplatesCollection() {}
+
+PatternTemplate *TemplatesCollection::AddTemplate(
+    std::unique_ptr<PatternTemplate> AddedTemplate) {
+  if (Templates.find(AddedTemplate->GetTemplateName()) != Templates.end())
+    return nullptr;
+  std::string TemplateName = AddedTemplate->GetTemplateName();
+  Templates
+      .insert(std::pair<std::string, std::unique_ptr<PatternTemplate>>(
+          AddedTemplate->GetTemplateName(), std::move(AddedTemplate)));
+  return Templates[TemplateName].get();
+}
+
+PatternTemplate *TemplatesCollection::GetTemplate(StringRef TemplateName) {
+  const auto PatternIt = Templates.find(TemplateName);
+  if (PatternIt == Templates.end())
+    return nullptr;
+  return PatternIt->second.get();
+}
+
+bool TemplatesCollection::HasTemplate(const StringRef &TemplateName, 
+    const StringRef Prefix) {
+  auto Template = Templates.find(TemplateName);
+  return Template != Templates.end() && 
+         Template->second->DefinedForPrefix(Prefix);
+}
+
+bool Pattern::AddVariable(StringRef Name, unsigned& CurParen, SourceMgr &SM,
+                          StringRef AddedRegex) {
+  VariableDefs[Name] = CurParen;
+  RegExStr += '(';
+  ++CurParen;
+
+  if (AddRegExToRegEx(AddedRegex, CurParen, SM))
+    return true;
+
+  RegExStr += ')';
+  return false;
+}
 
 bool Pattern::ParsePattern(StringRef PatternStr,
                            StringRef Prefix,
                            SourceMgr &SM,
                            unsigned LineNumber) {
   bool MatchFullLinesHere = MatchFullLines && CheckTy != Check::CheckNot;
 
   this->LineNumber = LineNumber;
if (PatternStr.startswith("[[")) {
       size_t End = FindRegexVarEnd(PatternStr.substr(2), SM);
 
       if (End == StringRef::npos) {
         SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
                         SourceMgr::DK_Error,
                         "invalid named regex reference, no ]] found");
         return true;
       }
+      // Handle templates.
+      SmallVector<StringRef, 10> Matches;
+      if (Regex(StringRef("(([a-zA-Z0-9_]+)? *@([a-zA-Z0-9_]+) "
+                          "*)(\\(.+\\))? *]]"),
+                Regex::Newline)
+              .match(PatternStr, &Matches)) {
+        if (Matches[3].str() != "LINE") {
+          PatternStr = PatternStr.substr(2 + Matches[1].size());
+          auto TemplateRegex =
+              ReplaceTemplates(Matches[3], PatternStr, Prefix, SM);
+          if (!TemplateRegex) {
+            handleAllErrors(TemplateRegex.takeError(), [&](const ErrorInfoBase &EI) {});
+            return true;
+          }
+          // There is variable for remembering match.
+          if (!Matches[2].empty()) {
+            AddVariable(Matches[2], CurParen, SM, *TemplateRegex);
+          } else {
+            RegExStr += '(';
+            ++CurParen;
+            if (AddRegExToRegEx(*TemplateRegex, CurParen, SM))
+              return true;
+            RegExStr += ')';
+          }
+          continue;
+        }
+      }
 
       StringRef MatchStr = PatternStr.substr(2, End);
       PatternStr = PatternStr.substr(End+4);
 
+
+
       // Get the regex name (e.g. "foo").
       size_t NameEnd = MatchStr.find(':');
       StringRef Name = MatchStr.substr(0, NameEnd);
 
       if (Name.empty()) {
         SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
                         "invalid name in named regex: empty name");
         return true;
if (PatternStr.startswith("[[")) {
           AddBackrefToRegEx(VarParenNum);
         } else {
           VariableUses.push_back(std::make_pair(Name, RegExStr.size()));
         }
         continue;
       }
 
       // Handle [[foo:.*]].
-      VariableDefs[Name] = CurParen;
-      RegExStr += '(';
-      ++CurParen;
-
-      if (AddRegExToRegEx(MatchStr.substr(NameEnd+1), CurParen, SM))
+      if (AddVariable(Name, CurParen, SM, MatchStr.substr(NameEnd+1)))
         return true;
-
-      RegExStr += ')';
     }
 
     // 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 (!NoCanonicalizeWhiteSpace)
       RegExStr += " *";
     RegExStr += '$';
   }
-
   return false;
 }
 
 bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen,
                               SourceMgr &SM) {
   Regex R(RS);
   std::string Error;
   if (!R.isValid(Error)) {
for (const auto &VariableUse : VariableUses) {
         StringMap<StringRef>::iterator it =
             VariableTable.find(VariableUse.first);
         // If the variable is undefined, return an error.
         if (it == VariableTable.end())
           return StringRef::npos;
 
         // Look up the value and escape it so that we can put it into the regex.
         Value += Regex::escape(it->second);
-      }
-
+      } 
       // Plop it into the regex at the adjusted offset.
       TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset,
                     Value.begin(), Value.end());
       InsertOffset += Value.size();
     }
 
     // Match the newly constructed regex.
     RegExToMatch = TmpStr;
void Pattern::PrintFailureInfo(const SourceMgr &SM, StringRef Buffer,
   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), VariableTable);
if (Str[0] == '\\') {
       Str = Str.substr(1);
       Offset++;
     }
   }
 
   return StringRef::npos;
 }
 
+Expected<std::string> Pattern::ReplaceTemplates(StringRef TemplateName,
+                                                StringRef& Buffer,
+                                                const StringRef Prefix,
+                                                SourceMgr &SM) {
+  // Replace templates with regular expressions.
+  std::string ResultRegex;
+  bool ParametersEndFound = false;
+  // Check if template was declared
+  if (!TemplatesCollection::Instance().HasTemplate(TemplateName, Prefix)) {
+    SM.PrintMessage(SMLoc::getFromPointer(TemplateName.data()),
+                    SourceMgr::DK_Error,
+                    "template " + TemplateName.str() + " wasn't declared");
+    return llvm::make_error<llvm::StringError>(
+        "Template " + TemplateName.str() + " wasn't declared",
+        llvm::inconvertibleErrorCode());
+  }
+
+  PatternTemplate *Temp =
+      TemplatesCollection::Instance().GetTemplate(TemplateName);
+  SmallVector<StringRef, 5> ParametersValues;
+  Buffer = Buffer.rtrim();
+  if (Buffer.startswith("("))
+    Buffer = Buffer.drop_front(1);
+  else 
+    ParametersEndFound = true;
+  
+  while (!ParametersEndFound) {
+    Buffer = Buffer.ltrim();
+    if (!Buffer.startswith("\"")) {
+      SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
+                            SourceMgr::DK_Error,
+                            "Pattern parameter should be quoted string.");
+      return llvm::make_error<llvm::StringError>(
+        "Pattern parameter should be quoted string",
+        llvm::inconvertibleErrorCode());
+    }
+    // Find close quote.
+    size_t StringEnd = Buffer.find_first_of('"', 1);
+    if (StringEnd != StringRef::npos && Buffer[StringEnd - 1] == '\\') {
+      StringEnd = Buffer.find_first_of('"', StringEnd + 1);
+    }
+    if (StringEnd == StringRef::npos) {
+      SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
+                            SourceMgr::DK_Error,
+                            "No close quote was found.");
+      return llvm::make_error<llvm::StringError>(
+        "No close quote was found.",
+        llvm::inconvertibleErrorCode());
+    }
+    ParametersValues.push_back(Buffer.slice(1, StringEnd));
+    Buffer = Buffer.drop_front(StringEnd + 1);
+    Buffer = Buffer.ltrim();
+
+    if (Buffer.startswith(")"))
+      ParametersEndFound = true;
+
+    if (!(Buffer.startswith(",") || Buffer.startswith(")"))) {
+      SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
+                      SourceMgr::DK_Error,
+                      "Extra characters in parameters list");
+      return llvm::make_error<llvm::StringError>(
+        "Extra characters in parameters list.",
+        llvm::inconvertibleErrorCode());
+    }
+
+    if (!Buffer.empty())
+      Buffer = Buffer.drop_front(1);
+  }
+
+  Buffer = Buffer.drop_front(Buffer.find("]]") + 2);
+
+  // Check number of parameters.
+  if (Temp->getNumParameters() != ParametersValues.size()) {
+    SM.PrintMessage(
+        SMLoc::getFromPointer(Buffer.data() + TemplateName.size()),
+        SourceMgr::DK_Error,
+        "Number of declared parameters differs from necessary.");
+    return llvm::make_error<llvm::StringError>(
+        "Number of declared parameters differs from necessary.",
+        llvm::inconvertibleErrorCode());
+  }
+
+  ResultRegex = Temp->GetRegularExpression(ParametersValues);
+  VariableUses.insert(VariableUses.end(),
+                      Temp->GetTemplatePattern()->VariableUses.begin(),
+                      Temp->GetTemplatePattern()->VariableUses.end());
+  VariableDefs.insert(Temp->GetTemplatePattern()->VariableDefs.begin(),
+                      Temp->GetTemplatePattern()->VariableDefs.end());
+  return ResultRegex;
+}
 
 //===----------------------------------------------------------------------===//
 // Check Strings.
 //===----------------------------------------------------------------------===//
 
 /// CheckString - This is a check that we found in the input file.
 struct CheckString {
   /// Pat - The pattern to match.
CanonicalizeInputFile(std::unique_ptr<MemoryBuffer> MB,
   return std::unique_ptr<MemoryBuffer>(
       MemoryBuffer::getMemBufferCopy(NewFile.str(), MB->getBufferIdentifier()));
 }
 
 static bool IsPartOfWord(char c) {
   return (isalnum(c) || c == '-' || c == '_');
 }
 
-// Get the size of the prefix extension.
-static size_t CheckTypeSize(Check::CheckType Ty) {
-  switch (Ty) {
-  case Check::CheckNone:
-  case Check::CheckBadNot:
-    return 0;
-
-  case Check::CheckPlain:
-    return sizeof(":") - 1;
-
-  case Check::CheckNext:
-    return sizeof("-NEXT:") - 1;
-
-  case Check::CheckSame:
-    return sizeof("-SAME:") - 1;
-
-  case Check::CheckNot:
-    return sizeof("-NOT:") - 1;
-
-  case Check::CheckDAG:
-    return sizeof("-DAG:") - 1;
-
-  case Check::CheckLabel:
-    return sizeof("-LABEL:") - 1;
-
-  case Check::CheckEOF:
-    llvm_unreachable("Should not be using EOF size");
-  }
-
-  llvm_unreachable("Bad check type");
-}
-
-static Check::CheckType FindCheckType(StringRef Buffer, StringRef Prefix) {
+static Check::CheckType FindCheckType(SourceMgr &SM, StringRef Buffer,
+                                      StringRef Prefix, size_t &CheckTypeSize) {
   char NextChar = Buffer[Prefix.size()];
+  CheckTypeSize = 0;
 
   // Verify that the : is present after the prefix.
-  if (NextChar == ':')
+  if (NextChar == ':') {
+    CheckTypeSize = 1;
     return Check::CheckPlain;
+  }
 
   if (NextChar != '-')
     return Check::CheckNone;
 
   StringRef Rest = Buffer.drop_front(Prefix.size() + 1);
-  if (Rest.startswith("NEXT:"))
+  if (Rest.startswith("NEXT:")) {
+    CheckTypeSize = sizeof("-NEXT:") - 1;
     return Check::CheckNext;
+  }
 
-  if (Rest.startswith("SAME:"))
+  if (Rest.startswith("SAME:")) {
+    CheckTypeSize = sizeof("-SAME:") - 1;
     return Check::CheckSame;
+  }
 
-  if (Rest.startswith("NOT:"))
+  if (Rest.startswith("NOT:")) {
+    CheckTypeSize = sizeof("-NOT:") - 1;
     return Check::CheckNot;
+  }
 
-  if (Rest.startswith("DAG:"))
+  if (Rest.startswith("DAG:")) {
+    CheckTypeSize = sizeof("-DAG:") - 1;
     return Check::CheckDAG;
+  }
 
-  if (Rest.startswith("LABEL:"))
+  if (Rest.startswith("LABEL:")) {
+    CheckTypeSize = sizeof("-LABEL:") - 1;
     return Check::CheckLabel;
+  }
+
+  if (Rest.startswith("DEFINE-PATTERN:")) {
+    CheckTypeSize = sizeof("-DEFINE-PATTERN:") - 1;
+    return Check::CheckPattern;
+  }
 
   // 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:"))
     return Check::CheckBadNot;
 
   return Check::CheckNone;
 }
 
 // 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;
 }
 
 // Try to find the first match in buffer for any prefix. If a valid match is
 // found, return that prefix and set its type and location.  If there are almost
 // matches (e.g. the actual prefix string is found, but is not an actual check
 // string), but no valid match, return an empty string and set the position to
 // resume searching from. If no partial matches are found, return an empty
 // string and the location will be StringRef::npos. If one prefix is a substring
 // of another, the maximal match should be found. e.g. if "A" and "AA" are
 // prefixes then AA-CHECK: should match the second one.
-static StringRef FindFirstCandidateMatch(StringRef &Buffer,
+static StringRef FindFirstCandidateMatch(SourceMgr &SM, StringRef &Buffer,
                                          Check::CheckType &CheckTy,
-                                         size_t &CheckLoc) {
+                                         size_t &CheckLoc,
+                                         size_t &CheckTypeSize) {
   StringRef FirstPrefix;
   size_t FirstLoc = StringRef::npos;
+  size_t FirstTypeSize = StringRef::npos;
   size_t SearchLoc = StringRef::npos;
   Check::CheckType FirstTy = Check::CheckNone;
 
   CheckTy = Check::CheckNone;
   CheckLoc = StringRef::npos;
 
   for (StringRef Prefix : CheckPrefixes) {
     size_t PrefixLoc = Buffer.find(Prefix);
for (StringRef Prefix : CheckPrefixes) {
 
     StringRef Rest = Buffer.drop_front(PrefixLoc);
     // Make sure we have actually found the prefix, and not a word containing
     // it. This should also prevent matching the wrong prefix when one is a
     // substring of another.
     if (PrefixLoc != 0 && IsPartOfWord(Buffer[PrefixLoc - 1]))
       FirstTy = Check::CheckNone;
     else
-      FirstTy = FindCheckType(Rest, Prefix);
+      FirstTy = FindCheckType(SM, Rest, Prefix, FirstTypeSize);
 
     FirstLoc = PrefixLoc;
     FirstPrefix = Prefix;
   }
 
   // If the first prefix is invalid, we should continue the search after it.
   if (FirstTy == Check::CheckNone) {
     CheckLoc = SearchLoc;
     return "";
   }
 
   CheckTy = FirstTy;
   CheckLoc = FirstLoc;
+  CheckTypeSize = FirstTypeSize;
   return FirstPrefix;
 }
 
-static StringRef FindFirstMatchingPrefix(StringRef &Buffer,
+static StringRef FindFirstMatchingPrefix(SourceMgr &SM, StringRef &Buffer,
                                          unsigned &LineNumber,
                                          Check::CheckType &CheckTy,
-                                         size_t &CheckLoc) {
+                                         size_t &CheckLoc,
+                                         size_t &CheckTypeSize) {
   while (!Buffer.empty()) {
-    StringRef Prefix = FindFirstCandidateMatch(Buffer, CheckTy, CheckLoc);
+    StringRef Prefix =
+        FindFirstCandidateMatch(SM, Buffer, CheckTy, CheckLoc, CheckTypeSize);
     // If we found a real match, we are done.
     if (!Prefix.empty()) {
       LineNumber += Buffer.substr(0, CheckLoc).count('\n');
       return Prefix;
     }
 
     // We didn't find any almost matches either, we are also done.
     if (CheckLoc == StringRef::npos)
StringRef PatternInBuffer =
         CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());
     SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());
 
     ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot));
     ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer,
                                                "IMPLICIT-CHECK", SM, 0);
   }
 
-
   std::vector<Pattern> DagNotMatches = ImplicitNegativeChecks;
 
   // LineNumber keeps track of the line on which CheckPrefix instances are
   // found.
   unsigned LineNumber = 1;
 
   while (1) {
     Check::CheckType CheckTy;
     size_t PrefixLoc;
+    size_t CheckTypeSize;
 
     // See if a prefix occurs in the memory buffer.
-    StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer,
-                                                   LineNumber,
-                                                   CheckTy,
-                                                   PrefixLoc);
+    StringRef UsedPrefix = FindFirstMatchingPrefix(
+        SM, Buffer, LineNumber, CheckTy, PrefixLoc, CheckTypeSize);
     if (UsedPrefix.empty())
       break;
 
     Buffer = Buffer.drop_front(PrefixLoc);
 
     // Location to use for error messages.
     const char *UsedPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1);
 
     // PrefixLoc is to the start of the prefix. Skip to the end.
-    Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy));
+    Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize);
 
     // Complain about useful-looking but unsupported suffixes.
     if (CheckTy == Check::CheckBadNot) {
-      SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
-                      SourceMgr::DK_Error,
+      SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Error,
                       "unsupported -NOT combo on prefix '" + UsedPrefix + "'");
       return true;
     }
 
     // Okay, we found the prefix, yay. Remember the rest of the line, but ignore
     // leading and trailing whitespace.
     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());
 
+    if (CheckTy == Check::CheckType::CheckPattern) {
+      // Get name of pattern.
+      SmallVector<StringRef, 20> Matches;
+      if (Regex(StringRef("^([a-zA-Z0-9_]+) *(\\((([a-zA-Z0-9_]+ *, "
+                          "*)*[a-zA-Z0-9_]+)\\))? *:"),
+                Regex::Newline)
+              .match(Buffer, &Matches)) {
+        std::unique_ptr<PatternTemplate> Template =
+            make_unique<PatternTemplate>(Matches[1], UsedPrefix);
+        PatternTemplate *AddedTemplate =
+            TemplatesCollection::Instance().AddTemplate(std::move(Template));
+
+        // Error template with same name.
+        if (AddedTemplate == nullptr) {
+          SM.PrintMessage(
+              SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Warning,
+              "the template name " + Matches[1].str() + " is already used");
+          return true;
+        }
+
+        Buffer = Buffer.drop_front(Matches[0].size());
+        EOL -= Matches[0].size();
+        if (AddedTemplate->ParseParameters(Matches[3], SM, Buffer))
+          return true;
+        if (AddedTemplate->ParseTemplate(Buffer.substr(0, EOL).ltrim(),
+                                         UsedPrefix, SM, LineNumber))
+          return true;
+      } else {
+        SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()),
+                        SourceMgr::DK_Warning,
+                        "No name was defined for pattern.");
+        return true;
+      }
+
+      Buffer = Buffer.substr(EOL);
+      continue;
+    }
+
     // Parse the pattern.
     Pattern P(CheckTy);
     if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber))
       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:'"
+      SM.PrintMessage(
+          SMLoc::getFromPointer(UsedPrefixStart), SourceMgr::DK_Error,
                                    " with variable definition or use");
       return true;
     }
 
     Buffer = Buffer.substr(EOL);
 
     // Verify that CHECK-NEXT lines have at least one CHECK line before them.
     if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame) &&
         CheckStrings.empty()) {
       StringRef Type = CheckTy == Check::CheckNext ? "NEXT" : "SAME";
       SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
                       SourceMgr::DK_Error,
-                      "found '" + UsedPrefix + "-" + Type + "' without previous '"
-                      + UsedPrefix + ": line");
+                      "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;
     }