This is an archive of the discontinued LLVM Phabricator instance.

Differential D123859

[NFC][UpdateTestChecks] Fix whitespace in common.py and asm.py
ClosedPublic

Authored by kovdan01 on Apr 15 2022, 8:10 AM.

Details

Reviewers
tra
MaskRay
Commits
rGb1bb76a731d2: [NFC][UpdateTestChecks] Fix whitespace in common.py and asm.py
Summary

While working on D122986, noticed that indentation size varies even within
one file. Fixed that - now indentation is 2 spaces everywhere. This indentation
size was chosen as the most common one.

Diff Detail

Event Timeline

kovdan01 created this revision.Apr 15 2022, 8:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 8:10 AM
Herald added subscribers: StephenFan, arichardson. · View Herald Transcript
kovdan01 requested review of this revision.Apr 15 2022, 8:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 8:10 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
This revision was not accepted when it landed; it landed in state Needs Review.Apr 15 2022, 8:12 AM
This revision was landed with ongoing or failed builds.
Closed by commit rGb1bb76a731d2: [NFC][UpdateTestChecks] Fix whitespace in common.py and asm.py (authored by kovdan01). · Explain Why
This revision was automatically updated to reflect the committed changes.
kovdan01 added a commit: rGb1bb76a731d2: [NFC][UpdateTestChecks] Fix whitespace in common.py and asm.py.
Harbormaster completed remote builds in B159847: Diff 423112.Apr 15 2022, 9:10 AM
MaskRay added a comment.Apr 15 2022, 9:51 AM

LGTM. Thanks!

Revision Contents

PathSize
llvm/
utils/
UpdateTestChecks/
68 lines
198 lines

Diff 423112

llvm/utils/UpdateTestChecks/asm.py

Show All 17 LinesASM_FUNCTION_X86_RE = re.compile(
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*(@"?(?P=func)"?| -- Begin function (?P=func))\n(?:\s*\.?Lfunc_begin[^:\n]*:\n)?' r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*(@"?(?P=func)"?| -- Begin function (?P=func))\n(?:\s*\.?Lfunc_begin[^:\n]*:\n)?'
r'(?:\.L[^$]+\$local:\n)?' # drop .L<func>$local: r'(?:\.L[^$]+\$local:\n)?' # drop .L<func>$local:
r'(?:[ \t]+.cfi_startproc\n|.seh_proc[^\n]+\n)?' # drop optional cfi r'(?:[ \t]+.cfi_startproc\n|.seh_proc[^\n]+\n)?' # drop optional cfi
r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*' r'(?P<body>^##?[ \t]+[^:]+:.*?)\s*'
r'^\s*(?:[^:\n]+?:\s*\n\s*\.size|\.cfi_endproc|\.globl|\.comm|\.(?:sub)?section|#+ -- End function)', r'^\s*(?:[^:\n]+?:\s*\n\s*\.size|\.cfi_endproc|\.globl|\.comm|\.(?:sub)?section|#+ -- End function)',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_ARM_RE = re.compile( ASM_FUNCTION_ARM_RE = re.compile(
r'^(?P<func>[0-9a-zA-Z_]+):\n' # f: (name of function) r'^(?P<func>[0-9a-zA-Z_]+):\n' # f: (name of function)
r'\s+\.fnstart\n' # .fnstart r'\s+\.fnstart\n' # .fnstart
r'(?P<body>.*?)\n' # (body of the function) r'(?P<body>.*?)\n' # (body of the function)
r'.Lfunc_end[0-9]+:', # .Lfunc_end0: or # -- End function r'.Lfunc_end[0-9]+:', # .Lfunc_end0: or # -- End function
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_AARCH64_RE = re.compile( ASM_FUNCTION_AARCH64_RE = re.compile(
r'^_?(?P<func>[^:]+):[ \t]*\/\/[ \t]*@"?(?P=func)"?( (Function|Tail Call))?\n' r'^_?(?P<func>[^:]+):[ \t]*\/\/[ \t]*@"?(?P=func)"?( (Function|Tail Call))?\n'
r'(?:[ \t]+.cfi_startproc\n)?' # drop optional cfi noise r'(?:[ \t]+.cfi_startproc\n)?' # drop optional cfi noise
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
# This list is incomplete # This list is incomplete
r'.Lfunc_end[0-9]+:\n', r'.Lfunc_end[0-9]+:\n',
flags=(re.M | re.S)) flags=(re.M | re.S))
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
ASM_FUNCTION_SYSTEMZ_RE = re.compile( ASM_FUNCTION_SYSTEMZ_RE = re.compile(
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n' r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
r'[ \t]+.cfi_startproc\n' r'[ \t]+.cfi_startproc\n'
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
r'.Lfunc_end[0-9]+:\n', r'.Lfunc_end[0-9]+:\n',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_AARCH64_DARWIN_RE = re.compile( ASM_FUNCTION_AARCH64_DARWIN_RE = re.compile(
r'^_(?P<func>[^:]+):[ \t]*;[ \t]@"?(?P=func)"?\n' r'^_(?P<func>[^:]+):[ \t]*;[ \t]@"?(?P=func)"?\n'
r'([ \t]*.cfi_startproc\n[\s]*)?' r'([ \t]*.cfi_startproc\n[\s]*)?'
r'(?P<body>.*?)' r'(?P<body>.*?)'
r'([ \t]*.cfi_endproc\n[\s]*)?' r'([ \t]*.cfi_endproc\n[\s]*)?'
r'^[ \t]*;[ \t]--[ \t]End[ \t]function', r'^[ \t]*;[ \t]--[ \t]End[ \t]function',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_ARM_DARWIN_RE = re.compile( ASM_FUNCTION_ARM_DARWIN_RE = re.compile(
r'^[ \t]*\.globl[ \t]*_(?P<func>[^ \t])[ \t]*@[ \t]--[ \t]Begin[ \t]function[ \t]"?(?P=func)"?' r'^[ \t]*\.globl[ \t]*_(?P<func>[^ \t])[ \t]*@[ \t]--[ \t]Begin[ \t]function[ \t]"?(?P=func)"?'
r'(?P<directives>.*?)' r'(?P<directives>.*?)'
r'^_(?P=func):\n[ \t]*' r'^_(?P=func):\n[ \t]*'
r'(?P<body>.*?)' r'(?P<body>.*?)'
r'^[ \t]*@[ \t]--[ \t]End[ \t]function', r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
flags=(re.M | re.S )) flags=(re.M | re.S ))
ASM_FUNCTION_ARM_MACHO_RE = re.compile( ASM_FUNCTION_ARM_MACHO_RE = re.compile(
r'^_(?P<func>[^:]+):[ \t]*\n' r'^_(?P<func>[^:]+):[ \t]*\n'
r'([ \t]*.cfi_startproc\n[ \t]*)?' r'([ \t]*.cfi_startproc\n[ \t]*)?'
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
r'[ \t]*\.cfi_endproc\n', r'[ \t]*\.cfi_endproc\n',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_THUMBS_DARWIN_RE = re.compile( ASM_FUNCTION_THUMBS_DARWIN_RE = re.compile(
r'^_(?P<func>[^:]+):\n' r'^_(?P<func>[^:]+):\n'
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
r'[ \t]*\.data_region\n', r'[ \t]*\.data_region\n',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_THUMB_DARWIN_RE = re.compile( ASM_FUNCTION_THUMB_DARWIN_RE = re.compile(
r'^_(?P<func>[^:]+):\n' r'^_(?P<func>[^:]+):\n'
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
r'^[ \t]*@[ \t]--[ \t]End[ \t]function', r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_ARM_IOS_RE = re.compile( ASM_FUNCTION_ARM_IOS_RE = re.compile(
r'^_(?P<func>[^:]+):\n' r'^_(?P<func>[^:]+):\n'
r'(?P<body>.*?)' r'(?P<body>.*?)'
r'^[ \t]*@[ \t]--[ \t]End[ \t]function', r'^[ \t]*@[ \t]--[ \t]End[ \t]function',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_WASM32_RE = re.compile( ASM_FUNCTION_WASM32_RE = re.compile(
r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n' r'^_?(?P<func>[^:]+):[ \t]*#+[ \t]*@"?(?P=func)"?\n'
r'(?P<body>.*?)\n' r'(?P<body>.*?)\n'
r'^\s*(\.Lfunc_end[0-9]+:\n|end_function)', r'^\s*(\.Lfunc_end[0-9]+:\n|end_function)',
flags=(re.M | re.S)) flags=(re.M | re.S))
ASM_FUNCTION_VE_RE = re.compile( ASM_FUNCTION_VE_RE = re.compile(
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

llvm/utils/UpdateTestChecks/common.py

Show First 20 Lines • Show All 223 Lines • ▼ Show 20 Lines if input_line.strip() == comment_marker + SEPARATOR:
return False return False
# Skip any blank lines in the IR. # Skip any blank lines in the IR.
#if input_line.strip() == '': #if input_line.strip() == '':
# return False # return False
# And skip any CHECK lines. We're building our own. # And skip any CHECK lines. We're building our own.
m = CHECK_RE.match(input_line) m = CHECK_RE.match(input_line)
if m and m.group(1) in prefix_set: if m and m.group(1) in prefix_set:
if skip_global_checks: if skip_global_checks:
global_ir_value_re = re.compile('\[\[', flags=(re.M)) global_ir_value_re = re.compile(r'\[\[', flags=(re.M))
return not global_ir_value_re.search(input_line) return not global_ir_value_re.search(input_line)
return False return False
return True return True
# Perform lit-like substitutions # Perform lit-like substitutions
def getSubstitutions(sourcepath): def getSubstitutions(sourcepath):
sourcedir = os.path.dirname(sourcepath) sourcedir = os.path.dirname(sourcepath)
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines def __init__(self, string, extra, args_and_sig, attrs, func_name_separator):
self.scrub = string self.scrub = string
self.extrascrub = extra self.extrascrub = extra
self.args_and_sig = args_and_sig self.args_and_sig = args_and_sig
self.attrs = attrs self.attrs = attrs
self.func_name_separator = func_name_separator self.func_name_separator = func_name_separator
def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs, is_backend): def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs, is_backend):
arg_names = set() arg_names = set()
def drop_arg_names(match): def drop_arg_names(match):
arg_names.add(match.group(variable_group_in_ir_value_match)) arg_names.add(match.group(variable_group_in_ir_value_match))
if match.group(attribute_group_in_ir_value_match): if match.group(attribute_group_in_ir_value_match):
attr = match.group(attribute_group_in_ir_value_match) attr = match.group(attribute_group_in_ir_value_match)
else: else:
attr = '' attr = ''
return match.group(1) + attr + match.group(match.lastindex) return match.group(1) + attr + match.group(match.lastindex)
def repl_arg_names(match): def repl_arg_names(match):
if match.group(variable_group_in_ir_value_match) is not None and match.group(variable_group_in_ir_value_match) in arg_names: if match.group(variable_group_in_ir_value_match) is not None and match.group(variable_group_in_ir_value_match) in arg_names:
return match.group(1) + match.group(match.lastindex) return match.group(1) + match.group(match.lastindex)
return match.group(1) + match.group(2) + match.group(match.lastindex) return match.group(1) + match.group(2) + match.group(match.lastindex)
if self.attrs != attrs: if self.attrs != attrs:
return False return False
ans0 = IR_VALUE_RE.sub(drop_arg_names, self.args_and_sig) ans0 = IR_VALUE_RE.sub(drop_arg_names, self.args_and_sig)
ans1 = IR_VALUE_RE.sub(drop_arg_names, args_and_sig) ans1 = IR_VALUE_RE.sub(drop_arg_names, args_and_sig)
if ans0 != ans1: if ans0 != ans1:
return False return False
if is_backend: if is_backend:
# Check without replacements, the replacements are not applied to the # Check without replacements, the replacements are not applied to the
# body for backend checks. # body for backend checks.
return self.extrascrub == extrascrub return self.extrascrub == extrascrub
es0 = IR_VALUE_RE.sub(repl_arg_names, self.extrascrub) es0 = IR_VALUE_RE.sub(repl_arg_names, self.extrascrub)
es1 = IR_VALUE_RE.sub(repl_arg_names, extrascrub) es1 = IR_VALUE_RE.sub(repl_arg_names, extrascrub)
es0 = SCRUB_IR_COMMENT_RE.sub(r'', es0) es0 = SCRUB_IR_COMMENT_RE.sub(r'', es0)
es1 = SCRUB_IR_COMMENT_RE.sub(r'', es1) es1 = SCRUB_IR_COMMENT_RE.sub(r'', es1)
return es0 == es1 return es0 == es1
def __str__(self): def __str__(self):
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines for m in function_re.finditer(raw_tool_output):
# Use ':' as default separator. # Use ':' as default separator.
func_name_separator = m.group('func_name_separator') if 'func_name_separator' in m.groupdict() else ':' func_name_separator = m.group('func_name_separator') if 'func_name_separator' in m.groupdict() else ':'
else: else:
func_name_separator = '' func_name_separator = ''
attrs = m.group('attrs') if self._check_attributes else '' attrs = m.group('attrs') if self._check_attributes else ''
# Determine if we print arguments, the opening brace, or nothing after the # Determine if we print arguments, the opening brace, or nothing after the
# function name # function name
if self._record_args and 'args_and_sig' in m.groupdict(): if self._record_args and 'args_and_sig' in m.groupdict():
args_and_sig = scrub_body(m.group('args_and_sig').strip()) args_and_sig = scrub_body(m.group('args_and_sig').strip())
elif 'args_and_sig' in m.groupdict(): elif 'args_and_sig' in m.groupdict():
args_and_sig = '(' args_and_sig = '('
else: else:
args_and_sig = '' args_and_sig = ''
filtered_body = do_filter(body, self._filters) filtered_body = do_filter(body, self._filters)
scrubbed_body = do_scrub(filtered_body, scrubber, self._scrubber_args, scrubbed_body = do_scrub(filtered_body, scrubber, self._scrubber_args,
extra=False) extra=False)
scrubbed_extra = do_scrub(filtered_body, scrubber, self._scrubber_args, scrubbed_extra = do_scrub(filtered_body, scrubber, self._scrubber_args,
extra=True) extra=True)
if 'analysis' in m.groupdict(): if 'analysis' in m.groupdict():
analysis = m.group('analysis') analysis = m.group('analysis')
if analysis.lower() != 'cost model analysis': if analysis.lower() != 'cost model analysis':
warn('Unsupported analysis mode: %r!' % (analysis,)) warn('Unsupported analysis mode: %r!' % (analysis,))
if func.startswith('stress'): if func.startswith('stress'):
# We only use the last line of the function body for stress tests. # We only use the last line of the function body for stress tests.
scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:]) scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:])
if self._verbose: if self._verbose:
print('Processing function: ' + func, file=sys.stderr) print('Processing function: ' + func, file=sys.stderr)
for l in scrubbed_body.splitlines(): for l in scrubbed_body.splitlines():
print(' ' + l, file=sys.stderr) print(' ' + l, file=sys.stderr)
for prefix in prefixes: for prefix in prefixes:
# Replace function names matching the regex. # Replace function names matching the regex.
for regex in self._replace_value_regex: for regex in self._replace_value_regex:
# Pattern that matches capture groups in the regex in leftmost order. # Pattern that matches capture groups in the regex in leftmost order.
group_regex = re.compile('\(.*?\)') group_regex = re.compile(r'\(.*?\)')
# Replace function name with regex. # Replace function name with regex.
match = re.match(regex, func) match = re.match(regex, func)
if match: if match:
func_repl = regex func_repl = regex
# Replace any capture groups with their matched strings. # Replace any capture groups with their matched strings.
for g in match.groups(): for g in match.groups():
func_repl = group_regex.sub(re.escape(g), func_repl, count=1) func_repl = group_regex.sub(re.escape(g), func_repl, count=1)
func = re.sub(func_repl, '{{' + func_repl + '}}', func) func = re.sub(func_repl, '{{' + func_repl + '}}', func)
# Replace all calls to regex matching functions. # Replace all calls to regex matching functions.
matches = re.finditer(regex, scrubbed_body) matches = re.finditer(regex, scrubbed_body)
for match in matches: for match in matches:
func_repl = regex func_repl = regex
# Replace any capture groups with their matched strings. # Replace any capture groups with their matched strings.
for g in match.groups(): for g in match.groups():
func_repl = group_regex.sub(re.escape(g), func_repl, count=1) func_repl = group_regex.sub(re.escape(g), func_repl, count=1)
# Substitute function call names that match the regex with the same # Substitute function call names that match the regex with the same
# capture groups set. # capture groups set.
scrubbed_body = re.sub(func_repl, '{{' + func_repl + '}}', scrubbed_body = re.sub(func_repl, '{{' + func_repl + '}}',
scrubbed_body) scrubbed_body)
if func in self._func_dict[prefix]: if func in self._func_dict[prefix]:
if (self._func_dict[prefix][func] is None or if (self._func_dict[prefix][func] is None or
str(self._func_dict[prefix][func]) != scrubbed_body or str(self._func_dict[prefix][func]) != scrubbed_body or
Show All 34 Lines
##### Generator of LLVM IR CHECK lines ##### Generator of LLVM IR CHECK lines
SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*') SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*')
# TODO: We should also derive check lines for global, debug, loop declarations, etc.. # TODO: We should also derive check lines for global, debug, loop declarations, etc..
class NamelessValue: class NamelessValue:
def __init__(self, check_prefix, check_key, ir_prefix, global_ir_prefix, global_ir_prefix_regexp, def __init__(self, check_prefix, check_key, ir_prefix, global_ir_prefix, global_ir_prefix_regexp,
ir_regexp, global_ir_rhs_regexp, is_before_functions): ir_regexp, global_ir_rhs_regexp, is_before_functions):
self.check_prefix = check_prefix self.check_prefix = check_prefix
self.check_key = check_key self.check_key = check_key
self.ir_prefix = ir_prefix self.ir_prefix = ir_prefix
self.global_ir_prefix = global_ir_prefix self.global_ir_prefix = global_ir_prefix
self.global_ir_prefix_regexp = global_ir_prefix_regexp self.global_ir_prefix_regexp = global_ir_prefix_regexp
self.ir_regexp = ir_regexp self.ir_regexp = ir_regexp
self.global_ir_rhs_regexp = global_ir_rhs_regexp self.global_ir_rhs_regexp = global_ir_rhs_regexp
self.is_before_functions = is_before_functions self.is_before_functions = is_before_functions
# Description of the different "unnamed" values we match in the IR, e.g., # Description of the different "unnamed" values we match in the IR, e.g.,
# (local) ssa values, (debug) metadata, etc. # (local) ssa values, (debug) metadata, etc.
nameless_values = [ nameless_values = [
NamelessValue(r'TMP' , '%' , r'%' , None , None , r'[\w$.-]+?' , None , False) , NamelessValue(r'TMP' , '%' , r'%' , None , None , r'[\w$.-]+?' , None , False) ,
NamelessValue(r'ATTR' , '#' , r'#' , None , None , r'[0-9]+' , None , False) , NamelessValue(r'ATTR' , '#' , r'#' , None , None , r'[0-9]+' , None , False) ,
NamelessValue(r'ATTR' , '#' , None , r'attributes #' , r'[0-9]+' , None , r'{[^}]*}' , False) , NamelessValue(r'ATTR' , '#' , None , r'attributes #' , r'[0-9]+' , None , r'{[^}]*}' , False) ,
NamelessValue(r'GLOB' , '@' , r'@' , None , None , r'[0-9]+' , None , False) , NamelessValue(r'GLOB' , '@' , r'@' , None , None , r'[0-9]+' , None , False) ,
NamelessValue(r'GLOB' , '@' , None , r'@' , r'[a-zA-Z0-9_$"\\.-]+' , None , r'.+' , True) , NamelessValue(r'GLOB' , '@' , None , r'@' , r'[a-zA-Z0-9_$"\\.-]+' , None , r'.+' , True) ,
NamelessValue(r'DBG' , '!' , r'!dbg ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'DBG' , '!' , r'!dbg ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'PROF' , '!' , r'!prof ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'PROF' , '!' , r'!prof ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'TBAA' , '!' , r'!tbaa ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'TBAA' , '!' , r'!tbaa ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'RNG' , '!' , r'!range ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'RNG' , '!' , r'!range ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'LOOP' , '!' , r'!llvm.loop ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'LOOP' , '!' , r'!llvm.loop ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'META' , '!' , r'metadata ' , None , None , r'![0-9]+' , None , False) , NamelessValue(r'META' , '!' , r'metadata ' , None , None , r'![0-9]+' , None , False) ,
NamelessValue(r'META' , '!' , None , r'' , r'![0-9]+' , None , r'(?:distinct |)!.*' , False) , NamelessValue(r'META' , '!' , None , r'' , r'![0-9]+' , None , r'(?:distinct |)!.*' , False) ,
] ]
def createOrRegexp(old, new): def createOrRegexp(old, new):
if not old: if not old:
return new return new
if not new: if not new:
return old return old
return old + '|' + new return old + '|' + new
def createPrefixMatch(prefix_str, prefix_re): def createPrefixMatch(prefix_str, prefix_re):
if prefix_str is None or prefix_re is None: if prefix_str is None or prefix_re is None:
return '' return ''
return '(?:' + prefix_str + '(' + prefix_re + '))' return '(?:' + prefix_str + '(' + prefix_re + '))'
# Build the regexp that matches an "IR value". This can be a local variable, # Build the regexp that matches an "IR value". This can be a local variable,
# argument, global, or metadata, anything that is "named". It is important that # argument, global, or metadata, anything that is "named". It is important that
# the PREFIX and SUFFIX below only contain a single group, if that changes # the PREFIX and SUFFIX below only contain a single group, if that changes
# other locations will need adjustment as well. # other locations will need adjustment as well.
IR_VALUE_REGEXP_PREFIX = r'(\s*)' IR_VALUE_REGEXP_PREFIX = r'(\s*)'
IR_VALUE_REGEXP_STRING = r'' IR_VALUE_REGEXP_STRING = r''
for nameless_value in nameless_values: for nameless_value in nameless_values:
lcl_match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp) lcl_match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
glb_match = createPrefixMatch(nameless_value.global_ir_prefix, nameless_value.global_ir_prefix_regexp) glb_match = createPrefixMatch(nameless_value.global_ir_prefix, nameless_value.global_ir_prefix_regexp)
assert((lcl_match or glb_match) and not (lcl_match and glb_match)) assert((lcl_match or glb_match) and not (lcl_match and glb_match))
if lcl_match: if lcl_match:
IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, lcl_match) IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, lcl_match)
elif glb_match: elif glb_match:
IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, '^' + glb_match) IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, '^' + glb_match)
IR_VALUE_REGEXP_SUFFIX = r'([,\s\(\)]|\Z)' IR_VALUE_REGEXP_SUFFIX = r'([,\s\(\)]|\Z)'
IR_VALUE_RE = re.compile(IR_VALUE_REGEXP_PREFIX + r'(' + IR_VALUE_REGEXP_STRING + r')' + IR_VALUE_REGEXP_SUFFIX) IR_VALUE_RE = re.compile(IR_VALUE_REGEXP_PREFIX + r'(' + IR_VALUE_REGEXP_STRING + r')' + IR_VALUE_REGEXP_SUFFIX)
# The entire match is group 0, the prefix has one group (=1), the entire # The entire match is group 0, the prefix has one group (=1), the entire
# IR_VALUE_REGEXP_STRING is one group (=2), and then the nameless values start. # IR_VALUE_REGEXP_STRING is one group (=2), and then the nameless values start.
first_nameless_group_in_ir_value_match = 3 first_nameless_group_in_ir_value_match = 3
# constants for the group id of special matches # constants for the group id of special matches
variable_group_in_ir_value_match = 3 variable_group_in_ir_value_match = 3
attribute_group_in_ir_value_match = 4 attribute_group_in_ir_value_match = 4
# Check a match for IR_VALUE_RE and inspect it to determine if it was a local # Check a match for IR_VALUE_RE and inspect it to determine if it was a local
# value, %..., global @..., debug number !dbg !..., etc. See the PREFIXES above. # value, %..., global @..., debug number !dbg !..., etc. See the PREFIXES above.
def get_idx_from_ir_value_match(match): def get_idx_from_ir_value_match(match):
for i in range(first_nameless_group_in_ir_value_match, match.lastindex): for i in range(first_nameless_group_in_ir_value_match, match.lastindex):
if match.group(i) is not None: if match.group(i) is not None:
return i - first_nameless_group_in_ir_value_match return i - first_nameless_group_in_ir_value_match
error("Unable to identify the kind of IR value from the match!") error("Unable to identify the kind of IR value from the match!")
return 0 return 0
# See get_idx_from_ir_value_match # See get_idx_from_ir_value_match
def get_name_from_ir_value_match(match): def get_name_from_ir_value_match(match):
return match.group(get_idx_from_ir_value_match(match) + first_nameless_group_in_ir_value_match) return match.group(get_idx_from_ir_value_match(match) + first_nameless_group_in_ir_value_match)
# Return the nameless prefix we use for this kind or IR value, see also # Return the nameless prefix we use for this kind or IR value, see also
# get_idx_from_ir_value_match # get_idx_from_ir_value_match
def get_nameless_check_prefix_from_ir_value_match(match): def get_nameless_check_prefix_from_ir_value_match(match):
return nameless_values[get_idx_from_ir_value_match(match)].check_prefix return nameless_values[get_idx_from_ir_value_match(match)].check_prefix
# Return the IR prefix and check prefix we use for this kind or IR value, e.g., (%, TMP) for locals, # Return the IR prefix and check prefix we use for this kind or IR value, e.g., (%, TMP) for locals,
# see also get_idx_from_ir_value_match # see also get_idx_from_ir_value_match
def get_ir_prefix_from_ir_value_match(match): def get_ir_prefix_from_ir_value_match(match):
idx = get_idx_from_ir_value_match(match) idx = get_idx_from_ir_value_match(match)
if nameless_values[idx].ir_prefix and match.group(0).strip().startswith(nameless_values[idx].ir_prefix): if nameless_values[idx].ir_prefix and match.group(0).strip().startswith(nameless_values[idx].ir_prefix):
return nameless_values[idx].ir_prefix, nameless_values[idx].check_prefix return nameless_values[idx].ir_prefix, nameless_values[idx].check_prefix
return nameless_values[idx].global_ir_prefix, nameless_values[idx].check_prefix return nameless_values[idx].global_ir_prefix, nameless_values[idx].check_prefix
def get_check_key_from_ir_value_match(match): def get_check_key_from_ir_value_match(match):
idx = get_idx_from_ir_value_match(match) idx = get_idx_from_ir_value_match(match)
return nameless_values[idx].check_key return nameless_values[idx].check_key
# Return the IR regexp we use for this kind or IR value, e.g., [\w.-]+? for locals, # Return the IR regexp we use for this kind or IR value, e.g., [\w.-]+? for locals,
# see also get_idx_from_ir_value_match # see also get_idx_from_ir_value_match
def get_ir_prefix_from_ir_value_re_match(match): def get_ir_prefix_from_ir_value_re_match(match):
# for backwards compatibility we check locals with '.*' # for backwards compatibility we check locals with '.*'
if is_local_def_ir_value_match(match): if is_local_def_ir_value_match(match):
return '.*' return '.*'
idx = get_idx_from_ir_value_match(match) idx = get_idx_from_ir_value_match(match)
if nameless_values[idx].ir_prefix and match.group(0).strip().startswith(nameless_values[idx].ir_prefix): if nameless_values[idx].ir_prefix and match.group(0).strip().startswith(nameless_values[idx].ir_prefix):
return nameless_values[idx].ir_regexp return nameless_values[idx].ir_regexp
return nameless_values[idx].global_ir_prefix_regexp return nameless_values[idx].global_ir_prefix_regexp
# Return true if this kind of IR value is "local", basically if it matches '%{{.*}}'. # Return true if this kind of IR value is "local", basically if it matches '%{{.*}}'.
def is_local_def_ir_value_match(match): def is_local_def_ir_value_match(match):
return nameless_values[get_idx_from_ir_value_match(match)].ir_prefix == '%' return nameless_values[get_idx_from_ir_value_match(match)].ir_prefix == '%'
# Return true if this kind of IR value is "global", basically if it matches '#{{.*}}'. # Return true if this kind of IR value is "global", basically if it matches '#{{.*}}'.
def is_global_scope_ir_value_match(match): def is_global_scope_ir_value_match(match):
return nameless_values[get_idx_from_ir_value_match(match)].global_ir_prefix is not None return nameless_values[get_idx_from_ir_value_match(match)].global_ir_prefix is not None
# Return true if var clashes with the scripted FileCheck check_prefix. # Return true if var clashes with the scripted FileCheck check_prefix.
def may_clash_with_default_check_prefix_name(check_prefix, var): def may_clash_with_default_check_prefix_name(check_prefix, var):
return check_prefix and re.match(r'^' + check_prefix + r'[0-9]+?$', var, re.IGNORECASE) return check_prefix and re.match(r'^' + check_prefix + r'[0-9]+?$', var, re.IGNORECASE)
# Create a FileCheck variable name based on an IR name. # Create a FileCheck variable name based on an IR name.
def get_value_name(var, check_prefix): def get_value_name(var, check_prefix):
var = var.replace('!', '') var = var.replace('!', '')
Show All 29 Lines
def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen): def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
# This gets called for each match that occurs in # This gets called for each match that occurs in
# a line. We transform variables we haven't seen # a line. We transform variables we haven't seen
# into defs, and variables we have seen into uses. # into defs, and variables we have seen into uses.
def transform_line_vars(match): def transform_line_vars(match):
pre, check = get_ir_prefix_from_ir_value_match(match) pre, check = get_ir_prefix_from_ir_value_match(match)
var = get_name_from_ir_value_match(match) var = get_name_from_ir_value_match(match)
for nameless_value in nameless_values: for nameless_value in nameless_values:
if may_clash_with_default_check_prefix_name(nameless_value.check_prefix, var): if may_clash_with_default_check_prefix_name(nameless_value.check_prefix, var):
warn("Change IR value name '%s' or use --prefix-filecheck-ir-name to prevent possible conflict" warn("Change IR value name '%s' or use --prefix-filecheck-ir-name to prevent possible conflict"
" with scripted FileCheck name." % (var,)) " with scripted FileCheck name." % (var,))
key = (var, get_check_key_from_ir_value_match(match)) key = (var, get_check_key_from_ir_value_match(match))
is_local_def = is_local_def_ir_value_match(match) is_local_def = is_local_def_ir_value_match(match)
if is_local_def and key in vars_seen: if is_local_def and key in vars_seen:
rv = get_value_use(var, match, get_nameless_check_prefix_from_ir_value_match(match)) rv = get_value_use(var, match, get_nameless_check_prefix_from_ir_value_match(match))
elif not is_local_def and key in global_vars_seen: elif not is_local_def and key in global_vars_seen:
rv = get_value_use(var, match, global_vars_seen[key]) rv = get_value_use(var, match, global_vars_seen[key])
else: else:
if is_local_def: if is_local_def:
vars_seen.add(key) vars_seen.add(key)
else: else:
global_vars_seen[key] = get_nameless_check_prefix_from_ir_value_match(match) global_vars_seen[key] = get_nameless_check_prefix_from_ir_value_match(match)
rv = get_value_definition(var, match) rv = get_value_definition(var, match)
# re.sub replaces the entire regex match # re.sub replaces the entire regex match
# with whatever you return, so we have # with whatever you return, so we have
# to make sure to hand it back everything # to make sure to hand it back everything
# including the commas and spaces. # including the commas and spaces.
return match.group(1) + rv + match.group(match.lastindex) return match.group(1) + rv + match.group(match.lastindex)
lines_with_def = [] lines_with_def = []
Show All 11 Lines for i, line in enumerate(lines):
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line) scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line)
lines[i] = scrubbed_line lines[i] = scrubbed_line
if not is_analyze: if not is_analyze:
# It can happen that two matches are back-to-back and for some reason sub # It can happen that two matches are back-to-back and for some reason sub
# will not replace both of them. For now we work around this by # will not replace both of them. For now we work around this by
# substituting until there is no more match. # substituting until there is no more match.
changed = True changed = True
while changed: while changed:
(lines[i], changed) = IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1) (lines[i], changed) = IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1)
return lines return lines
def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_backend, is_analyze, global_vars_seen_dict, is_filtered): def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_backend, is_analyze, global_vars_seen_dict, is_filtered):
# prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well. # prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well.
prefix_exclusions = set() prefix_exclusions = set()
printed_prefixes = [] printed_prefixes = []
for p in prefix_list: for p in prefix_list:
checkprefixes = p[0] checkprefixes = p[0]
# If not all checkprefixes of this run line produced the function we cannot check for it as it does not # If not all checkprefixes of this run line produced the function we cannot check for it as it does not
# exist for this run line. A subset of the check prefixes might know about the function but only because # exist for this run line. A subset of the check prefixes might know about the function but only because
# other run lines created it. # other run lines created it.
if any(map(lambda checkprefix: func_name not in func_dict[checkprefix], checkprefixes)): if any(map(lambda checkprefix: func_name not in func_dict[checkprefix], checkprefixes)):
prefix_exclusions |= set(checkprefixes) prefix_exclusions |= set(checkprefixes)
continue continue
# prefix_exclusions is constructed, we can now emit the output # prefix_exclusions is constructed, we can now emit the output
for p in prefix_list: for p in prefix_list:
global_vars_seen = {} global_vars_seen = {}
checkprefixes = p[0] checkprefixes = p[0]
for checkprefix in checkprefixes: for checkprefix in checkprefixes:
if checkprefix in global_vars_seen_dict: if checkprefix in global_vars_seen_dict:
global_vars_seen.update(global_vars_seen_dict[checkprefix]) global_vars_seen.update(global_vars_seen_dict[checkprefix])
Show All 12 Lines for checkprefix in checkprefixes:
# Add some space between different check prefixes, but not after the last # Add some space between different check prefixes, but not after the last
# check line (before the test code). # check line (before the test code).
if is_backend: if is_backend:
if len(printed_prefixes) != 0: if len(printed_prefixes) != 0:
output_lines.append(comment_marker) output_lines.append(comment_marker)
if checkprefix not in global_vars_seen_dict: if checkprefix not in global_vars_seen_dict:
global_vars_seen_dict[checkprefix] = {} global_vars_seen_dict[checkprefix] = {}
global_vars_seen_before = [key for key in global_vars_seen.keys()] global_vars_seen_before = [key for key in global_vars_seen.keys()]
vars_seen = set() vars_seen = set()
printed_prefixes.append(checkprefix) printed_prefixes.append(checkprefix)
attrs = str(func_dict[checkprefix][func_name].attrs) attrs = str(func_dict[checkprefix][func_name].attrs)
attrs = '' if attrs == 'None' else attrs attrs = '' if attrs == 'None' else attrs
if attrs: if attrs:
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines for checkprefix in checkprefixes:
is_blank_line = False is_blank_line = False
# Add space between different check prefixes and also before the first # Add space between different check prefixes and also before the first
# line of code in the test function. # line of code in the test function.
output_lines.append(comment_marker) output_lines.append(comment_marker)
# Remembe new global variables we have not seen before # Remembe new global variables we have not seen before
for key in global_vars_seen: for key in global_vars_seen:
if key not in global_vars_seen_before: if key not in global_vars_seen_before:
global_vars_seen_dict[checkprefix][key] = global_vars_seen[key] global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
break break
def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict, def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
func_name, preserve_names, function_sig, func_name, preserve_names, function_sig,
global_vars_seen_dict, is_filtered): global_vars_seen_dict, is_filtered):
# Label format is based on IR string. # Label format is based on IR string.
function_def_regex = 'define {{[^@]+}}' if function_sig else '' function_def_regex = 'define {{[^@]+}}' if function_sig else ''
check_label_format = '{} %s-LABEL: {}@%s%s%s'.format(comment_marker, function_def_regex) check_label_format = '{} %s-LABEL: {}@%s%s%s'.format(comment_marker, function_def_regex)
Show All 15 Lines for nameless_value in nameless_values:
lhs_re_str = nameless_value.global_ir_prefix + nameless_value.global_ir_prefix_regexp lhs_re_str = nameless_value.global_ir_prefix + nameless_value.global_ir_prefix_regexp
rhs_re_str = nameless_value.global_ir_rhs_regexp rhs_re_str = nameless_value.global_ir_rhs_regexp
global_ir_value_re_str = r'^' + lhs_re_str + r'\s=\s' + rhs_re_str + r'$' global_ir_value_re_str = r'^' + lhs_re_str + r'\s=\s' + rhs_re_str + r'$'
global_ir_value_re = re.compile(global_ir_value_re_str, flags=(re.M)) global_ir_value_re = re.compile(global_ir_value_re_str, flags=(re.M))
lines = [] lines = []
for m in global_ir_value_re.finditer(raw_tool_output): for m in global_ir_value_re.finditer(raw_tool_output):
lines.append(m.group(0)) lines.append(m.group(0))
for prefix in prefixes: for prefix in prefixes:
if glob_val_dict[prefix] is None: if glob_val_dict[prefix] is None:
continue continue
if nameless_value.check_prefix in glob_val_dict[prefix]: if nameless_value.check_prefix in glob_val_dict[prefix]:
if lines == glob_val_dict[prefix][nameless_value.check_prefix]: if lines == glob_val_dict[prefix][nameless_value.check_prefix]:
continue continue
if prefix == prefixes[-1]: if prefix == prefixes[-1]:
warn('Found conflicting asm under the same prefix: %r!' % (prefix,)) warn('Found conflicting asm under the same prefix: %r!' % (prefix,))
else: else:
glob_val_dict[prefix][nameless_value.check_prefix] = None glob_val_dict[prefix][nameless_value.check_prefix] = None
continue continue
glob_val_dict[prefix][nameless_value.check_prefix] = lines glob_val_dict[prefix][nameless_value.check_prefix] = lines
def add_global_checks(glob_val_dict, comment_marker, prefix_list, output_lines, global_vars_seen_dict, is_analyze, is_before_functions): def add_global_checks(glob_val_dict, comment_marker, prefix_list, output_lines, global_vars_seen_dict, is_analyze, is_before_functions):
printed_prefixes = set() printed_prefixes = set()
for nameless_value in nameless_values: for nameless_value in nameless_values:
if nameless_value.global_ir_prefix is None: if nameless_value.global_ir_prefix is None:
continue continue
if nameless_value.is_before_functions != is_before_functions: if nameless_value.is_before_functions != is_before_functions:
continue continue
for p in prefix_list: for p in prefix_list:
global_vars_seen = {} global_vars_seen = {}
checkprefixes = p[0] checkprefixes = p[0]
if checkprefixes is None: if checkprefixes is None:
continue continue
for checkprefix in checkprefixes: for checkprefix in checkprefixes:
if checkprefix in global_vars_seen_dict: if checkprefix in global_vars_seen_dict:
global_vars_seen.update(global_vars_seen_dict[checkprefix]) global_vars_seen.update(global_vars_seen_dict[checkprefix])
else: else:
global_vars_seen_dict[checkprefix] = {} global_vars_seen_dict[checkprefix] = {}
if (checkprefix, nameless_value.check_prefix) in printed_prefixes: if (checkprefix, nameless_value.check_prefix) in printed_prefixes:
break break
if not glob_val_dict[checkprefix]: if not glob_val_dict[checkprefix]:
continue continue
if nameless_value.check_prefix not in glob_val_dict[checkprefix]: if nameless_value.check_prefix not in glob_val_dict[checkprefix]:
continue continue
if not glob_val_dict[checkprefix][nameless_value.check_prefix]: if not glob_val_dict[checkprefix][nameless_value.check_prefix]:
continue continue
Show All 18 Lines for p in prefix_list:
output_lines.append(comment_marker + SEPARATOR) output_lines.append(comment_marker + SEPARATOR)
for check_line in check_lines: for check_line in check_lines:
output_lines.append(check_line) output_lines.append(check_line)
printed_prefixes.add((checkprefix, nameless_value.check_prefix)) printed_prefixes.add((checkprefix, nameless_value.check_prefix))
# Remembe new global variables we have not seen before # Remembe new global variables we have not seen before
for key in global_vars_seen: for key in global_vars_seen:
if key not in global_vars_seen_before: if key not in global_vars_seen_before:
global_vars_seen_dict[checkprefix][key] = global_vars_seen[key] global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
break break
if printed_prefixes: if printed_prefixes:
output_lines.append(comment_marker + SEPARATOR) output_lines.append(comment_marker + SEPARATOR)
def check_prefix(prefix): def check_prefix(prefix):
if not PREFIX_RE.match(prefix): if not PREFIX_RE.match(prefix):
hint = "" hint = ""
if ',' in prefix: if ',' in prefix:
hint = " Did you mean '--check-prefixes=" + prefix + "'?" hint = " Did you mean '--check-prefixes=" + prefix + "'?"
warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) % warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %
(prefix)) (prefix))
def verify_filecheck_prefixes(fc_cmd): def verify_filecheck_prefixes(fc_cmd):
fc_cmd_parts = fc_cmd.split() fc_cmd_parts = fc_cmd.split()
for part in fc_cmd_parts: for part in fc_cmd_parts:
if "check-prefix=" in part: if "check-prefix=" in part:
prefix = part.split('=', 1)[1] prefix = part.split('=', 1)[1]
check_prefix(prefix) check_prefix(prefix)
Show All 38 Lines else:
value = ' '.join(map(lambda v: '"' + v.strip('"') + '"', value)) value = ' '.join(map(lambda v: '"' + v.strip('"') + '"', value))
autogenerated_note_args += '%s ' % value autogenerated_note_args += '%s ' % value
if autogenerated_note_args: if autogenerated_note_args:
autogenerated_note_args = ' %s %s' % (UTC_ARGS_KEY, autogenerated_note_args[:-1]) autogenerated_note_args = ' %s %s' % (UTC_ARGS_KEY, autogenerated_note_args[:-1])
return autogenerated_note_args return autogenerated_note_args
def check_for_command(line, parser, args, argv, argparse_callback): def check_for_command(line, parser, args, argv, argparse_callback):
cmd_m = UTC_ARGS_CMD.match(line) cmd_m = UTC_ARGS_CMD.match(line)
if cmd_m: if cmd_m:
for option in shlex.split(cmd_m.group('cmd').strip()): for option in shlex.split(cmd_m.group('cmd').strip()):
if option: if option:
argv.append(option) argv.append(option)
args = parser.parse_args(filter(lambda arg: arg not in args.tests, argv)) args = parser.parse_args(filter(lambda arg: arg not in args.tests, argv))
if argparse_callback is not None: if argparse_callback is not None:
argparse_callback(args) argparse_callback(args)
return args, argv return args, argv
def find_arg_in_test(test_info, get_arg_to_check, arg_string, is_global): def find_arg_in_test(test_info, get_arg_to_check, arg_string, is_global):
result = get_arg_to_check(test_info.args) result = get_arg_to_check(test_info.args)
if not result and is_global: if not result and is_global:
# See if this has been specified via UTC_ARGS. This is a "global" option # See if this has been specified via UTC_ARGS. This is a "global" option
# that affects the entire generation of test checks. If it exists anywhere # that affects the entire generation of test checks. If it exists anywhere
# in the test, apply it to everything. # in the test, apply it to everything.
saw_line = False saw_line = False
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines