• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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