[FileCheck] Add multiplication support to numerical expressions.

[thopre]

Thanks for this change, multiplication seems like a much needed addition to the numeric expression support indeed.

This changes gives the same priority to the multiplication operator as the addition and subtraction operators. That's counter-intuitive and is sure to bite people later on. The change will also need to update the documentation (llvm/docs/CommandGuide/FileCheck.rst) since it mentions valid operators.

[arichardson]

We also added multiplication and division locally in the CHERI fork of LLVM. However, I didn't try upstreaming it since I feel like operator precedence needs to be solved first.
D77383 adds support for parenthesized expressions that allows working around the lack of operator precendence, but I haven't had time to update it yet.

[paulwalker-arm]

I understand the operator precedence might surprise some (although personally I just assumed a left->right evaluation order) but when taken with named operators (https://reviews.llvm.org/D79882) is it worth enforcing and documenting this simple precedence order rather than complicating things? With the bracket feature providing a route to a custom evaluation order.

[paulwalker-arm]

Updated FileCheck documentation.

[thopre]

In D79885#2034705, @paulwalker-arm wrote:

I understand the operator precedence might surprise some (although personally I just assumed a left->right evaluation order) but when taken with named operators (https://reviews.llvm.org/D79882) is it worth enforcing and documenting this simple precedence order rather than complicating things? With the bracket feature providing a route to a custom evaluation order.

Using the functional notation as I suggested would allow to clarify how is the evaluation to be performed since it forces parenthesis around the arguments.

[paulwalker-arm]

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

llvm/docs/CommandGuide/FileCheck.rst

 
 * ``<expr>`` is an expression. An expression is in turn 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.
+  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]
     ; CHECK: Loading from 0x[[#%x,ADDR:]]

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
 //
 //===----------------------------------------------------------------------===//
 //
Expected<std::unique_ptr<ExpressionAST>> Pattern::parseNumericOperand(
   return ErrorDiagnostic::get(SM, Expr,
                               "invalid operand format '" + Expr + "'");
 }
 
 static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp + RightOp;
 }
 
+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;
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
                     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
     EvalBinop = add;
     break;
   case '-':
     EvalBinop = sub;
     break;
+  case '*':
+    EvalBinop = mul;
+    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/line-count.txt

 41 ERR6: line-count.txt:[[#@LINE-1]]:18: error: unexpected whitespace
 42
 43 BAD7: [[@LINE-1 ]]
 44 ERR7: line-count.txt:[[#@LINE-1]]:19: error: unexpected whitespace
 45
 46 BAD8: [[@LIN]]
 47 ERR8: line-count.txt:[[#@LINE-1]]:12: error: invalid pseudo numeric variable '@LIN'
 48
-49 BAD9: [[@LINE*2]]
-50 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported operation '*'
+49 BAD9: [[@LINE%2]]
+50 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported operation '%'
 51
 52 BAD10: [[@LINE-x]]
 53 ERR10: line-count.txt:[[#@LINE-1]]:19: error: invalid operand format 'x'
 54
 55 BAD11: [[@LINE-1x]]
 56 ERR11: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of expression 'x'
 57
 ; RUN: %ProtectFileCheckOutput \

llvm/test/FileCheck/numeric-expression.txt

 INVALID-FMT-SPEC-MSG2-NEXT:    {{^}}                                    ^{{$}}
 
 ; 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
 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: [[#%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]]
 CHECK-NEXT: [[#%X,VAR3+14]]
+CHECK-NEXT: [[#%X,VAR3*16]]
 CHECK-NEXT: [[#%u,VAR1a]]
 CHECK-NEXT: [[#%u,VAR1b]]
 CHECK-NEXT: [[#%u,VAR1c]]
 CHECK-NEXT: [[#%x,VAR2a]]
 
 ; Numeric expressions in explicit matching format and default matching rule using
 ; variables defined on other lines with different spacing.
 USE EXPL FMT IMPL MATCH SPC
 11
 11
 11
 12
 12
 12
 12
 12
 12
 10
 10
 10
 10
 10
 10
+22
+22
+22
+22
+22
+22
 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 ]]
 
 ; 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
 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]]
 
 ; 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]]

 
 ; Numeric expression with unsupported operator.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-OP \
 RUN:               --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix INVAL-OP-MSG %s
 
 INVALID OPERATOR
-NUMVAR*2: 22
+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-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:     {{^}}                                  ^{{$}}
 
 ; 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