mirror of
https://github.com/RPCS3/llvm.git
synced 2026-07-19 15:13:49 -04:00
Thomas Preud'homme
c30b26e38b
Summary: This patch is part of a patch series to add support for FileCheck numeric expressions. This specific patch lift the restriction for a numeric expression to either be a variable definition or a numeric expression to try to match. This commit allows a numeric variable to be set to the result of the evaluation of a numeric expression after it has been matched successfully. When it happens, the variable is allowed to be used on the same line since its value is known at match time. It also makes use of this possibility to reuse the parsing code to parse a command-line definition by crafting a mirror string of the -D option with the equal sign replaced by a colon sign, e.g. for option '-D#NUMVAL=10' it creates the string '-D#NUMVAL=10 (parsed as [[#NUMVAL:10]])' where the numeric expression is parsed to define NUMVAL. This result in a few tests needing updating for the location diagnostics on top of the tests for the new feature. It also enables empty numeric expression which match any number without defining a variable. This is done here rather than in commit #5 of the patch series because it requires to dissociate automatic regex insertion in RegExStr from variable definition which would make commit #5 even bigger than it already is. Copyright: - Linaro (changes up to diff 183612 of revision D55940) - GraphCore (changes in later versions of revision D55940 and in new revision created off D55940) Reviewers: jhenderson, chandlerc, jdenny, probinson, grimar, arichardson, rnk Subscribers: hiraditya, llvm-commits, probinson, dblaikie, grimar, arichardson, tra, rnk, kristina, hfinkel, rogfer01, JonChesterfield Tags: #llvm Differential Revision: https://reviews.llvm.org/D60388 llvm-svn: 366860 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@366897 91177308-0d34-0410-b5e6-96231b3b80d8
192 lines
6.6 KiB
Plaintext
192 lines
6.6 KiB
Plaintext
RUN: FileCheck --input-file %s %s
|
|
|
|
; We use CHECK-NEXT directives to force a match on all lines with digits.
|
|
|
|
; Numeric variable definition without spaces.
|
|
DEF NO SPC
|
|
10
|
|
CHECK-LABEL: DEF NO SPC
|
|
CHECK-NEXT: [[#VAR1:]]
|
|
|
|
; Numeric variable definition with different spacing.
|
|
DEF SPC
|
|
11
|
|
11
|
|
11
|
|
CHECK-LABEL: DEF SPC
|
|
CHECK-NEXT: [[# VAR1a:]]
|
|
CHECK-NEXT: [[# VAR1b :]]
|
|
CHECK-NEXT: [[# VAR1c : ]]
|
|
|
|
; Numeric variable redefinition.
|
|
REDEF NO SPC
|
|
11
|
|
CHECK-LABEL: REDEF
|
|
CHECK-NEXT: [[#VAR1:]]
|
|
|
|
; Numeric expressions using variables defined on other lines without spaces.
|
|
USE NO SPC
|
|
11
|
|
12
|
|
10
|
|
11
|
|
11
|
|
11
|
|
CHECK-LABEL: USE
|
|
CHECK-NEXT: [[#VAR1]]
|
|
CHECK-NEXT: [[#VAR1+1]]
|
|
CHECK-NEXT: [[#VAR1-1]]
|
|
CHECK-NEXT: [[#VAR1a]]
|
|
CHECK-NEXT: [[#VAR1b]]
|
|
CHECK-NEXT: [[#VAR1c]]
|
|
|
|
; Numeric expressions using variables defined on other lines with different
|
|
; spacing.
|
|
USE SPC
|
|
11
|
|
11
|
|
12
|
|
12
|
|
12
|
|
12
|
|
10
|
|
10
|
|
10
|
|
10
|
|
CHECK-LABEL: USE SPC
|
|
CHECK-NEXT: [[# VAR1]]
|
|
CHECK-NEXT: [[# VAR1 ]]
|
|
CHECK-NEXT: [[# VAR1+1]]
|
|
CHECK-NEXT: [[# VAR1 +1]]
|
|
CHECK-NEXT: [[# VAR1 + 1]]
|
|
CHECK-NEXT: [[# VAR1 + 1 ]]
|
|
CHECK-NEXT: [[# VAR1-1]]
|
|
CHECK-NEXT: [[# VAR1 -1]]
|
|
CHECK-NEXT: [[# VAR1 - 1]]
|
|
CHECK-NEXT: [[# VAR1 - 1 ]]
|
|
|
|
; Numeric expressions using variables defined on other lines and an immediate
|
|
; interpreted as an unsigned value.
|
|
; Note: 9223372036854775819 = 0x8000000000000000 + 11
|
|
; 9223372036854775808 = 0x8000000000000000
|
|
USE UNSIGNED IMM
|
|
9223372036854775819
|
|
CHECK-LABEL: USE UNSIGNED IMM
|
|
CHECK-NEXT: [[#VAR1+9223372036854775808]]
|
|
|
|
; Numeric expressions using more than one variable defined on other lines.
|
|
USE MULTI VAR
|
|
31
|
|
42
|
|
CHECK-LABEL: USE MULTI VAR
|
|
CHECK-NEXT: [[#VAR2:]]
|
|
CHECK-NEXT: [[#VAR1+VAR2]]
|
|
|
|
; Numeric expression using a variable defined from a numeric expression.
|
|
DEF EXPR GOOD MATCH
|
|
42
|
|
41 43
|
|
; CHECK-LABEL: DEF EXPR GOOD MATCH
|
|
; CHECK-NEXT: [[# VAR42:VAR1+31]]
|
|
; CHECK-NEXT: [[# VAR41: VAR42-1]] [[# VAR41 + 2]]
|
|
|
|
; Empty numeric expression.
|
|
EMPTY NUM EXPR
|
|
foo 104 bar
|
|
; CHECK-LABEL: EMPTY NUM EXPR
|
|
; CHECK-NEXT: foo [[#]] bar
|
|
|
|
; Numeric expression using undefined variables.
|
|
RUN: not FileCheck --check-prefix UNDEF-USE --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix UNDEF-USE-MSG %s
|
|
|
|
UNDEF VAR USE
|
|
UNDEFVAR: 11
|
|
UNDEF-USE-LABEL: UNDEF VAR USE
|
|
UNDEF-USE-NEXT: UNDEFVAR: [[#UNDEFVAR1+UNDEFVAR2]]
|
|
UNDEF-USE-MSG: numeric-expression.txt:[[#@LINE-1]]:17: error: {{U}}NDEF-USE-NEXT: expected string not found in input
|
|
UNDEF-USE-MSG-NEXT: {{U}}NDEF-USE-NEXT: UNDEFVAR: {{\[\[#UNDEFVAR1\+UNDEFVAR2\]\]}}
|
|
UNDEF-USE-MSG-NEXT: {{^ \^$}}
|
|
UNDEF-USE-MSG-NEXT: numeric-expression.txt:[[#@LINE-6]]:1: note: scanning from here
|
|
UNDEF-USE-MSG-NEXT: UNDEFVAR: 11
|
|
UNDEF-USE-MSG-NEXT: {{^\^$}}
|
|
UNDEF-USE-MSG-NEXT: numeric-expression.txt:[[#@LINE-9]]:1: note: uses undefined variable(s): "UNDEFVAR1" "UNDEFVAR2"
|
|
UNDEF-USE-MSG-NEXT: UNDEFVAR: 11
|
|
UNDEF-USE-MSG-NEXT: {{^\^$}}
|
|
|
|
; Numeric expression with unsupported operator.
|
|
RUN: not FileCheck -D#NUMVAR=10 --check-prefix INVAL-OP --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix INVAL-OP-MSG %s
|
|
|
|
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: {{^ \^$}}
|
|
|
|
; Name conflict between Numeric variable definition and string variable
|
|
; definition whether from the command-line or input text.
|
|
RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT1,CONFLICT2 --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
|
|
RUN: not FileCheck -D#NUMVAR=42 --check-prefixes CONFLICT,CONFLICT2 --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix INPUT-STR-CONFLICT %s
|
|
RUN: not FileCheck -D#NUMVAR=42 -DNUMVAR=foobar --check-prefix CONFLICT --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix CLI-STR-CONFLICT %s
|
|
RUN: not FileCheck --check-prefixes CONFLICT,CONFLICT3,CONFLICT4 --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix INPUT-NUM-CONFLICT %s
|
|
RUN: not FileCheck -DSTRVAR=foobar --check-prefixes CONFLICT,CONFLICT4 --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix INPUT-NUM-CONFLICT %s
|
|
RUN: not FileCheck -DSTRVAR=foobar -D#STRVAR=42 --check-prefix CONFLICT --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix CLI-NUM-CONFLICT %s
|
|
|
|
STRVAR NUMVAR CONFLICT
|
|
redef1 42
|
|
foobar
|
|
redef2 42
|
|
CONFLICT-LABEL: STRVAR NUMVAR CONFLICT
|
|
CONFLICT1-NEXT: redef1 [[#NUMVAR:]]
|
|
CONFLICT2: [[NUMVAR:foo.*]]
|
|
CONFLICT3: [[STRVAR:foo.*]]
|
|
CONFLICT4: redef2 [[#STRVAR:]]
|
|
INPUT-STR-CONFLICT: numeric-expression.txt:[[#@LINE-3]]:14: error: numeric variable with name 'NUMVAR' already exists
|
|
INPUT-STR-CONFLICT-NEXT: {{C}}ONFLICT2: {{\[\[NUMVAR:foo\.\*\]\]}}
|
|
INPUT-STR-CONFLICT-NEXT: {{^ \^$}}
|
|
CLI-STR-CONFLICT: Global defines:2:19: error: numeric variable with name 'NUMVAR' already exists
|
|
CLI-STR-CONFLICT-NEXT: Global define #2: NUMVAR=foobar
|
|
CLI-STR-CONFLICT-NEXT: {{^ \^$}}
|
|
INPUT-NUM-CONFLICT: numeric-expression.txt:[[#@LINE-7]]:22: error: string variable with name 'STRVAR' already exists
|
|
INPUT-NUM-CONFLICT-NEXT: CONFLICT4: redef2 {{\[\[#STRVAR:\]\]}}
|
|
INPUT-NUM-CONFLICT-NEXT: {{^ \^$}}
|
|
CLI-NUM-CONFLICT: Global defines:2:45: error: string variable with name 'STRVAR' already exists
|
|
CLI-NUM-CONFLICT-NEXT: Global define #2: #STRVAR=42 (parsed as: {{\[\[#STRVAR:42\]\]}})
|
|
CLI-NUM-CONFLICT-NEXT: {{^ \^$}}
|
|
|
|
; Numeric variable definition with too big value.
|
|
RUN: not FileCheck --check-prefix BIGVAL --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix BIGVAL-MSG %s
|
|
|
|
BIG VALUE
|
|
NUMVAR: 10000000000000000000000
|
|
BIGVAL-LABEL: BIG VALUE
|
|
BIGVAL-NEXT: NUMVAR: [[#NUMVAR:]]
|
|
BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: Unable to represent numeric value
|
|
BIGVAL-MSG-NEXT: {{N}}UMVAR: 10000000000000000000000
|
|
BIGVAL-MSG-NEXT: {{^ \^$}}
|
|
|
|
; Verify that when a variable is set to an expression the expression is still
|
|
; checked.
|
|
RUN: not FileCheck --check-prefix DEF-EXPR-FAIL --input-file %s %s 2>&1 \
|
|
RUN: | FileCheck --strict-whitespace --check-prefix DEF-EXPR-FAIL-MSG %s
|
|
|
|
DEF EXPR WRONG MATCH
|
|
20
|
|
43
|
|
DEF-EXPR-FAIL-LABEL: DEF EXPR WRONG MATCH
|
|
DEF-EXPR-FAIL-NEXT: [[# VAR20:]]
|
|
DEF-EXPR-FAIL-NEXT: [[# VAR42: VAR20+22]]
|
|
DEF-EXPR-FAIL-MSG: numeric-expression.txt:[[#@LINE-1]]:21: error: {{D}}EF-EXPR-FAIL-NEXT: is not on the line after the previous match
|
|
DEF-EXPR-FAIL-MSG-NEXT: {{D}}EF-EXPR-FAIL-NEXT: {{\[\[# VAR42: VAR20\+22\]\]}}
|
|
DEF-EXPR-FAIL-MSG-NEXT: {{^ \^$}}
|