blob: 520c4aedd7ab0737a0d8051f1b33e9433d4b9f8c [file] [log] [blame]
# Copyright (C) 2014 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from collections import namedtuple
from common.immutables import ImmutableDict
from common.logger import Logger
from file_format.c1visualizer.struct import C1visualizerFile, C1visualizerPass
from file_format.checker.struct import CheckerFile, TestCase, TestAssertion
from match.line import MatchLines, EvaluateLine
MatchScope = namedtuple("MatchScope", ["start", "end"])
MatchInfo = namedtuple("MatchInfo", ["scope", "variables"])
class MatchFailedException(Exception):
def __init__(self, assertion, lineNo, variables):
self.assertion = assertion
self.lineNo = lineNo
self.variables = variables
def splitIntoGroups(assertions):
""" Breaks up a list of assertions, grouping instructions which should be
tested in the same scope (consecutive DAG and NOT instructions).
"""
splitAssertions = []
lastVariant = None
for assertion in assertions:
if (assertion.variant == lastVariant and
assertion.variant in [TestAssertion.Variant.DAG, TestAssertion.Variant.Not]):
splitAssertions[-1].append(assertion)
else:
splitAssertions.append([assertion])
lastVariant = assertion.variant
return splitAssertions
def findMatchingLine(assertion, c1Pass, scope, variables, excludeLines=[]):
""" Finds the first line in `c1Pass` which matches `assertion`.
Scan only lines numbered between `scope.start` and `scope.end` and not on the
`excludeLines` list.
Returns the index of the `c1Pass` line matching the assertion and variables
values after the match.
Raises MatchFailedException if no such `c1Pass` line can be found.
"""
for i in range(scope.start, scope.end):
if i in excludeLines: continue
newVariables = MatchLines(assertion, c1Pass.body[i], variables)
if newVariables is not None:
return MatchInfo(MatchScope(i, i), newVariables)
raise MatchFailedException(assertion, scope.start, variables)
def matchDagGroup(assertions, c1Pass, scope, variables):
""" Attempts to find matching `c1Pass` lines for a group of DAG assertions.
Assertions are matched in the list order and variable values propagated. Only
lines in `scope` are scanned and each line can only match one assertion.
Returns the range of `c1Pass` lines covered by this group (min/max of matching
line numbers) and the variable values after the match of the last assertion.
Raises MatchFailedException when an assertion cannot be satisfied.
"""
matchedLines = []
for assertion in assertions:
assert assertion.variant == TestAssertion.Variant.DAG
match = findMatchingLine(assertion, c1Pass, scope, variables, matchedLines)
variables = match.variables
assert match.scope.start == match.scope.end
assert match.scope.start not in matchedLines
matchedLines.append(match.scope.start)
return MatchInfo(MatchScope(min(matchedLines), max(matchedLines)), variables)
def testNotGroup(assertions, c1Pass, scope, variables):
""" Verifies that none of the given NOT assertions matches a line inside
the given `scope` of `c1Pass` lines.
Raises MatchFailedException if an assertion matches a line in the scope.
"""
for i in range(scope.start, scope.end):
line = c1Pass.body[i]
for assertion in assertions:
assert assertion.variant == TestAssertion.Variant.Not
if MatchLines(assertion, line, variables) is not None:
raise MatchFailedException(assertion, i, variables)
def testEvalGroup(assertions, scope, variables):
for assertion in assertions:
if not EvaluateLine(assertion, variables):
raise MatchFailedException(assertion, scope.start, variables)
def MatchTestCase(testCase, c1Pass):
""" Runs a test case against a C1visualizer graph dump.
Raises MatchFailedException when an assertion cannot be satisfied.
"""
assert testCase.name == c1Pass.name
matchFrom = 0
variables = ImmutableDict()
c1Length = len(c1Pass.body)
# NOT assertions are verified retrospectively, once the scope is known.
pendingNotAssertions = None
# Prepare assertions by grouping those that are verified in the same scope.
# We also add None as an EOF assertion that will set scope for NOTs.
assertionGroups = splitIntoGroups(testCase.assertions)
assertionGroups.append(None)
for assertionGroup in assertionGroups:
if assertionGroup is None:
# EOF marker always matches the last+1 line of c1Pass.
match = MatchInfo(MatchScope(c1Length, c1Length), None)
elif assertionGroup[0].variant == TestAssertion.Variant.Not:
# NOT assertions will be tested together with the next group.
assert not pendingNotAssertions
pendingNotAssertions = assertionGroup
continue
elif assertionGroup[0].variant == TestAssertion.Variant.InOrder:
# Single in-order assertion. Find the first line that matches.
assert len(assertionGroup) == 1
scope = MatchScope(matchFrom, c1Length)
match = findMatchingLine(assertionGroup[0], c1Pass, scope, variables)
elif assertionGroup[0].variant == TestAssertion.Variant.NextLine:
# Single next-line assertion. Test if the current line matches.
assert len(assertionGroup) == 1
scope = MatchScope(matchFrom, matchFrom + 1)
match = findMatchingLine(assertionGroup[0], c1Pass, scope, variables)
elif assertionGroup[0].variant == TestAssertion.Variant.DAG:
# A group of DAG assertions. Match them all starting from the same point.
scope = MatchScope(matchFrom, c1Length)
match = matchDagGroup(assertionGroup, c1Pass, scope, variables)
else:
assert assertionGroup[0].variant == TestAssertion.Variant.Eval
scope = MatchScope(matchFrom, c1Length)
testEvalGroup(assertionGroup, scope, variables)
continue
if pendingNotAssertions:
# Previous group were NOT assertions. Make sure they don't match any lines
# in the [matchFrom, match.start) scope.
scope = MatchScope(matchFrom, match.scope.start)
testNotGroup(pendingNotAssertions, c1Pass, scope, variables)
pendingNotAssertions = None
# Update state.
assert matchFrom <= match.scope.end
matchFrom = match.scope.end + 1
variables = match.variables
def MatchFiles(checkerFile, c1File, targetArch, debuggableMode):
for testCase in checkerFile.testCases:
if testCase.testArch not in [None, targetArch]:
continue
if testCase.forDebuggable != debuggableMode:
continue
# TODO: Currently does not handle multiple occurrences of the same group
# name, e.g. when a pass is run multiple times. It will always try to
# match a check group against the first output group of the same name.
c1Pass = c1File.findPass(testCase.name)
if c1Pass is None:
Logger.fail("Test case not found in the CFG file",
testCase.fileName, testCase.startLineNo, testCase.name)
Logger.startTest(testCase.name)
try:
MatchTestCase(testCase, c1Pass)
Logger.testPassed()
except MatchFailedException as e:
lineNo = c1Pass.startLineNo + e.lineNo
if e.assertion.variant == TestAssertion.Variant.Not:
msg = "NOT assertion matched line {}"
else:
msg = "Assertion could not be matched starting from line {}"
msg = msg.format(lineNo)
Logger.testFailed(msg, e.assertion, e.variables)