def main(): from argparse import RawTextHelpFormatter parser = argparse.ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter) parser.add_argument('--opt-binary', default='opt', help='The opt binary used to generate the test case') parser.add_argument('--function', help='The function in the test file to update') parser.add_argument('-p', '--preserve-names', action='store_true', help='Do not scrub IR names') parser.add_argument( '--function-signature', action='store_true', help='Keep function signature information around for the check line') parser.add_argument( '--scrub-attributes', action='store_true', help='Remove attribute annotations (#0) from the end of check line') parser.add_argument('--check-attributes', action='store_true', help='Check "Function Attributes" for functions') parser.add_argument('tests', nargs='+') initial_args = common.parse_commandline_args(parser) script_name = os.path.basename(__file__) opt_basename = os.path.basename(initial_args.opt_binary) if not re.match(r'^opt(-\d+)?(\.exe)?$', opt_basename): common.error('Unexpected opt name: ' + opt_basename) sys.exit(1) opt_basename = 'opt' for ti in common.itertests(initial_args.tests, parser, script_name='utils/' + script_name): # If requested we scrub trailing attribute annotations, e.g., '#0', together with whitespaces if ti.args.scrub_attributes: common.SCRUB_TRAILING_WHITESPACE_TEST_RE = common.SCRUB_TRAILING_WHITESPACE_AND_ATTRIBUTES_RE else: common.SCRUB_TRAILING_WHITESPACE_TEST_RE = common.SCRUB_TRAILING_WHITESPACE_RE prefix_list = [] for l in ti.run_lines: if '|' not in l: common.warn('Skipping unparseable RUN line: ' + l) continue (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)]) common.verify_filecheck_prefixes(filecheck_cmd) if not tool_cmd.startswith(opt_basename + ' '): common.warn('Skipping non-%s RUN line: %s' % (opt_basename, l)) continue if not filecheck_cmd.startswith('FileCheck '): common.warn('Skipping non-FileChecked RUN line: ' + l) continue tool_cmd_args = tool_cmd[len(opt_basename):].strip() tool_cmd_args = tool_cmd_args.replace('< %s', '').replace('%s', '').strip() check_prefixes = [ item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd) for item in m.group(1).split(',') ] if not check_prefixes: check_prefixes = ['CHECK'] # FIXME: We should use multiple check prefixes to common check lines. For # now, we just ignore all but the last. prefix_list.append((check_prefixes, tool_cmd_args)) global_vars_seen_dict = {} builder = common.FunctionTestBuilder(run_list=prefix_list, flags=ti.args, scrubber_args=[]) for prefixes, opt_args in prefix_list: common.debug('Extracted opt cmd: ' + opt_basename + ' ' + opt_args) common.debug('Extracted FileCheck prefixes: ' + str(prefixes)) raw_tool_output = common.invoke_tool(ti.args.opt_binary, opt_args, ti.path) builder.process_run_line(common.OPT_FUNCTION_RE, common.scrub_body, raw_tool_output, prefixes) func_dict = builder.finish_and_get_func_dict() is_in_function = False is_in_function_start = False prefix_set = set( [prefix for prefixes, _ in prefix_list for prefix in prefixes]) common.debug('Rewriting FileCheck prefixes:', str(prefix_set)) output_lines = [] include_generated_funcs = common.find_arg_in_test( ti, lambda args: ti.args.include_generated_funcs, '--include-generated-funcs', True) if include_generated_funcs: # Generate the appropriate checks for each function. We need to emit # these in the order according to the generated output so that CHECK-LABEL # works properly. func_order provides that. # We can't predict where various passes might insert functions so we can't # be sure the input function order is maintained. Therefore, first spit # out all the source lines. common.dump_input_lines(output_lines, ti, prefix_set, ';') # Now generate all the checks. common.add_checks_at_end( output_lines, prefix_list, builder.func_order(), ';', lambda my_output_lines, prefixes, func: common.add_ir_checks( my_output_lines, ';', prefixes, func_dict, func, False, ti. args.function_signature, global_vars_seen_dict)) else: # "Normal" mode. for input_line_info in ti.iterlines(output_lines): input_line = input_line_info.line args = input_line_info.args if is_in_function_start: if input_line == '': continue if input_line.lstrip().startswith(';'): m = common.CHECK_RE.match(input_line) if not m or m.group(1) not in prefix_set: output_lines.append(input_line) continue # Print out the various check lines here. common.add_ir_checks(output_lines, ';', prefix_list, func_dict, func_name, args.preserve_names, args.function_signature, global_vars_seen_dict) is_in_function_start = False if is_in_function: if common.should_add_line_to_output( input_line, prefix_set): # This input line of the function body will go as-is into the output. # Except make leading whitespace uniform: 2 spaces. input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub( r' ', input_line) output_lines.append(input_line) else: continue if input_line.strip() == '}': is_in_function = False continue # If it's outside a function, it just gets copied to the output. output_lines.append(input_line) m = common.IR_FUNCTION_RE.match(input_line) if not m: continue func_name = m.group(1) if args.function is not None and func_name != args.function: # When filtering on a specific function, skip all others. continue is_in_function = is_in_function_start = True common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path)) with open(ti.path, 'wb') as f: f.writelines( ['{}\n'.format(l).encode('utf-8') for l in output_lines])
def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( '--llc-binary', default=None, help='The "llc" binary to use to generate the test case') parser.add_argument('--function', help='The function in the test file to update') parser.add_argument( '--extra_scrub', action='store_true', help= 'Always use additional regex to further reduce diffs between various subtargets' ) parser.add_argument( '--x86_scrub_sp', action='store_true', default=True, help= 'Use regex for x86 sp matching to reduce diffs between various subtargets' ) parser.add_argument('--no_x86_scrub_sp', action='store_false', dest='x86_scrub_sp') parser.add_argument( '--x86_scrub_rip', action='store_true', default=True, help= 'Use more regex for x86 rip matching to reduce diffs between various subtargets' ) parser.add_argument('--no_x86_scrub_rip', action='store_false', dest='x86_scrub_rip') parser.add_argument('--no_x86_scrub_mem_shuffle', action='store_true', default=False, help='Reduce scrubbing shuffles with memory operands') parser.add_argument('tests', nargs='+') initial_args = common.parse_commandline_args(parser) script_name = os.path.basename(__file__) for ti in common.itertests(initial_args.tests, parser, script_name='utils/' + script_name): triple_in_ir = None for l in ti.input_lines: m = common.TRIPLE_IR_RE.match(l) if m: triple_in_ir = m.groups()[0] break run_list = [] for l in ti.run_lines: if '|' not in l: common.warn('Skipping unparseable RUN line: ' + l) continue commands = [cmd.strip() for cmd in l.split('|', 1)] llc_cmd = commands[0] llc_tool = llc_cmd.split(' ')[0] triple_in_cmd = None m = common.TRIPLE_ARG_RE.search(llc_cmd) if m: triple_in_cmd = m.groups()[0] march_in_cmd = None m = common.MARCH_ARG_RE.search(llc_cmd) if m: march_in_cmd = m.groups()[0] filecheck_cmd = '' if len(commands) > 1: filecheck_cmd = commands[1] common.verify_filecheck_prefixes(filecheck_cmd) if llc_tool not in LLC_LIKE_TOOLS: common.warn('Skipping non-llc RUN line: ' + l) continue if not filecheck_cmd.startswith('FileCheck '): common.warn('Skipping non-FileChecked RUN line: ' + l) continue llc_cmd_args = llc_cmd[len(llc_tool):].strip() llc_cmd_args = llc_cmd_args.replace('< %s', '').replace('%s', '').strip() if ti.path.endswith('.mir'): llc_cmd_args += ' -x mir' check_prefixes = [ item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd) for item in m.group(1).split(',') ] if not check_prefixes: check_prefixes = ['CHECK'] # FIXME: We should use multiple check prefixes to common check lines. For # now, we just ignore all but the last. run_list.append( (check_prefixes, llc_cmd_args, triple_in_cmd, march_in_cmd)) if ti.path.endswith('.mir'): check_indent = ' ' else: check_indent = '' func_dict = {} func_order = {} for p in run_list: prefixes = p[0] for prefix in prefixes: func_dict.update({prefix: dict()}) func_order.update({prefix: []}) for prefixes, llc_args, triple_in_cmd, march_in_cmd in run_list: common.debug('Extracted LLC cmd:', llc_tool, llc_args) common.debug('Extracted FileCheck prefixes:', str(prefixes)) raw_tool_output = common.invoke_tool( ti.args.llc_binary or llc_tool, llc_args, ti.path) triple = triple_in_cmd or triple_in_ir if not triple: triple = asm.get_triple_from_march(march_in_cmd) asm.build_function_body_dictionary_for_triple( ti.args, raw_tool_output, triple, prefixes, func_dict, func_order) is_in_function = False is_in_function_start = False func_name = None prefix_set = set([prefix for p in run_list for prefix in p[0]]) common.debug('Rewriting FileCheck prefixes:', str(prefix_set)) output_lines = [] include_generated_funcs = common.find_arg_in_test( ti, lambda args: ti.args.include_generated_funcs, '--include-generated-funcs', True) if include_generated_funcs: # Generate the appropriate checks for each function. We need to emit # these in the order according to the generated output so that CHECK-LABEL # works properly. func_order provides that. # We can't predict where various passes might insert functions so we can't # be sure the input function order is maintained. Therefore, first spit # out all the source lines. common.dump_input_lines(output_lines, ti, prefix_set, ';') # Now generate all the checks. common.add_checks_at_end( output_lines, run_list, func_order, check_indent + ';', lambda my_output_lines, prefixes, func: asm.add_asm_checks( my_output_lines, check_indent + ';', prefixes, func_dict, func)) else: for input_info in ti.iterlines(output_lines): input_line = input_info.line args = input_info.args if is_in_function_start: if input_line == '': continue if input_line.lstrip().startswith(';'): m = common.CHECK_RE.match(input_line) if not m or m.group(1) not in prefix_set: output_lines.append(input_line) continue # Print out the various check lines here. asm.add_asm_checks(output_lines, check_indent + ';', run_list, func_dict, func_name) is_in_function_start = False if is_in_function: if common.should_add_line_to_output( input_line, prefix_set): # This input line of the function body will go as-is into the output. output_lines.append(input_line) else: continue if input_line.strip() == '}': is_in_function = False continue # If it's outside a function, it just gets copied to the output. output_lines.append(input_line) m = common.IR_FUNCTION_RE.match(input_line) if not m: continue func_name = m.group(1) if args.function is not None and func_name != args.function: # When filtering on a specific function, skip all others. continue is_in_function = is_in_function_start = True common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path)) with open(ti.path, 'wb') as f: f.writelines( ['{}\n'.format(l).encode('utf-8') for l in output_lines])
def main(): initial_args, parser = config() script_name = os.path.basename(__file__) for ti in common.itertests(initial_args.tests, parser, 'utils/' + script_name, comment_prefix='//', argparse_callback=infer_dependent_args): # Build a list of clang command lines and check prefixes from RUN lines. run_list = [] line2spell_and_mangled_list = collections.defaultdict(list) subs = { '%s': ti.path, '%t': tempfile.NamedTemporaryFile().name, '%S': os.getcwd(), } for l in ti.run_lines: commands = [cmd.strip() for cmd in l.split('|')] triple_in_cmd = None m = common.TRIPLE_ARG_RE.search(commands[0]) if m: triple_in_cmd = m.groups()[0] # Parse executable args. exec_args = shlex.split(commands[0]) # Execute non-clang runline. if exec_args[0] not in SUBST: print('NOTE: Executing non-clang RUN line: ' + l, file=sys.stderr) # Do lit-like substitutions. for s in subs: exec_args = [ i.replace(s, subs[s]) if s in i else i for i in exec_args ] exec_run_line(exec_args) continue # This is a clang runline, apply %clang substitution rule, do lit-like substitutions, # and append args.clang_args clang_args = exec_args clang_args[0:1] = SUBST[clang_args[0]] for s in subs: clang_args = [ i.replace(s, subs[s]) if s in i else i for i in clang_args ] clang_args += ti.args.clang_args # Extract -check-prefix in FileCheck args filecheck_cmd = commands[-1] common.verify_filecheck_prefixes(filecheck_cmd) if not filecheck_cmd.startswith('FileCheck '): print('NOTE: Executing non-FileChecked clang RUN line: ' + l, file=sys.stderr) # Execute non-filechecked clang runline. exe = [ti.args.clang] + clang_args exec_run_line(exe) continue check_prefixes = [ item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd) for item in m.group(1).split(',') ] if not check_prefixes: check_prefixes = ['CHECK'] run_list.append( (check_prefixes, clang_args, commands[1:-1], triple_in_cmd)) # Execute clang, generate LLVM IR, and extract functions. builder = common.FunctionTestBuilder(run_list=run_list, flags=ti.args, scrubber_args=[]) for prefixes, clang_args, extra_commands, triple_in_cmd in run_list: common.debug('Extracted clang cmd: clang {}'.format(clang_args)) common.debug('Extracted FileCheck prefixes: {}'.format(prefixes)) get_function_body(builder, ti.args, ti.path, clang_args, extra_commands, prefixes) # Invoke clang -Xclang -ast-dump=json to get mapping from start lines to # mangled names. Forward all clang args for now. for k, v in get_line2spell_and_mangled(ti.args, clang_args).items(): line2spell_and_mangled_list[k].append(v) func_dict = builder.finish_and_get_func_dict() global_vars_seen_dict = {} prefix_set = set([prefix for p in run_list for prefix in p[0]]) output_lines = [] include_generated_funcs = common.find_arg_in_test( ti, lambda args: ti.args.include_generated_funcs, '--include-generated-funcs', True) if include_generated_funcs: # Generate the appropriate checks for each function. We need to emit # these in the order according to the generated output so that CHECK-LABEL # works properly. func_order provides that. # It turns out that when clang generates functions (for example, with # -fopenmp), it can sometimes cause functions to be re-ordered in the # output, even functions that exist in the source file. Therefore we # can't insert check lines before each source function and instead have to # put them at the end. So the first thing to do is dump out the source # lines. common.dump_input_lines(output_lines, ti, prefix_set, '//') # Now generate all the checks. def check_generator(my_output_lines, prefixes, func): if '-emit-llvm' in clang_args: common.add_ir_checks(my_output_lines, '//', prefixes, func_dict, func, False, ti.args.function_signature, global_vars_seen_dict) else: asm.add_asm_checks(my_output_lines, '//', prefixes, func_dict, func) common.add_checks_at_end( output_lines, run_list, builder.func_order(), '//', lambda my_output_lines, prefixes, func: check_generator( my_output_lines, prefixes, func)) else: # Normal mode. Put checks before each source function. for line_info in ti.iterlines(output_lines): idx = line_info.line_number line = line_info.line args = line_info.args include_line = True m = common.CHECK_RE.match(line) if m and m.group(1) in prefix_set: continue # Don't append the existing CHECK lines if idx in line2spell_and_mangled_list: added = set() for spell, mangled in line2spell_and_mangled_list[idx]: # One line may contain multiple function declarations. # Skip if the mangled name has been added before. # The line number may come from an included file, # we simply require the spelling name to appear on the line # to exclude functions from other files. if mangled in added or spell not in line: continue if args.functions is None or any( re.search(regex, spell) for regex in args.functions): last_line = output_lines[-1].strip() while last_line == '//': # Remove the comment line since we will generate a new comment # line as part of common.add_ir_checks() output_lines.pop() last_line = output_lines[-1].strip() if added: output_lines.append('//') added.add(mangled) common.add_ir_checks(output_lines, '//', run_list, func_dict, mangled, False, args.function_signature, global_vars_seen_dict) if line.rstrip('\n') == '//': include_line = False if include_line: output_lines.append(line.rstrip('\n')) common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path)) with open(ti.path, 'wb') as f: f.writelines( ['{}\n'.format(l).encode('utf-8') for l in output_lines]) return 0