common.py

from __future__ importprint_function

importcopy
importglob
importos
importre
importsubprocess
importsys

##### Common utilities for update_*test_checks.py


_verbose=False
_prefix_filecheck_ir_name=''

defparse_commandline_args(parser):
parser.add_argument('--include-generated-funcs', action='store_true',
help='Output checks for functions not in source')
parser.add_argument('-v', '--verbose', action='store_true',
help='Show verbose output')
parser.add_argument('-u', '--update-only', action='store_true',
help='Only update test if it was already autogened')
parser.add_argument('--force-update', action='store_true',
help='Update test even if it was autogened by a different script')
parser.add_argument('--enable', action='store_true', dest='enabled', default=True,
help='Activate CHECK line generation from this point forward')
parser.add_argument('--disable', action='store_false', dest='enabled',
help='Deactivate CHECK line generation from this point forward')
parser.add_argument('--replace-value-regex', nargs='+', default=[],
help='List of regular expressions to replace matching value names')
parser.add_argument('--prefix-filecheck-ir-name', default='',
help='Add a prefix to FileCheck IR value names to avoid conflicts with scripted names')
parser.add_argument('--global-value-regex', nargs='+', default=[],
help='List of regular expressions that a global value declaration must match to generate a check (has no effect if checking globals is not enabled)')
parser.add_argument('--global-hex-value-regex', nargs='+', default=[],
help='List of regular expressions such that, for matching global value declarations, literal integer values should be encoded in hex in the associated FileCheck directives')
args=parser.parse_args()
global_verbose, _global_value_regex, _global_hex_value_regex
_verbose=args.verbose
_global_value_regex=args.global_value_regex
_global_hex_value_regex=args.global_hex_value_regex
returnargs


classInputLineInfo(object):
def__init__(self, line, line_number, args, argv):
self.line=line
self.line_number=line_number
self.args=args
self.argv=argv


classTestInfo(object):
def__init__(self, test, parser, script_name, input_lines, args, argv,
comment_prefix, argparse_callback):
self.parser=parser
self.argparse_callback=argparse_callback
self.path=test
self.args=args
ifargs.prefix_filecheck_ir_name:
global_prefix_filecheck_ir_name
_prefix_filecheck_ir_name=args.prefix_filecheck_ir_name
self.argv=argv
self.input_lines=input_lines
self.run_lines=find_run_lines(test, self.input_lines)
self.comment_prefix=comment_prefix
ifself.comment_prefixisNone:
ifself.path.endswith('.mir'):
self.comment_prefix='#'
else:
self.comment_prefix=';'
self.autogenerated_note_prefix=self.comment_prefix+' '+UTC_ADVERT
self.test_autogenerated_note=self.autogenerated_note_prefix+script_name
self.test_autogenerated_note+=get_autogennote_suffix(parser, self.args)

defro_iterlines(self):
forline_num, input_lineinenumerate(self.input_lines):
args, argv=check_for_command(input_line, self.parser,
self.args, self.argv, self.argparse_callback)
yieldInputLineInfo(input_line, line_num, args, argv)

defiterlines(self, output_lines):
output_lines.append(self.test_autogenerated_note)
forline_infoinself.ro_iterlines():
input_line=line_info.line
# Discard any previous script advertising.
ifinput_line.startswith(self.autogenerated_note_prefix):
continue
self.args=line_info.args
self.argv=line_info.argv
ifnotself.args.enabled:
output_lines.append(input_line)
continue
yieldline_info

defitertests(test_patterns, parser, script_name, comment_prefix=None, argparse_callback=None):
forpatternintest_patterns:
# On Windows we must expand the patterns ourselves.
tests_list=glob.glob(pattern)
ifnottests_list:
warn("Test file pattern '%s' was not found. Ignoring it."% (pattern,))
continue
fortestintests_list:
withopen(test) asf:
input_lines= [l.rstrip() forlinf]
args=parser.parse_args()
ifargparse_callbackisnotNone:
argparse_callback(args)
argv=sys.argv[:]
first_line=input_lines[0] ifinput_lineselse""
ifUTC_ADVERTinfirst_line:
ifscript_namenotinfirst_lineandnotargs.force_update:
warn("Skipping test which wasn't autogenerated by "+script_name, test)
continue
args, argv=check_for_command(first_line, parser, args, argv, argparse_callback)
elifargs.update_only:
assertUTC_ADVERTnotinfirst_line
warn("Skipping test which isn't autogenerated: "+test)
continue
yieldTestInfo(test, parser, script_name, input_lines, args, argv,
comment_prefix, argparse_callback)


defshould_add_line_to_output(input_line, prefix_set, skip_global_checks=False, comment_marker=';'):
# Skip any blank comment lines in the IR.
ifnotskip_global_checksandinput_line.strip() ==comment_marker:
returnFalse
# Skip a special double comment line we use as a separator.
ifinput_line.strip() ==comment_marker+SEPARATOR:
returnFalse
# Skip any blank lines in the IR.
#if input_line.strip() == '':
# return False
# And skip any CHECK lines. We're building our own.
m=CHECK_RE.match(input_line)
ifmandm.group(1) inprefix_set:
ifskip_global_checks:
global_ir_value_re=re.compile('\[\[', flags=(re.M))
returnnotglobal_ir_value_re.search(input_line)
returnFalse

returnTrue

# Perform lit-like substitutions
defgetSubstitutions(sourcepath):
sourcedir=os.path.dirname(sourcepath)
return [('%s', sourcepath),
 ('%S', sourcedir),
 ('%p', sourcedir),
 ('%{pathsep}', os.pathsep)]

defapplySubstitutions(s, substitutions):
fora,binsubstitutions:
s=s.replace(a, b)
returns

# Invoke the tool that is being tested.
definvoke_tool(exe, cmd_args, ir, preprocess_cmd=None, verbose=False):
withopen(ir) asir_file:
substitutions=getSubstitutions(ir)

# TODO Remove the str form which is used by update_test_checks.py and
# update_llc_test_checks.py
# The safer list form is used by update_cc_test_checks.py
ifpreprocess_cmd:
# Allow pre-processing the IR file (e.g. using sed):
assertisinstance(preprocess_cmd, str) # TODO: use a list instead of using shell
preprocess_cmd=applySubstitutions(preprocess_cmd, substitutions).strip()
ifverbose:
print('Pre-processing input file: ', ir, " with command '",
preprocess_cmd, "'", sep="", file=sys.stderr)
# Python 2.7 doesn't have subprocess.DEVNULL:
withopen(os.devnull, 'w') asdevnull:
pp=subprocess.Popen(preprocess_cmd, shell=True, stdin=devnull,
stdout=subprocess.PIPE)
ir_file=pp.stdout

ifisinstance(cmd_args, list):
args= [applySubstitutions(a, substitutions) foraincmd_args]
stdout=subprocess.check_output([exe] +args, stdin=ir_file)
else:
stdout=subprocess.check_output(exe+' '+applySubstitutions(cmd_args, substitutions),
shell=True, stdin=ir_file)
ifsys.version_info[0] >2:
stdout=stdout.decode()
# Fix line endings to unix CR style.
returnstdout.replace('\r\n', '\n')

##### LLVM IR parser
RUN_LINE_RE=re.compile(r'^\s*(?://|[;#])\s*RUN:\s*(.*)$')
CHECK_PREFIX_RE=re.compile(r'--?check-prefix(?:es)?[= ](\S+)')
PREFIX_RE=re.compile('^[a-zA-Z0-9_-]+$')
CHECK_RE=re.compile(r'^\s*(?://|[;#])\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL|-SAME|-EMPTY)?:')

UTC_ARGS_KEY='UTC_ARGS:'
UTC_ARGS_CMD=re.compile(r'.*'+UTC_ARGS_KEY+'\s*(?P<cmd>.*)\s*$')
UTC_ADVERT='NOTE: Assertions have been autogenerated by '

OPT_FUNCTION_RE=re.compile(
r'^(\s*;\s*Function\sAttrs:\s(?P<attrs>[\w\s]+?))?\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w.$-]+?)\s*'
r'(?P<args_and_sig>\((\)|(.*?[\w.-]+?)\))[^{]*\{)\n(?P<body>.*?)^\}$',
flags=(re.M|re.S))

ANALYZE_FUNCTION_RE=re.compile(
r'^\s*\'(?P<analysis>[\w\s-]+?)\'\s+for\s+function\s+\'(?P<func>[\w.$-]+?)\':'
r'\s*\n(?P<body>.*)$',
flags=(re.X|re.S))

IR_FUNCTION_RE=re.compile(r'^\s*define\s+(?:internal\s+)?[^@]*@"?([\w.$-]+)"?\s*\(')
TRIPLE_IR_RE=re.compile(r'^\s*target\s+triple\s*=\s*"([^"]+)"$')
TRIPLE_ARG_RE=re.compile(r'-mtriple[= ]([^ ]+)')
MARCH_ARG_RE=re.compile(r'-march[= ]([^ ]+)')

SCRUB_LEADING_WHITESPACE_RE=re.compile(r'^(\s+)')
SCRUB_WHITESPACE_RE=re.compile(r'(?!^(| \w))[ \t]+', flags=re.M)
SCRUB_TRAILING_WHITESPACE_RE=re.compile(r'[ \t]+$', flags=re.M)
SCRUB_TRAILING_WHITESPACE_TEST_RE=SCRUB_TRAILING_WHITESPACE_RE
SCRUB_TRAILING_WHITESPACE_AND_ATTRIBUTES_RE=re.compile(r'([ \t]|(#[0-9]+))+$', flags=re.M)
SCRUB_KILL_COMMENT_RE=re.compile(r'^ *#+ +kill:.*\n')
SCRUB_LOOP_COMMENT_RE=re.compile(
r'# =>This Inner Loop Header:.*|# in Loop:.*', flags=re.M)
SCRUB_TAILING_COMMENT_TOKEN_RE=re.compile(r'(?<=\S)+[ \t]*#$', flags=re.M)

SEPARATOR='.'

deferror(msg, test_file=None):
iftest_file:
msg='{}: {}'.format(msg, test_file)
print('ERROR: {}'.format(msg), file=sys.stderr)

defwarn(msg, test_file=None):
iftest_file:
msg='{}: {}'.format(msg, test_file)
print('WARNING: {}'.format(msg), file=sys.stderr)

defdebug(*args, **kwargs):
# Python2 does not allow def debug(*args, file=sys.stderr, **kwargs):
if'file'notinkwargs:
kwargs['file'] =sys.stderr
if_verbose:
print(*args, **kwargs)

deffind_run_lines(test, lines):
debug('Scanning for RUN lines in test file:', test)
raw_lines= [m.group(1)
formin [RUN_LINE_RE.match(l) forlinlines] ifm]
run_lines= [raw_lines[0]] iflen(raw_lines) >0else []
forlinraw_lines[1:]:
ifrun_lines[-1].endswith('\\'):
run_lines[-1] =run_lines[-1].rstrip('\\') +' '+l
else:
run_lines.append(l)
debug('Found {} RUN lines in {}:'.format(len(run_lines), test))
forlinrun_lines:
debug(' RUN: {}'.format(l))
returnrun_lines

defscrub_body(body):
# Scrub runs of whitespace out of the assembly, but leave the leading
# whitespace in place.
body=SCRUB_WHITESPACE_RE.sub(r' ', body)
# Expand the tabs used for indentation.
body=str.expandtabs(body, 2)
# Strip trailing whitespace.
body=SCRUB_TRAILING_WHITESPACE_TEST_RE.sub(r'', body)
returnbody

defdo_scrub(body, scrubber, scrubber_args, extra):
ifscrubber_args:
local_args=copy.deepcopy(scrubber_args)
local_args[0].extra_scrub=extra
returnscrubber(body, *local_args)
returnscrubber(body, *scrubber_args)

# Build up a dictionary of all the function bodies.
classfunction_body(object):
def__init__(self, string, extra, args_and_sig, attrs):
self.scrub=string
self.extrascrub=extra
self.args_and_sig=args_and_sig
self.attrs=attrs
defis_same_except_arg_names(self, extrascrub, args_and_sig, attrs, is_asm):
arg_names=set()
defdrop_arg_names(match):
arg_names.add(match.group(variable_group_in_ir_value_match))
ifmatch.group(attribute_group_in_ir_value_match):
attr=match.group(attribute_group_in_ir_value_match)
else:
attr=''
returnmatch.group(1) +attr+match.group(match.lastindex)
defrepl_arg_names(match):
ifmatch.group(variable_group_in_ir_value_match) isnotNoneandmatch.group(variable_group_in_ir_value_match) inarg_names:
returnmatch.group(1) +match.group(match.lastindex)
returnmatch.group(1) +match.group(2) +match.group(match.lastindex)
ifself.attrs!=attrs:
returnFalse
ans0=IR_VALUE_RE.sub(drop_arg_names, self.args_and_sig)
ans1=IR_VALUE_RE.sub(drop_arg_names, args_and_sig)
ifans0!=ans1:
returnFalse
ifis_asm:
# Check without replacements, the replacements are not applied to the
# body for asm checks.
returnself.extrascrub==extrascrub

es0=IR_VALUE_RE.sub(repl_arg_names, self.extrascrub)
es1=IR_VALUE_RE.sub(repl_arg_names, extrascrub)
es0=SCRUB_IR_COMMENT_RE.sub(r'', es0)
es1=SCRUB_IR_COMMENT_RE.sub(r'', es1)
returnes0==es1

def__str__(self):
returnself.scrub

classFunctionTestBuilder:
def__init__(self, run_list, flags, scrubber_args, path):
self._verbose=flags.verbose
self._record_args=flags.function_signature
self._check_attributes=flags.check_attributes
self._scrubber_args=scrubber_args
self._path=path
# Strip double-quotes if input was read by UTC_ARGS
self._replace_value_regex=list(map(lambdax: x.strip('"'), flags.replace_value_regex))
self._func_dict= {}
self._func_order= {}
self._global_var_dict= {}
fortupleinrun_list:
forprefixintuple[0]:
self._func_dict.update({prefix:dict()})
self._func_order.update({prefix: []})
self._global_var_dict.update({prefix:dict()})

deffinish_and_get_func_dict(self):
forprefixinself._get_failed_prefixes():
warn('Prefix %s had conflicting output from different RUN lines for all functions in test %s'% (prefix,self._path,))
returnself._func_dict

deffunc_order(self):
returnself._func_order

defglobal_var_dict(self):
returnself._global_var_dict

defprocess_run_line(self, function_re, scrubber, raw_tool_output, prefixes, is_asm):
build_global_values_dictionary(self._global_var_dict, raw_tool_output, prefixes)
forminfunction_re.finditer(raw_tool_output):
ifnotm:
continue
func=m.group('func')
body=m.group('body')
attrs=m.group('attrs') ifself._check_attributeselse''
# Determine if we print arguments, the opening brace, or nothing after the
# function name
ifself._record_argsand'args_and_sig'inm.groupdict():
args_and_sig=scrub_body(m.group('args_and_sig').strip())
elif'args_and_sig'inm.groupdict():
args_and_sig='('
else:
args_and_sig=''
scrubbed_body=do_scrub(body, scrubber, self._scrubber_args,
extra=False)
scrubbed_extra=do_scrub(body, scrubber, self._scrubber_args,
extra=True)
if'analysis'inm.groupdict():
analysis=m.group('analysis')
ifanalysis.lower() !='cost model analysis':
warn('Unsupported analysis mode: %r!'% (analysis,))
iffunc.startswith('stress'):
# We only use the last line of the function body for stress tests.
scrubbed_body='\n'.join(scrubbed_body.splitlines()[-1:])
ifself._verbose:
print('Processing function: '+func, file=sys.stderr)
forlinscrubbed_body.splitlines():
print(' '+l, file=sys.stderr)
forprefixinprefixes:
# Replace function names matching the regex.
forregexinself._replace_value_regex:
# Pattern that matches capture groups in the regex in leftmost order.
group_regex=re.compile('\(.*?\)')
# Replace function name with regex.
match=re.match(regex, func)
ifmatch:
func_repl=regex
# Replace any capture groups with their matched strings.
forginmatch.groups():
func_repl=group_regex.sub(re.escape(g), func_repl, count=1)
func=re.sub(func_repl, '{{'+func_repl+'}}', func)

# Replace all calls to regex matching functions.
matches=re.finditer(regex, scrubbed_body)
formatchinmatches:
func_repl=regex
# Replace any capture groups with their matched strings.
forginmatch.groups():
func_repl=group_regex.sub(re.escape(g), func_repl, count=1)
# Substitute function call names that match the regex with the same
# capture groups set.
scrubbed_body=re.sub(func_repl, '{{'+func_repl+'}}',
scrubbed_body)

iffuncinself._func_dict[prefix]:
if (self._func_dict[prefix][func] isNoneor
str(self._func_dict[prefix][func]) !=scrubbed_bodyor
self._func_dict[prefix][func].args_and_sig!=args_and_sigor
self._func_dict[prefix][func].attrs!=attrs):
if (self._func_dict[prefix][func] isnotNoneand
self._func_dict[prefix][func].is_same_except_arg_names(
scrubbed_extra,
args_and_sig,
attrs,
is_asm)):
self._func_dict[prefix][func].scrub=scrubbed_extra
self._func_dict[prefix][func].args_and_sig=args_and_sig
continue
else:
# This means a previous RUN line produced a body for this function
# that is different from the one produced by this current RUN line,
# so the body can't be common accross RUN lines. We use None to
# indicate that.
self._func_dict[prefix][func] =None
continue

self._func_dict[prefix][func] =function_body(
scrubbed_body, scrubbed_extra, args_and_sig, attrs)
self._func_order[prefix].append(func)

def_get_failed_prefixes(self):
# This returns the list of those prefixes that failed to match any function,
# because there were conflicting bodies produced by different RUN lines, in
# all instances of the prefix. Effectively, this prefix is unused and should
# be removed.
forprefixinself._func_dict:
if (self._func_dict[prefix] and
 (not [fctforfctinself._func_dict[prefix]
ifself._func_dict[prefix][fct] isnotNone])):
yieldprefix


##### Generator of LLVM IR CHECK lines

SCRUB_IR_COMMENT_RE=re.compile(r'\s*;.*')

# TODO: We should also derive check lines for global, debug, loop declarations, etc..

classNamelessValue:
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):
self.check_prefix=check_prefix
self.check_key=check_key
self.ir_prefix=ir_prefix
self.global_ir_prefix=global_ir_prefix
self.global_ir_prefix_regexp=global_ir_prefix_regexp
self.ir_regexp=ir_regexp
self.global_ir_rhs_regexp=global_ir_rhs_regexp
self.is_before_functions=is_before_functions

# Description of the different "unnamed" values we match in the IR, e.g.,
# (local) ssa values, (debug) metadata, etc.
nameless_values= [
NamelessValue(r'TMP' , '%' , r'%' , None , None , r'[\w$.-]+?' , 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'GLOB' , '@' , r'@' , None , None , r'[0-9]+' , None , False) ,
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'PROF' , '!' , r'!prof ' , 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'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' , '!' , None , r'' , r'![0-9]+' , None , r'(?:distinct |)!.*' , False) ,
]

defcreateOrRegexp(old, new):
ifnotold:
returnnew
ifnotnew:
returnold
returnold+'|'+new

defcreatePrefixMatch(prefix_str, prefix_re):
ifprefix_strisNoneorprefix_reisNone:
return''
return'(?:'+prefix_str+'('+prefix_re+'))'

# 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
# the PREFIX and SUFFIX below only contain a single group, if that changes
# other locations will need adjustment as well.
IR_VALUE_REGEXP_PREFIX=r'(\s*)'
IR_VALUE_REGEXP_STRING=r''
fornameless_valueinnameless_values:
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)
assert((lcl_matchorglb_match) andnot (lcl_matchandglb_match))
iflcl_match:
IR_VALUE_REGEXP_STRING=createOrRegexp(IR_VALUE_REGEXP_STRING, lcl_match)
elifglb_match:
IR_VALUE_REGEXP_STRING=createOrRegexp(IR_VALUE_REGEXP_STRING, '^'+glb_match)
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)

# 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.
first_nameless_group_in_ir_value_match=3

# constants for the group id of special matches
variable_group_in_ir_value_match=3
attribute_group_in_ir_value_match=4

# 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.
defget_idx_from_ir_value_match(match):
foriinrange(first_nameless_group_in_ir_value_match, match.lastindex):
ifmatch.group(i) isnotNone:
returni-first_nameless_group_in_ir_value_match
error("Unable to identify the kind of IR value from the match!")
return0

# See get_idx_from_ir_value_match
defget_name_from_ir_value_match(match):
returnmatch.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
# get_idx_from_ir_value_match
defget_nameless_check_prefix_from_ir_value_match(match):
returnnameless_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,
# see also get_idx_from_ir_value_match
defget_ir_prefix_from_ir_value_match(match):
idx=get_idx_from_ir_value_match(match)
ifnameless_values[idx].ir_prefixandmatch.group(0).strip().startswith(nameless_values[idx].ir_prefix):
returnnameless_values[idx].ir_prefix, nameless_values[idx].check_prefix
returnnameless_values[idx].global_ir_prefix, nameless_values[idx].check_prefix

defget_check_key_from_ir_value_match(match):
idx=get_idx_from_ir_value_match(match)
returnnameless_values[idx].check_key

# 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
defget_ir_prefix_from_ir_value_re_match(match):
# for backwards compatibility we check locals with '.*'
ifis_local_def_ir_value_match(match):
return'.*'
idx=get_idx_from_ir_value_match(match)
ifnameless_values[idx].ir_prefixandmatch.group(0).strip().startswith(nameless_values[idx].ir_prefix):
returnnameless_values[idx].ir_regexp
returnnameless_values[idx].global_ir_prefix_regexp

# Return true if this kind of IR value is "local", basically if it matches '%{{.*}}'.
defis_local_def_ir_value_match(match):
returnnameless_values[get_idx_from_ir_value_match(match)].ir_prefix=='%'

# Return true if this kind of IR value is "global", basically if it matches '#{{.*}}'.
defis_global_scope_ir_value_match(match):
returnnameless_values[get_idx_from_ir_value_match(match)].global_ir_prefixisnotNone

# Return true if var clashes with the scripted FileCheck check_prefix.
defmay_clash_with_default_check_prefix_name(check_prefix, var):
returncheck_prefixandre.match(r'^'+check_prefix+r'[0-9]+?$', var, re.IGNORECASE)

# Create a FileCheck variable name based on an IR name.
defget_value_name(var, check_prefix):
var=var.replace('!', '')
# This is a nameless value, prepend check_prefix.
ifvar.isdigit():
var=check_prefix+var
else:
# This is a named value that clashes with the check_prefix, prepend with _prefix_filecheck_ir_name,
# if it has been defined.
ifmay_clash_with_default_check_prefix_name(check_prefix, var) and_prefix_filecheck_ir_name:
var=_prefix_filecheck_ir_name+var
var=var.replace('.', '_')
var=var.replace('-', '_')
returnvar.upper()

# Create a FileCheck variable from regex.
defget_value_definition(var, match):
# for backwards compatibility we check locals with '.*'
ifis_local_def_ir_value_match(match):
return'[['+get_value_name(var, get_nameless_check_prefix_from_ir_value_match(match)) +':'+ \
get_ir_prefix_from_ir_value_match(match)[0] +get_ir_prefix_from_ir_value_re_match(match) +']]'
prefix=get_ir_prefix_from_ir_value_match(match)[0]
returnprefix+'[['+get_value_name(var, get_nameless_check_prefix_from_ir_value_match(match)) +':'+get_ir_prefix_from_ir_value_re_match(match) +']]'

# Use a FileCheck variable.
defget_value_use(var, match, check_prefix):
ifis_local_def_ir_value_match(match):
return'[['+get_value_name(var, check_prefix) +']]'
prefix=get_ir_prefix_from_ir_value_match(match)[0]
returnprefix+'[['+get_value_name(var, check_prefix) +']]'

# Replace IR value defs and uses with FileCheck variables.
defgeneralize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
# This gets called for each match that occurs in
# a line. We transform variables we haven't seen
# into defs, and variables we have seen into uses.
deftransform_line_vars(match):
pre, check=get_ir_prefix_from_ir_value_match(match)
var=get_name_from_ir_value_match(match)
fornameless_valueinnameless_values:
ifmay_clash_with_default_check_prefix_name(nameless_value.check_prefix, var):
warn("Change IR value name '%s' or use -prefix-ir-filecheck-name to prevent possible conflict"
" with scripted FileCheck name."% (var,))
key= (var, get_check_key_from_ir_value_match(match))
is_local_def=is_local_def_ir_value_match(match)
ifis_local_defandkeyinvars_seen:
rv=get_value_use(var, match, get_nameless_check_prefix_from_ir_value_match(match))
elifnotis_local_defandkeyinglobal_vars_seen:
rv=get_value_use(var, match, global_vars_seen[key])
else:
ifis_local_def:
vars_seen.add(key)
else:
global_vars_seen[key] =get_nameless_check_prefix_from_ir_value_match(match)
rv=get_value_definition(var, match)
# re.sub replaces the entire regex match
# with whatever you return, so we have
# to make sure to hand it back everything
# including the commas and spaces.
returnmatch.group(1) +rv+match.group(match.lastindex)

lines_with_def= []

fori, lineinenumerate(lines):
# An IR variable named '%.' matches the FileCheck regex string.
line=line.replace('%.', '%dot')
forregexin_global_hex_value_regex:
ifre.match('^@'+regex+' = ', line):
line=re.sub(r'\bi([0-9]+) ([0-9]+)',
lambdam : 'i'+m.group(1) +' [[#'+hex(int(m.group(2))) +']]',
line)
break
# Ignore any comments, since the check lines will too.
scrubbed_line=SCRUB_IR_COMMENT_RE.sub(r'', line)
lines[i] =scrubbed_line
ifnotis_analyze:
# 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
# substituting until there is no more match.
changed=True
whilechanged:
 (lines[i], changed) =IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1)
returnlines


defadd_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze, global_vars_seen_dict):
# 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()
printed_prefixes= []
forpinprefix_list:
checkprefixes=p[0]
# 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
# other run lines created it.
ifany(map(lambdacheckprefix: func_namenotinfunc_dict[checkprefix], checkprefixes)):
prefix_exclusions|=set(checkprefixes)
continue

# prefix_exclusions is constructed, we can now emit the output
forpinprefix_list:
global_vars_seen= {}
checkprefixes=p[0]
forcheckprefixincheckprefixes:
ifcheckprefixinglobal_vars_seen_dict:
global_vars_seen.update(global_vars_seen_dict[checkprefix])
else:
global_vars_seen_dict[checkprefix] = {}
ifcheckprefixinprinted_prefixes:
break

# Check if the prefix is excluded.
ifcheckprefixinprefix_exclusions:
continue

# If we do not have output for this prefix we skip it.
ifnotfunc_dict[checkprefix][func_name]:
continue

# Add some space between different check prefixes, but not after the last
# check line (before the test code).
ifis_asm:
iflen(printed_prefixes) !=0:
output_lines.append(comment_marker)

ifcheckprefixnotinglobal_vars_seen_dict:
global_vars_seen_dict[checkprefix] = {}

global_vars_seen_before= [keyforkeyinglobal_vars_seen.keys()]

vars_seen=set()
printed_prefixes.append(checkprefix)
attrs=str(func_dict[checkprefix][func_name].attrs)
attrs=''ifattrs=='None'elseattrs
ifattrs:
output_lines.append('%s %s: Function Attrs: %s'% (comment_marker, checkprefix, attrs))
args_and_sig=str(func_dict[checkprefix][func_name].args_and_sig)
args_and_sig=generalize_check_lines([args_and_sig], is_analyze, vars_seen, global_vars_seen)[0]
if'[['inargs_and_sig:
output_lines.append(check_label_format% (checkprefix, func_name, ''))
output_lines.append('%s %s-SAME: %s'% (comment_marker, checkprefix, args_and_sig))
else:
output_lines.append(check_label_format% (checkprefix, func_name, args_and_sig))
func_body=str(func_dict[checkprefix][func_name]).splitlines()

# For ASM output, just emit the check lines.
ifis_asm:
output_lines.append('%s %s: %s'% (comment_marker, checkprefix, func_body[0]))
forfunc_lineinfunc_body[1:]:
iffunc_line.strip() =='':
output_lines.append('%s %s-EMPTY:'% (comment_marker, checkprefix))
else:
output_lines.append('%s %s-NEXT: %s'% (comment_marker, checkprefix, func_line))
break

# For IR output, change all defs to FileCheck variables, so we're immune
# to variable naming fashions.
func_body=generalize_check_lines(func_body, is_analyze, vars_seen, global_vars_seen)

# This could be selectively enabled with an optional invocation argument.
# Disabled for now: better to check everything. Be safe rather than sorry.

# Handle the first line of the function body as a special case because
# it's often just noise (a useless asm comment or entry label).
#if func_body[0].startswith("#") or func_body[0].startswith("entry:"):
# is_blank_line = True
#else:
# output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0]))
# is_blank_line = False

is_blank_line=False

forfunc_lineinfunc_body:
iffunc_line.strip() =='':
is_blank_line=True
continue
# Do not waste time checking IR comments.
func_line=SCRUB_IR_COMMENT_RE.sub(r'', func_line)

# Skip blank lines instead of checking them.
ifis_blank_line:
output_lines.append('{} {}: {}'.format(
comment_marker, checkprefix, func_line))
else:
output_lines.append('{} {}-NEXT: {}'.format(
comment_marker, checkprefix, func_line))
is_blank_line=False

# Add space between different check prefixes and also before the first
# line of code in the test function.
output_lines.append(comment_marker)

# Remembe new global variables we have not seen before
forkeyinglobal_vars_seen:
ifkeynotinglobal_vars_seen_before:
global_vars_seen_dict[checkprefix][key] =global_vars_seen[key]
break

defadd_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
func_name, preserve_names, function_sig, global_vars_seen_dict):
# Label format is based on IR string.
function_def_regex='define {{[^@]+}}'iffunction_sigelse''
check_label_format='{} %s-LABEL: {}@%s%s'.format(comment_marker, function_def_regex)
add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
check_label_format, False, preserve_names, global_vars_seen_dict)

defadd_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
check_label_format='{} %s-LABEL: \'%s%s\''.format(comment_marker)
global_vars_seen_dict= {}
add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
check_label_format, False, True, global_vars_seen_dict)

defbuild_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes):
fornameless_valueinnameless_values:
ifnameless_value.global_ir_prefixisNone:
continue

lhs_re_str=nameless_value.global_ir_prefix+nameless_value.global_ir_prefix_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=re.compile(global_ir_value_re_str, flags=(re.M))
lines= []
forminglobal_ir_value_re.finditer(raw_tool_output):
lines.append(m.group(0))

forprefixinprefixes:
ifglob_val_dict[prefix] isNone:
continue
ifnameless_value.check_prefixinglob_val_dict[prefix]:
iflines==glob_val_dict[prefix][nameless_value.check_prefix]:
continue
ifprefix==prefixes[-1]:
warn('Found conflicting asm under the same prefix: %r!'% (prefix,))
else:
glob_val_dict[prefix][nameless_value.check_prefix] =None
continue
glob_val_dict[prefix][nameless_value.check_prefix] =lines

defadd_global_checks(glob_val_dict, comment_marker, prefix_list, output_lines, global_vars_seen_dict, is_analyze, is_before_functions):
printed_prefixes=set()
fornameless_valueinnameless_values:
ifnameless_value.global_ir_prefixisNone:
continue
ifnameless_value.is_before_functions!=is_before_functions:
continue
forpinprefix_list:
global_vars_seen= {}
checkprefixes=p[0]
ifcheckprefixesisNone:
continue
forcheckprefixincheckprefixes:
ifcheckprefixinglobal_vars_seen_dict:
global_vars_seen.update(global_vars_seen_dict[checkprefix])
else:
global_vars_seen_dict[checkprefix] = {}
if (checkprefix, nameless_value.check_prefix) inprinted_prefixes:
break
ifnotglob_val_dict[checkprefix]:
continue
ifnameless_value.check_prefixnotinglob_val_dict[checkprefix]:
continue
ifnotglob_val_dict[checkprefix][nameless_value.check_prefix]:
continue

check_lines= []
global_vars_seen_before= [keyforkeyinglobal_vars_seen.keys()]
forlineinglob_val_dict[checkprefix][nameless_value.check_prefix]:
if_global_value_regex:
matched=False
forregexin_global_value_regex:
ifre.match('^@'+regex+' = ', line):
matched=True
break
ifnotmatched:
continue
tmp=generalize_check_lines([line], is_analyze, set(), global_vars_seen)
check_line='%s %s: %s'% (comment_marker, checkprefix, tmp[0])
check_lines.append(check_line)
ifnotcheck_lines:
continue

output_lines.append(comment_marker+SEPARATOR)
forcheck_lineincheck_lines:
output_lines.append(check_line)

printed_prefixes.add((checkprefix, nameless_value.check_prefix))

# Remembe new global variables we have not seen before
forkeyinglobal_vars_seen:
ifkeynotinglobal_vars_seen_before:
global_vars_seen_dict[checkprefix][key] =global_vars_seen[key]
break

ifprinted_prefixes:
output_lines.append(comment_marker+SEPARATOR)


defcheck_prefix(prefix):
ifnotPREFIX_RE.match(prefix):
hint=""
if','inprefix:
hint=" Did you mean '--check-prefixes="+prefix+"'?"
warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores."+hint) %
 (prefix))


defverify_filecheck_prefixes(fc_cmd):
fc_cmd_parts=fc_cmd.split()
forpartinfc_cmd_parts:
if"check-prefix="inpart:
prefix=part.split('=', 1)[1]
check_prefix(prefix)
elif"check-prefixes="inpart:
prefixes=part.split('=', 1)[1].split(',')
forprefixinprefixes:
check_prefix(prefix)
ifprefixes.count(prefix) >1:
warn("Supplied prefix '%s' is not unique in the prefix list."% (prefix,))


defget_autogennote_suffix(parser, args):
autogenerated_note_args=''
foractioninparser._actions:
ifnothasattr(args, action.dest):
continue# Ignore options such as --help that aren't included in args
# Ignore parameters such as paths to the binary or the list of tests
ifaction.destin ('tests', 'update_only', 'opt_binary', 'llc_binary',
'clang', 'opt', 'llvm_bin', 'verbose'):
continue
value=getattr(args, action.dest)
ifaction.constisnotNone: # action stores a constant (usually True/False)
# Skip actions with different constant values (this happens with boolean
# --foo/--no-foo options)
ifvalue!=action.const:
continue
ifparser.get_default(action.dest) ==value:
continue# Don't add default values
autogenerated_note_args+=action.option_strings[0] +' '
ifaction.constisNone: # action takes a parameter
ifaction.nargs=='+':
value=' '.join(map(lambdav: '"'+v.strip('"') +'"', value))
autogenerated_note_args+='%s '%value
ifautogenerated_note_args:
autogenerated_note_args=' %s %s'% (UTC_ARGS_KEY, autogenerated_note_args[:-1])
returnautogenerated_note_args


defcheck_for_command(line, parser, args, argv, argparse_callback):
cmd_m=UTC_ARGS_CMD.match(line)
ifcmd_m:
foroptionincmd_m.group('cmd').strip().split(' '):
ifoption:
argv.append(option)
args=parser.parse_args(filter(lambdaarg: argnotinargs.tests, argv))
ifargparse_callbackisnotNone:
argparse_callback(args)
returnargs, argv

deffind_arg_in_test(test_info, get_arg_to_check, arg_string, is_global):
result=get_arg_to_check(test_info.args)
ifnotresultandis_global:
# 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
# in the test, apply it to everything.
saw_line=False
forline_infointest_info.ro_iterlines():
line=line_info.line
ifnotline.startswith(';') andline.strip() !='':
saw_line=True
result=get_arg_to_check(line_info.args)
ifresult:
ifwarnandsaw_line:
# We saw the option after already reading some test input lines.
# Warn about it.
print('WARNING: Found {} in line following test start: '.format(arg_string)
+line, file=sys.stderr)
print('WARNING: Consider moving {} to top of file'.format(arg_string),
file=sys.stderr)
break
returnresult

defdump_input_lines(output_lines, test_info, prefix_set, comment_string):
forinput_line_infointest_info.iterlines(output_lines):
line=input_line_info.line
args=input_line_info.args
ifline.strip() ==comment_string:
continue
ifline.strip() ==comment_string+SEPARATOR:
continue
ifline.lstrip().startswith(comment_string):
m=CHECK_RE.match(line)
ifmandm.group(1) inprefix_set:
continue
output_lines.append(line.rstrip('\n'))

defadd_checks_at_end(output_lines, prefix_list, func_order,
comment_string, check_generator):
added=set()
forprefixinprefix_list:
prefixes=prefix[0]
tool_args=prefix[1]
forprefixinprefixes:
forfuncinfunc_order[prefix]:
ifadded:
output_lines.append(comment_string)
added.add(func)

# The add_*_checks routines expect a run list whose items are
# tuples that have a list of prefixes as their first element and
# tool command args string as their second element. They output
# checks for each prefix in the list of prefixes. By doing so, it
# implicitly assumes that for each function every run line will
# generate something for that function. That is not the case for
# generated functions as some run lines might not generate them
# (e.g. -fopenmp vs. no -fopenmp).
#
# Therefore, pass just the prefix we're interested in. This has
# the effect of generating all of the checks for functions of a
# single prefix before moving on to the next prefix. So checks
# are ordered by prefix instead of by function as in "normal"
# mode.
check_generator(output_lines,
 [([prefix], tool_args)],
func)