[FileCheck] Allow literal '['s before "[[var...]]"

[foad]

Summary

Change FileCheck to accept patterns like "[[[var...]]" and treat the
excess open brackets at the start as literals.

This makes the patterns for matching assembler output with literal
brackets much cleaner. For example an AMDGPU pattern that used to be
written like:

buffer_store_dwordx2 v{{\[}}[[LO]]:[[HI]]{{\]}}

can now be:

buffer_store_dwordx2 v[[[LO]]:[[HI]]]

(Even before this patch the final close bracket did not need to be
wrapped in {{}}, but people tended to do it anyway for symmetry.)

This does not introduce any ambiguity since "[[" was always followed by
an identifier or '@' or '#', so "[[[" was always an error.

I've included a few test updates in this patch just for illustration and
testing. There are a couple of hundred tests that could be updated as a
follow up, mostly in test/CodeGen/.

[thopre]

Could you add a new testcase somewhere in llvm/test/FileCheck? Thanks!

llvm/lib/FileCheck/FileCheck.cpp

1194

Why the special treatment for {{ here since only the [[[ case is handled above?

[foad]

llvm/lib/FileCheck/FileCheck.cpp

1194

Only for consistency and/or efficiency. At this point we know that PatternStr does not start with {{ since it was handled above, so there is no need to check for it at offset 0. And I found it easier to understand the code if both calls to find look the same.

[foad]

Add a FileCheck test.

[thopre]

llvm/lib/FileCheck/FileCheck.cpp

1194

Fair enough

llvm/lib/FileCheck/FileCheck.cpp

while (!PatternStr.empty()) {
     // 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("[[")) {
+    // valid, as this helps catch some common errors. If there are extra '['s
+    // before the "[[", treat them literally.
+    if (PatternStr.startswith("[[") && !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) {
if (PatternStr.startswith("[[") && !PatternStr.startswith("[[[")) {
           Substitution *Substitution =
               IsNumBlock
                   ? Context->makeNumericSubstitution(
                         SubstStr, std::move(ExpressionPointer), SubstInsertIdx)
                   : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);
           Substitutions.push_back(Substitution);
         }
       }
+
+      continue;
     }
 
     // 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("[["));
+    size_t FixedMatchEnd =
+        std::min(PatternStr.find("{{", 1), PatternStr.find("[[", 1));
     RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd));
     PatternStr = PatternStr.substr(FixedMatchEnd);
   }
 
   if (MatchFullLinesHere) {
     if (!Req.NoCanonicalizeWhiteSpace)
       RegExStr += " *";
     RegExStr += '$';

llvm/test/CodeGen/Mips/msa/3r-s.ll

 
 ; CHECK: llvm_mips_sld_b_test:
 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_sld_b_ARG1)
 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_sld_b_ARG2)
 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_sld_b_ARG3)
 ; CHECK-DAG: ld.b [[WD:\$w[0-9]+]], 0([[R1]])
 ; CHECK-DAG: ld.b [[WS:\$w[0-9]+]], 0([[R2]])
 ; CHECK-DAG: lw [[RT:\$[0-9]+]], 0([[R3]])
-; CHECK-DAG: sld.b [[WD]], [[WS]]{{\[}}[[RT]]{{\]}}
+; CHECK-DAG: sld.b [[WD]], [[WS]][[[RT]]]
 ; CHECK-DAG: st.b [[WD]]
 ; CHECK: .size llvm_mips_sld_b_test
 ;
 @llvm_mips_sld_h_ARG1 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 @llvm_mips_sld_h_ARG2 = global <8 x i16> <i16 0, i16 1, i16 2, i16 3, i16 4, i16 5, i16 6, i16 7>, align 16
 @llvm_mips_sld_h_ARG3 = global i32 10, align 16
 @llvm_mips_sld_h_RES  = global <8 x i16> <i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, align 16
 

 
 ; CHECK: llvm_mips_sld_h_test:
 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_sld_h_ARG1)
 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_sld_h_ARG2)
 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_sld_h_ARG3)
 ; CHECK-DAG: ld.h [[WD:\$w[0-9]+]], 0([[R1]])
 ; CHECK-DAG: ld.h [[WS:\$w[0-9]+]], 0([[R2]])
 ; CHECK-DAG: lw [[RT:\$[0-9]+]], 0([[R3]])
-; CHECK-DAG: sld.h [[WD]], [[WS]]{{\[}}[[RT]]{{\]}}
+; CHECK-DAG: sld.h [[WD]], [[WS]][[[RT]]]
 ; CHECK-DAG: st.h [[WD]]
 ; CHECK: .size llvm_mips_sld_h_test
 ;
 @llvm_mips_sld_w_ARG1 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 @llvm_mips_sld_w_ARG2 = global <4 x i32> <i32 0, i32 1, i32 2, i32 3>, align 16
 @llvm_mips_sld_w_ARG3 = global i32 10, align 16
 @llvm_mips_sld_w_RES  = global <4 x i32> <i32 0, i32 0, i32 0, i32 0>, align 16
 

 
 ; CHECK: llvm_mips_sld_w_test:
 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_sld_w_ARG1)
 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_sld_w_ARG2)
 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_sld_w_ARG3)
 ; CHECK-DAG: ld.w [[WD:\$w[0-9]+]], 0([[R1]])
 ; CHECK-DAG: ld.w [[WS:\$w[0-9]+]], 0([[R2]])
 ; CHECK-DAG: lw [[RT:\$[0-9]+]], 0([[R3]])
-; CHECK-DAG: sld.w [[WD]], [[WS]]{{\[}}[[RT]]{{\]}}
+; CHECK-DAG: sld.w [[WD]], [[WS]][[[RT]]]
 ; CHECK-DAG: st.w [[WD]]
 ; CHECK: .size llvm_mips_sld_w_test
 ;
 @llvm_mips_sld_d_ARG1 = global <2 x i64> <i64 0, i64 1>, align 16
 @llvm_mips_sld_d_ARG2 = global <2 x i64> <i64 0, i64 1>, align 16
 @llvm_mips_sld_d_ARG3 = global i32 10, align 16
 @llvm_mips_sld_d_RES  = global <2 x i64> <i64 0, i64 0>, align 16
 

 
 ; CHECK: llvm_mips_sld_d_test:
 ; CHECK-DAG: lw [[R1:\$[0-9]+]], %got(llvm_mips_sld_d_ARG1)
 ; CHECK-DAG: lw [[R2:\$[0-9]+]], %got(llvm_mips_sld_d_ARG2)
 ; CHECK-DAG: lw [[R3:\$[0-9]+]], %got(llvm_mips_sld_d_ARG3)
 ; CHECK-DAG: ld.d [[WD:\$w[0-9]+]], 0([[R1]])
 ; CHECK-DAG: ld.d [[WS:\$w[0-9]+]], 0([[R2]])
 ; CHECK-DAG: lw [[RT:\$[0-9]+]], 0([[R3]])
-; CHECK-DAG: sld.d [[WD]], [[WS]]{{\[}}[[RT]]{{\]}}
+; CHECK-DAG: sld.d [[WD]], [[WS]][[[RT]]]
 ; CHECK-DAG: st.d [[WD]]
 ; CHECK: .size llvm_mips_sld_d_test
 ;
 @llvm_mips_sll_b_ARG1 = global <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, align 16
 @llvm_mips_sll_b_ARG2 = global <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, align 16
 @llvm_mips_sll_b_RES  = global <16 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, align 16
 
 define void @llvm_mips_sll_b_test() nounwind {

llvm/test/CodeGen/Mips/msa/basic_operations_float.ll

define float @extract_v4f32_vidx() nounwind {
 
   %3 = load i32, i32* @i32
   ; O32-DAG: lw [[PTR_I:\$[0-9]+]], %got(i32)(
   ; N32-DAG: lw [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; N64-DAG: ld [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; ALL-DAG: lw [[IDX:\$[0-9]+]], 0([[PTR_I]])
 
   %4 = extractelement <4 x float> %2, i32 %3
-  ; ALL-DAG: splat.w $w0, [[R1]]{{\[}}[[IDX]]]
+  ; ALL-DAG: splat.w $w0, [[R1]][[[IDX]]]
 
   ret float %4
 }
 
 define double @extract_v2f64() nounwind {
   ; ALL-LABEL: extract_v2f64:
 
   %1 = load <2 x double>, <2 x double>* @v2f64
define double @extract_v2f64_vidx() nounwind {
 
   %3 = load i32, i32* @i32
   ; O32-DAG: lw [[PTR_I:\$[0-9]+]], %got(i32)(
   ; N32-DAG: lw [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; N64-DAG: ld [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; ALL-DAG: lw [[IDX:\$[0-9]+]], 0([[PTR_I]])
 
   %4 = extractelement <2 x double> %2, i32 %3
-  ; ALL-DAG: splat.d $w0, [[R1]]{{\[}}[[IDX]]]
+  ; ALL-DAG: splat.d $w0, [[R1]][[[IDX]]]
 
   ret double %4
 }
 
 define void @insert_v4f32(float %a) nounwind {
   ; ALL-LABEL: insert_v4f32:
 
   %1 = load <4 x float>, <4 x float>* @v4f32
define void @insert_v4f32_vidx(float %a) nounwind {
   ; O32-DAG: lw [[PTR_I:\$[0-9]+]], %got(i32)(
   ; N32-DAG: lw [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; N64-DAG: ld [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; ALL-DAG: lw [[IDX:\$[0-9]+]], 0([[PTR_I]])
 
   %3 = insertelement <4 x float> %1, float %a, i32 %2
   ; float argument passed in $f12
   ; ALL-DAG: sll [[BIDX:\$[0-9]+]], [[IDX]], 2
-  ; ALL-DAG: sld.b [[R1]], [[R1]]{{\[}}[[BIDX]]]
+  ; ALL-DAG: sld.b [[R1]], [[R1]][[[BIDX]]]
   ; ALL-DAG: insve.w [[R1]][0], $w12[0]
   ; ALL-DAG: neg [[NIDX:\$[0-9]+]], [[BIDX]]
-  ; ALL-DAG: sld.b [[R1]], [[R1]]{{\[}}[[NIDX]]]
+  ; ALL-DAG: sld.b [[R1]], [[R1]][[[NIDX]]]
 
   store <4 x float> %3, <4 x float>* @v4f32
   ; ALL-DAG: st.w [[R1]]
 
   ret void
 }
 
 define void @insert_v2f64_vidx(double %a) nounwind {
define void @insert_v2f64_vidx(double %a) nounwind {
   ; O32-DAG: lw [[PTR_I:\$[0-9]+]], %got(i32)(
   ; N32-DAG: lw [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; N64-DAG: ld [[PTR_I:\$[0-9]+]], %got_disp(i32)(
   ; ALL-DAG: lw [[IDX:\$[0-9]+]], 0([[PTR_I]])
 
   %3 = insertelement <2 x double> %1, double %a, i32 %2
   ; double argument passed in $f12
   ; ALL-DAG: sll [[BIDX:\$[0-9]+]], [[IDX]], 3
-  ; ALL-DAG: sld.b [[R1]], [[R1]]{{\[}}[[BIDX]]]
+  ; ALL-DAG: sld.b [[R1]], [[R1]][[[BIDX]]]
   ; ALL-DAG: insve.d [[R1]][0], $w12[0]
   ; ALL-DAG: neg [[NIDX:\$[0-9]+]], [[BIDX]]
-  ; ALL-DAG: sld.b [[R1]], [[R1]]{{\[}}[[NIDX]]]
+  ; ALL-DAG: sld.b [[R1]], [[R1]][[[NIDX]]]
 
   store <2 x double> %3, <2 x double>* @v2f64
   ; ALL-DAG: st.d [[R1]]
 
   ret void
 }

llvm/test/FileCheck/regex-brackets.txt

 // RUN: FileCheck -input-file %s %s
 
 op r1
 op r2, [x r1]
+op r3, [r1]
 ; CHECK:        op [[REG:r[0-9]]]
 ; CHECK:        op [[REG2:r[0-9]]], [x [[REG]]]
-
+; CHECK:        op [[REG3:r[0-9]]], [[[REG]]]