[FileCheck] Add saturation support to numerical expressions.

[paulwalker-arm]

Summary

Add support for named operations to numerical expressions, which
take the form ".<name>.". This support has been used to add the
following named operations:

usat_high : Clamp LHS to be no bigger than RHS.
usat_low  : Clamp LHS to be no smaller than LHS.

[thopre]

Was this intended for upstream? I see lots of code not in upstream FileCheck (e.g. mul).

[thopre]

In D79882#2034418, @thopre wrote:

Was this intended for upstream? I see lots of code not in upstream FileCheck (e.g. mul).

My bad, saw that patch before the other one.

[paulwalker-arm]

It was me at fault. I've just started using arc and had assumed "arc diff" would create a review for each commit. Either that or I'm just using it wrong.

[thopre]

I'm not a big fan of the syntax, why not introduce a functional notation instead? E.g. CHECK-NEXT: #min(VAR1,20). Also since the operation you perform is min and max why not use these instead of usat_high and usat_low?

[paulwalker-arm]

I'll admit the syntax comes from laziness, or rather trying to implement the feature within the confines of the current design with minimal effort. Implementing real function support seemed like a considerable undertaking because then it opens up having to distinguish between function names and variable names (e.g. when parentheses are also used to define scope and precedence) plus nested function calls.

The current design suggested a simple left to right parsing structure so that's what I went with. The naming supports this because min suggests picking between multiple operands, whereas usat_high is an operation applied to a single operand.

I can investigate the function route but I cannot help but wonder if we'll just get to the point where it's better to use an existing language parser than invent a new one.

[paulwalker-arm]

I've created D79936 as potential replacement for this patch.

[thopre]

In D79882#2035379, @paulwalker-arm wrote:

I'll admit the syntax comes from laziness, or rather trying to implement the feature within the confines of the current design with minimal effort. Implementing real function support seemed like a considerable undertaking because then it opens up having to distinguish between function names and variable names (e.g. when parentheses are also used to define scope and precedence) plus nested function calls.

The current design suggested a simple left to right parsing structure so that's what I went with. The naming supports this because min suggests picking between multiple operands, whereas usat_high is an operation applied to a single operand.

I can investigate the function route but I cannot help but wonder if we'll just get to the point where it's better to use an existing language parser than invent a new one.

Yes that would be better, but I suspect it would have to be something provided by LLVM to not bring a huge dependency for a small tool. The current parsing code is my own fault and stems from my inexperience in the domain of parsing.

llvm/lib/Support/FileCheck.cpp

 //===- 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
 //
 //===----------------------------------------------------------------------===//
 //

 static uint64_t mul(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp * RightOp;
 }
 
 static uint64_t sub(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp - RightOp;
 }
 
+static uint64_t umax(uint64_t LeftOp, uint64_t RightOp) {
+  return std::max(LeftOp, RightOp);
+}
+
+static uint64_t umin(uint64_t LeftOp, uint64_t RightOp) {
+  return std::min(LeftOp, RightOp);
+}
+
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
                     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
                     FileCheckPatternContext *Context, const SourceMgr &SM) {
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())
     return std::move(LeftOp);
 
   // Check if this is a supported operation and select a function to perform
   // it.
   SMLoc OpLoc = SMLoc::getFromPointer(RemainingExpr.data());
   char Operator = popFront(RemainingExpr);
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
     EvalBinop = add;
     break;
   case '-':
     EvalBinop = sub;
     break;
   case '*':
     EvalBinop = mul;
     break;
+  case '.': {
+    // Parse a named operation of the form ".<Name>.".
+    size_t NameEnd = RemainingExpr.find('.');
+    if (NameEnd == StringRef::npos)
+      return ErrorDiagnostic::get(SM, OpLoc, "unterminated named operation");
+
+    StringRef Name = RemainingExpr.take_front(NameEnd);
+    auto OptBinOp = StringSwitch<Optional<binop_eval_t>>(Name)
+                        .Case("usat_low", umax)
+                        .Case("usat_high", umin)
+                        .Default(None);
+    if (!OptBinOp)
+      return ErrorDiagnostic::get(
+          SM, OpLoc, Twine("unsupported named operation '") + Name + "'");
+
+    EvalBinop = *OptBinOp;
+    RemainingExpr = RemainingExpr.drop_front(NameEnd + 1);
+    break;
+  }
   default:
     return ErrorDiagnostic::get(
         SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");
   }
 
   // Parse right operand.
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())

llvm/test/FileCheck/numeric-expression.txt

 
 ; Numeric expressions in explicit matching format and default matching rule using
 ; variables defined on other lines without spaces.
 USE DEF FMT IMPL MATCH
 11
 12
 10
 33
+11
+10
+20
+11
 c
 d
 b
 1a
 c0
 D
 E
 C
 1B
 D0
 11
 11
 11
 c
 c
 c
 c
 c
 CHECK-LABEL: USE DEF FMT IMPL MATCH
 CHECK-NEXT: [[#%u,VAR1]]
 CHECK-NEXT: [[#%u,VAR1+1]]
 CHECK-NEXT: [[#%u,VAR1-1]]
 CHECK-NEXT: [[#%u,VAR1*3]]
+CHECK-NEXT: [[#%u,VAR1.usat_high.20]]
+CHECK-NEXT: [[#%u,VAR1.usat_high.10]]
+CHECK-NEXT: [[#%u,VAR1.usat_low.20]]
+CHECK-NEXT: [[#%u,VAR1.usat_low.10]]
 CHECK-NEXT: [[#%x,VAR2]]
 CHECK-NEXT: [[#%x,VAR2+1]]
 CHECK-NEXT: [[#%x,VAR2-1]]
 CHECK-NEXT: [[#%x,VAR2+14]]
 CHECK-NEXT: [[#%x,VAR2*16]]
 CHECK-NEXT: [[#%X,VAR3]]
 CHECK-NEXT: [[#%X,VAR3+1]]
 CHECK-NEXT: [[#%X,VAR3-1]]

 10
 10
 22
 22
 22
 22
 22
 22
+10
+10
+10
+10
+10
+10
 CHECK-LABEL: USE EXPL FMT IMPL MATCH SPC
 CHECK-NEXT: [[#%u, VAR1]]
 CHECK-NEXT: [[# %u, VAR1]]
 CHECK-NEXT: [[# %u, VAR1 ]]
 CHECK-NEXT: [[#%u, VAR1+1]]
 CHECK-NEXT: [[# %u, VAR1+1]]
 CHECK-NEXT: [[# %u , VAR1+1]]
 CHECK-NEXT: [[# %u , VAR1 +1]]
 CHECK-NEXT: [[# %u , VAR1 + 1]]
 CHECK-NEXT: [[# %u , VAR1 + 1 ]]
 CHECK-NEXT: [[#%u, VAR1-1]]
 CHECK-NEXT: [[# %u, VAR1-1]]
 CHECK-NEXT: [[# %u , VAR1-1]]
 CHECK-NEXT: [[# %u , VAR1 -1]]
 CHECK-NEXT: [[# %u , VAR1 - 1]]
 CHECK-NEXT: [[# %u , VAR1 - 1 ]]
 CHECK-NEXT: [[#%u, VAR1*2]]
 CHECK-NEXT: [[# %u, VAR1*2]]
 CHECK-NEXT: [[# %u , VAR1*2]]
 CHECK-NEXT: [[# %u , VAR1 *2]]
 CHECK-NEXT: [[# %u , VAR1 * 2]]
 CHECK-NEXT: [[# %u , VAR1 * 2 ]]
+CHECK-NEXT: [[#%u, VAR1.usat_high.10]]
+CHECK-NEXT: [[# %u, VAR1.usat_high.10]]
+CHECK-NEXT: [[# %u , VAR1.usat_high.10]]
+CHECK-NEXT: [[# %u , VAR1 .usat_high.10]]
+CHECK-NEXT: [[# %u , VAR1 .usat_high. 10]]
+CHECK-NEXT: [[# %u , VAR1 .usat_high. 10 ]]
 
 ; Numeric expressions in implicit matching format and default matching rule using
 ; variables defined on other lines.
 USE IMPL FMT IMPL MATCH
 11
 12
 10
 33
 c
 d
 b
 1a
 c0
 D
 E
 C
 1B
 D0
+11
+10
+20
+11
 CHECK-LABEL: USE IMPL FMT IMPL MATCH
 CHECK-NEXT: [[#VAR1]]
 CHECK-NEXT: [[#VAR1+1]]
 CHECK-NEXT: [[#VAR1-1]]
 CHECK-NEXT: [[#VAR1*3]]
 CHECK-NEXT: [[#VAR2]]
 CHECK-NEXT: [[#VAR2+1]]
 CHECK-NEXT: [[#VAR2-1]]
 CHECK-NEXT: [[#VAR2+14]]
 CHECK-NEXT: [[#VAR2*16]]
 CHECK-NEXT: [[#VAR3]]
 CHECK-NEXT: [[#VAR3+1]]
 CHECK-NEXT: [[#VAR3-1]]
 CHECK-NEXT: [[#VAR3+14]]
 CHECK-NEXT: [[#VAR3*16]]
+CHECK-NEXT: [[#VAR1.usat_high.20]]
+CHECK-NEXT: [[#VAR1.usat_high.10]]
+CHECK-NEXT: [[#VAR1.usat_low.20]]
+CHECK-NEXT: [[#VAR1.usat_low.10]]
 
 ; Numeric expressions using variables defined on other lines and an immediate
 ; interpreted as an unsigned value.
 ; Note: 9223372036854775819 = 0x8000000000000000 + 11
 USE IMPL FMT IMPL MATCH UNSIGNED IMM
 9223372036854775819
 CHECK-LABEL: USE IMPL FMT IMPL MATCH UNSIGNED IMM
 CHECK-NEXT: [[#VAR1+0x8000000000000000]]

 INVALID OPERATOR
 NUMVAR%2: 22
 INVAL-OP-LABEL: INVALID OPERATOR
 INVAL-OP-NEXT: NUMVAR%2: [[#NUMVAR%2]]
 INVAL-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:35: error: unsupported operation '%'
 INVAL-OP-MSG-NEXT: {{I}}NVAL-OP-NEXT: NUMVAR%2: {{\[\[#NUMVAR\%2\]\]}}
 INVAL-OP-MSG-NEXT:     {{^}}                                  ^{{$}}
 
+; Numeric expression with unsupported named operator.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-NAMED-OP \
+RUN:               --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-NAMED-OP-MSG %s
+
+INVALID NAMED OPERATOR
+NUMVAR.made_up_name.2: 22
+INVAL-NAMED-OP-LABEL: INVALID NAMED OPERATOR
+INVAL-NAMED-OP-NEXT: NUMVAR.made_up_name.2: [[#NUMVAR.made_up_name.2]]
+INVAL-NAMED-OP-MSG: numeric-expression.txt:[[#@LINE-1]]:54: error: unsupported named operation 'made_up_name'
+INVAL-NAMED-OP-MSG-NEXT: {{I}}NVAL-NAMED-OP-NEXT: NUMVAR.made_up_name.2: {{\[\[#NUMVAR\.made_up_name\.2\]\]}}
+INVAL-NAMED-OP-MSG-NEXT:     {{^}}                                                     ^{{$}}
+
+; Numeric expression with unsupported named operator.
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-NAMED-OP-2 \
+RUN:               --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-NAMED-OP-2-MSG %s
+
+UNTERMINATED NAMED OPERATOR
+NUMVAR.made_up_name 4: 22
+INVAL-NAMED-OP-2-LABEL: UNTERMINATED NAMED OPERATOR
+INVAL-NAMED-OP-2-NEXT: NUMVAR.made_up_name 4: [[#NUMVAR.made_up_name 4]]
+INVAL-NAMED-OP-2-MSG: numeric-expression.txt:[[#@LINE-1]]:56: error: unterminated named operation
+INVAL-NAMED-OP-2-MSG-NEXT: {{I}}NVAL-NAMED-OP-2-NEXT: NUMVAR.made_up_name 4: {{\[\[#NUMVAR\.made_up_name 4\]\]}}
+INVAL-NAMED-OP-2-MSG-NEXT:     {{^}}                                                       ^{{$}}
+
 ; Name conflict between Numeric variable definition and string variable
 ; definition whether from the command-line or input text.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT1,CONFLICT2 \
 RUN:               --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=42 --check-prefixes CONFLICT,CONFLICT2 \