[llvm] a0f8bdb - [lit] Stop supporting triple substrings in UNSUPPORTED and XFAIL
Paul Robinson via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 19 08:35:15 PST 2023
Author: Paul Robinson
Date: 2023-01-19T08:35:02-08:00
New Revision: a0f8bdbb18a82ec150515d24f6eefb3519d4459a
URL: https://github.com/llvm/llvm-project/commit/a0f8bdbb18a82ec150515d24f6eefb3519d4459a
DIFF: https://github.com/llvm/llvm-project/commit/a0f8bdbb18a82ec150515d24f6eefb3519d4459a.diff
LOG: [lit] Stop supporting triple substrings in UNSUPPORTED and XFAIL
AFAICT all in-tree lit tests have been converted to use `target=...`
and so there is no longer any need for triples being special.
Some project config files still define their own features based on
the triple, but those are normal feature words (although now are
redundant with target= checks).
Downstream tests that use triple substrings will need to convert.
For example:
UNSUPPORTED: -aix
XFAIL: arm
becomes
UNSUPPORTED: target={{.*}}-aix{{.*}}
XFAIL: target=arm{{.*}}
You can do
git log --grep "special handling for triples"
to find many examples of updates to the upstream tests.
https://discourse.llvm.org/t/rfc-lits-requires-and-triples/66041
Differential Revision: https://reviews.llvm.org/D141007
Added:
Modified:
llvm/docs/ReleaseNotes.rst
llvm/utils/lit/lit/BooleanExpression.py
llvm/utils/lit/lit/Test.py
Removed:
################################################################################
diff --git a/llvm/docs/ReleaseNotes.rst b/llvm/docs/ReleaseNotes.rst
index 6dc2dad13ad93..783e8f5617fe0 100644
--- a/llvm/docs/ReleaseNotes.rst
+++ b/llvm/docs/ReleaseNotes.rst
@@ -309,6 +309,13 @@ Changes to Sanitizers
Other Changes
-------------
+* lit no longer supports using substrings of the default target triple as
+ feature names in ``UNSUPPORTED:`` and ``XFAIL:`` directives. These have been
+ replaced by the ``target=<triple>`` feature, and tests can use regex
+ matching to achieve the same effect. For example, ``UNSUPPORTED: arm``
+ would now be ``UNSUPPORTED: target=arm{{.*}}`` and ``XFAIL: windows``
+ would now be ``XFAIL: target={{.*}}-windows{{.*}}``.
+
External Open Source Projects Using LLVM 15
===========================================
diff --git a/llvm/utils/lit/lit/BooleanExpression.py b/llvm/utils/lit/lit/BooleanExpression.py
index ff5352778e99c..ba8453d60e98a 100644
--- a/llvm/utils/lit/lit/BooleanExpression.py
+++ b/llvm/utils/lit/lit/BooleanExpression.py
@@ -22,24 +22,22 @@ class BooleanExpression:
#
# Variables in `variables` are true.
# Regexes that match any variable in `variables` are true.
- # Substrings of `triple` are true.
# 'true' is true.
# All other identifiers are false.
@staticmethod
- def evaluate(string, variables, triple=""):
+ def evaluate(string, variables):
try:
- parser = BooleanExpression(string, set(variables), triple)
+ parser = BooleanExpression(string, set(variables))
return parser.parseAll()
except ValueError as e:
raise ValueError(str(e) + ('\nin expression: %r' % string))
#####
- def __init__(self, string, variables, triple=""):
+ def __init__(self, string, variables):
self.tokens = BooleanExpression.tokenize(string)
self.variables = variables
self.variables.add('true')
- self.triple = triple
self.value = None
self.token = None
@@ -101,7 +99,7 @@ def parseMATCH(self):
else:
regex += re.escape(part)
regex = re.compile(regex)
- self.value = self.token in self.triple or any(regex.fullmatch(var) for var in self.variables)
+ self.value = any(regex.fullmatch(var) for var in self.variables)
self.token = next(self.tokens)
def parseNOT(self):
@@ -174,20 +172,6 @@ def test_variables(self):
self.assertFalse(BooleanExpression.evaluate('tru', variables))
self.assertFalse(BooleanExpression.evaluate('{{its-true.+}}', variables))
- def test_triple(self):
- triple = 'arch-vendor-os'
- self.assertTrue(BooleanExpression.evaluate('arch-', {}, triple))
- self.assertTrue(BooleanExpression.evaluate('ar', {}, triple))
- self.assertTrue(BooleanExpression.evaluate('ch-vend', {}, triple))
- self.assertTrue(BooleanExpression.evaluate('-vendor-', {}, triple))
- self.assertTrue(BooleanExpression.evaluate('-os', {}, triple))
- self.assertFalse(BooleanExpression.evaluate('arch-os', {}, triple))
-
- # When matching against the triple, a regex is treated as an identifier and checked
- # for a literal match. This preserves existing behavior before regexes were introduced.
- self.assertFalse(BooleanExpression.evaluate('arch-{{vendor}}-os', {}, triple))
- self.assertTrue(BooleanExpression.evaluate('arch-{{vendor}}-os', {}, 'arch-{{vendor}}-os'))
-
def test_matching(self):
expr1 = 'linux && (target={{aarch64-.+}} || target={{x86_64-.+}})'
self.assertTrue(BooleanExpression.evaluate(expr1, {'linux', 'target=x86_64-unknown-linux-gnu'}))
diff --git a/llvm/utils/lit/lit/Test.py b/llvm/utils/lit/lit/Test.py
index dc1c66e896c54..6c72359440b9c 100644
--- a/llvm/utils/lit/lit/Test.py
+++ b/llvm/utils/lit/lit/Test.py
@@ -227,9 +227,9 @@ def __init__(self, suite, path_in_suite, config, file_path = None, gtest_json_fi
self.gtest_json_file = gtest_json_file
# A list of conditions under which this test is expected to fail.
- # Each condition is a boolean expression of features and target
- # triple parts. These can optionally be provided by test format
- # handlers, and will be honored when the test result is supplied.
+ # Each condition is a boolean expression of features, or '*'.
+ # These can optionally be provided by test format handlers,
+ # and will be honored when the test result is supplied.
self.xfails = []
# If true, ignore all items in self.xfails.
@@ -238,12 +238,11 @@ def __init__(self, suite, path_in_suite, config, file_path = None, gtest_json_fi
# A list of conditions that must be satisfied before running the test.
# Each condition is a boolean expression of features. All of them
# must be True for the test to run.
- # FIXME should target triple parts count here too?
self.requires = []
# A list of conditions that prevent execution of the test.
- # Each condition is a boolean expression of features and target
- # triple parts. All of them must be False for the test to run.
+ # Each condition is a boolean expression of features. All of them
+ # must be False for the test to run.
self.unsupported = []
# An optional number of retries allowed before the test finally succeeds.
@@ -317,18 +316,16 @@ def isExpectedToFail(self):
return False
features = self.config.available_features
- triple = getattr(self.suite.config, 'target_triple', "")
- # Check if any of the xfails match an available feature or the target.
+ # Check if any of the xfails match an available feature.
for item in self.xfails:
# If this is the wildcard, it always fails.
if item == '*':
return True
- # If this is a True expression of features and target triple parts,
- # it fails.
+ # If this is a True expression of features, it fails.
try:
- if BooleanExpression.evaluate(item, features, triple):
+ if BooleanExpression.evaluate(item, features):
return True
except ValueError as e:
raise ValueError('Error in XFAIL list:\n%s' % str(e))
@@ -385,16 +382,15 @@ def getUnsupportedFeatures(self):
getUnsupportedFeatures() -> list of strings
Returns a list of features from UNSUPPORTED that are present
- in the test configuration's features or target triple.
+ in the test configuration's features.
Throws ValueError if an UNSUPPORTED line has a syntax error.
"""
features = self.config.available_features
- triple = getattr(self.suite.config, 'target_triple', "")
try:
return [item for item in self.unsupported
- if BooleanExpression.evaluate(item, features, triple)]
+ if BooleanExpression.evaluate(item, features)]
except ValueError as e:
raise ValueError('Error in UNSUPPORTED list:\n%s' % str(e))
More information about the llvm-commits
mailing list