diff --git a/llvm/docs/ReleaseNotes.rst b/llvm/docs/ReleaseNotes.rst --- a/llvm/docs/ReleaseNotes.rst +++ b/llvm/docs/ReleaseNotes.rst @@ -309,6 +309,13 @@ 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=`` 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 --- a/llvm/utils/lit/lit/BooleanExpression.py +++ b/llvm/utils/lit/lit/BooleanExpression.py @@ -22,24 +22,22 @@ # # 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 @@ 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 @@ 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 --- a/llvm/utils/lit/lit/Test.py +++ b/llvm/utils/lit/lit/Test.py @@ -227,9 +227,9 @@ 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 @@ # 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 @@ 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 @@ 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))