1from __future__ import print_function 2import re 3import string 4import subprocess 5import sys 6import copy 7 8if sys.version_info[0] > 2: 9 class string: 10 expandtabs = str.expandtabs 11else: 12 import string 13 14##### Common utilities for update_*test_checks.py 15 16def should_add_line_to_output(input_line, prefix_set): 17 # Skip any blank comment lines in the IR. 18 if input_line.strip() == ';': 19 return False 20 # Skip any blank lines in the IR. 21 #if input_line.strip() == '': 22 # return False 23 # And skip any CHECK lines. We're building our own. 24 m = CHECK_RE.match(input_line) 25 if m and m.group(1) in prefix_set: 26 return False 27 28 return True 29 30# Invoke the tool that is being tested. 31def invoke_tool(exe, cmd_args, ir): 32 with open(ir) as ir_file: 33 # TODO Remove the str form which is used by update_test_checks.py and 34 # update_llc_test_checks.py 35 # The safer list form is used by update_cc_test_checks.py 36 if isinstance(cmd_args, list): 37 stdout = subprocess.check_output([exe] + cmd_args, stdin=ir_file) 38 else: 39 stdout = subprocess.check_output(exe + ' ' + cmd_args, 40 shell=True, stdin=ir_file) 41 if sys.version_info[0] > 2: 42 stdout = stdout.decode() 43 # Fix line endings to unix CR style. 44 return stdout.replace('\r\n', '\n') 45 46##### LLVM IR parser 47 48RUN_LINE_RE = re.compile('^\s*[;#]\s*RUN:\s*(.*)$') 49CHECK_PREFIX_RE = re.compile('--?check-prefix(?:es)?[= ](\S+)') 50CHECK_RE = re.compile(r'^\s*[;#]\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:') 51 52OPT_FUNCTION_RE = re.compile( 53 r'^\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w-]+?)\s*\(' 54 r'(\s+)?[^)]*[^{]*\{\n(?P<body>.*?)^\}$', 55 flags=(re.M | re.S)) 56 57ANALYZE_FUNCTION_RE = re.compile( 58 r'^\s*\'(?P<analysis>[\w\s-]+?)\'\s+for\s+function\s+\'(?P<func>[\w-]+?)\':' 59 r'\s*\n(?P<body>.*)$', 60 flags=(re.X | re.S)) 61 62IR_FUNCTION_RE = re.compile('^\s*define\s+(?:internal\s+)?[^@]*@(\w+)\s*\(') 63TRIPLE_IR_RE = re.compile(r'^\s*target\s+triple\s*=\s*"([^"]+)"$') 64TRIPLE_ARG_RE = re.compile(r'-mtriple[= ]([^ ]+)') 65MARCH_ARG_RE = re.compile(r'-march[= ]([^ ]+)') 66 67SCRUB_LEADING_WHITESPACE_RE = re.compile(r'^(\s+)') 68SCRUB_WHITESPACE_RE = re.compile(r'(?!^(| \w))[ \t]+', flags=re.M) 69SCRUB_TRAILING_WHITESPACE_RE = re.compile(r'[ \t]+$', flags=re.M) 70SCRUB_KILL_COMMENT_RE = re.compile(r'^ *#+ +kill:.*\n') 71SCRUB_LOOP_COMMENT_RE = re.compile( 72 r'# =>This Inner Loop Header:.*|# in Loop:.*', flags=re.M) 73 74def scrub_body(body): 75 # Scrub runs of whitespace out of the assembly, but leave the leading 76 # whitespace in place. 77 body = SCRUB_WHITESPACE_RE.sub(r' ', body) 78 # Expand the tabs used for indentation. 79 body = string.expandtabs(body, 2) 80 # Strip trailing whitespace. 81 body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body) 82 return body 83 84def do_scrub(body, scrubber, scrubber_args, extra): 85 if scrubber_args: 86 local_args = copy.deepcopy(scrubber_args) 87 local_args[0].extra_scrub = extra 88 return scrubber(body, *local_args) 89 return scrubber(body, *scrubber_args) 90 91# Build up a dictionary of all the function bodies. 92class function_body(object): 93 def __init__(self, string, extra): 94 self.scrub = string 95 self.extrascrub = extra 96 def __str__(self): 97 return self.scrub 98 99def build_function_body_dictionary(function_re, scrubber, scrubber_args, raw_tool_output, prefixes, func_dict, verbose): 100 for m in function_re.finditer(raw_tool_output): 101 if not m: 102 continue 103 func = m.group('func') 104 body = m.group('body') 105 scrubbed_body = do_scrub(body, scrubber, scrubber_args, extra = False) 106 scrubbed_extra = do_scrub(body, scrubber, scrubber_args, extra = True) 107 if m.groupdict().has_key('analysis'): 108 analysis = m.group('analysis') 109 if analysis.lower() != 'cost model analysis': 110 print('WARNING: Unsupported analysis mode: %r!' % (analysis,), file=sys.stderr) 111 if func.startswith('stress'): 112 # We only use the last line of the function body for stress tests. 113 scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:]) 114 if verbose: 115 print('Processing function: ' + func, file=sys.stderr) 116 for l in scrubbed_body.splitlines(): 117 print(' ' + l, file=sys.stderr) 118 for prefix in prefixes: 119 if func in func_dict[prefix] and str(func_dict[prefix][func]) != scrubbed_body: 120 if func_dict[prefix][func] and func_dict[prefix][func].extrascrub == scrubbed_extra: 121 func_dict[prefix][func].scrub = scrubbed_extra 122 continue 123 else: 124 if prefix == prefixes[-1]: 125 print('WARNING: Found conflicting asm under the ' 126 'same prefix: %r!' % (prefix,), file=sys.stderr) 127 else: 128 func_dict[prefix][func] = None 129 continue 130 131 func_dict[prefix][func] = function_body(scrubbed_body, scrubbed_extra) 132 133##### Generator of LLVM IR CHECK lines 134 135SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*') 136 137# Match things that look at identifiers, but only if they are followed by 138# spaces, commas, paren, or end of the string 139IR_VALUE_RE = re.compile(r'(\s+)%([\w\.\-]+?)([,\s\(\)]|\Z)') 140 141# Create a FileCheck variable name based on an IR name. 142def get_value_name(var): 143 if var.isdigit(): 144 var = 'TMP' + var 145 var = var.replace('.', '_') 146 var = var.replace('-', '_') 147 return var.upper() 148 149 150# Create a FileCheck variable from regex. 151def get_value_definition(var): 152 return '[[' + get_value_name(var) + ':%.*]]' 153 154 155# Use a FileCheck variable. 156def get_value_use(var): 157 return '[[' + get_value_name(var) + ']]' 158 159# Replace IR value defs and uses with FileCheck variables. 160def genericize_check_lines(lines, is_analyze): 161 # This gets called for each match that occurs in 162 # a line. We transform variables we haven't seen 163 # into defs, and variables we have seen into uses. 164 def transform_line_vars(match): 165 var = match.group(2) 166 if var in vars_seen: 167 rv = get_value_use(var) 168 else: 169 vars_seen.add(var) 170 rv = get_value_definition(var) 171 # re.sub replaces the entire regex match 172 # with whatever you return, so we have 173 # to make sure to hand it back everything 174 # including the commas and spaces. 175 return match.group(1) + rv + match.group(3) 176 177 vars_seen = set() 178 lines_with_def = [] 179 180 for i, line in enumerate(lines): 181 # An IR variable named '%.' matches the FileCheck regex string. 182 line = line.replace('%.', '%dot') 183 # Ignore any comments, since the check lines will too. 184 scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line) 185 if is_analyze == False: 186 lines[i] = IR_VALUE_RE.sub(transform_line_vars, scrubbed_line) 187 else: 188 lines[i] = scrubbed_line 189 return lines 190 191 192def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze): 193 printed_prefixes = [] 194 for p in prefix_list: 195 checkprefixes = p[0] 196 for checkprefix in checkprefixes: 197 if checkprefix in printed_prefixes: 198 break 199 # TODO func_dict[checkprefix] may be None, '' or not exist. 200 # Fix the call sites. 201 if func_name not in func_dict[checkprefix] or not func_dict[checkprefix][func_name]: 202 continue 203 204 # Add some space between different check prefixes, but not after the last 205 # check line (before the test code). 206 if is_asm == True: 207 if len(printed_prefixes) != 0: 208 output_lines.append(comment_marker) 209 210 printed_prefixes.append(checkprefix) 211 output_lines.append(check_label_format % (checkprefix, func_name)) 212 func_body = str(func_dict[checkprefix][func_name]).splitlines() 213 214 # For ASM output, just emit the check lines. 215 if is_asm == True: 216 output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0])) 217 for func_line in func_body[1:]: 218 output_lines.append('%s %s-NEXT: %s' % (comment_marker, checkprefix, func_line)) 219 break 220 221 # For IR output, change all defs to FileCheck variables, so we're immune 222 # to variable naming fashions. 223 func_body = genericize_check_lines(func_body, is_analyze) 224 225 # This could be selectively enabled with an optional invocation argument. 226 # Disabled for now: better to check everything. Be safe rather than sorry. 227 228 # Handle the first line of the function body as a special case because 229 # it's often just noise (a useless asm comment or entry label). 230 #if func_body[0].startswith("#") or func_body[0].startswith("entry:"): 231 # is_blank_line = True 232 #else: 233 # output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0])) 234 # is_blank_line = False 235 236 is_blank_line = False 237 238 for func_line in func_body: 239 if func_line.strip() == '': 240 is_blank_line = True 241 continue 242 # Do not waste time checking IR comments. 243 func_line = SCRUB_IR_COMMENT_RE.sub(r'', func_line) 244 245 # Skip blank lines instead of checking them. 246 if is_blank_line == True: 247 output_lines.append('{} {}: {}'.format( 248 comment_marker, checkprefix, func_line)) 249 else: 250 output_lines.append('{} {}-NEXT: {}'.format( 251 comment_marker, checkprefix, func_line)) 252 is_blank_line = False 253 254 # Add space between different check prefixes and also before the first 255 # line of code in the test function. 256 output_lines.append(comment_marker) 257 break 258 259def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict, func_name): 260 # Label format is based on IR string. 261 check_label_format = '{} %s-LABEL: @%s('.format(comment_marker) 262 add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, False) 263 264def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name): 265 check_label_format = '{} %s-LABEL: \'%s\''.format(comment_marker) 266 add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, True) 267