Example script converting llvm-objdump -> objdump.

convert_tests_to_objdump.py

+#!/usr/bin/python
+
+import os
+import re
+import StringIO
+import sys
+import tempfile
+import textwrap
+import tokenize
+
+
+def GetFilesList(root_dir):
+  files = []
+  blacklist = ['load.ll', 'store.ll']
+  for (d, _, fs) in os.walk(root_dir):
+    for f in fs:
+      if f.endswith('.ll') and f not in blacklist:
+        files.append(os.path.join(d, f))
+  return files
+
+
+def MakeRegexRule(match, repl):
+  def Func(line):
+    return re.sub(match, repl, line)
+  return Func
+
+
+def MakeHexRule(match):
+  def Func(line):
+    m = re.match(match, line)
+    if m:
+      if not m.group(2).startswith('0x'):
+        return m.group(1) + ',' + hex(int(m.group(2))) + '\n'
+    return line
+  return Func
+
+def MakeHexOpRule(match):
+  def Func(line):
+    m = re.match(match, line)
+    if m:
+      if not (m.group(3).startswith('0x') or m.group(4).startswith('x')):
+        return m.group(1) + m.group(2) + hex(int(m.group(3))) + m.group(4) + '\n'
+    return line
+  return Func
+
+ALL_RULES = [
+  MakeRegexRule(r' -symbolize', r' --symbolize'),
+  MakeRegexRule(r'(.*-LABEL: .*):', r'\1'),
+  MakeRegexRule(r'dword ptr', r'DWORD PTR'),
+  MakeRegexRule(r' word ptr', r' WORD PTR'),
+  MakeRegexRule(r',word ptr', r',WORD PTR'),
+  MakeRegexRule(r'DWORD ptr', r'DWORD PTR'),
+  MakeRegexRule(r'qword ptr', r'QWORD PTR'),
+  MakeRegexRule(r'QWORD ptr', r'QWORD PTR'),
+  MakeRegexRule(r'byte ptr', r'BYTE PTR'),
+  MakeRegexRule(r'BYTE ptr', r'BYTE PTR'),
+  MakeRegexRule(r'xmmword ptr', r'XMMWORD PTR'),
+  MakeRegexRule(r'xmmword', r'XMMWORD'),
+  MakeRegexRule(r'(; CHECK: .*mov.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK: .*add.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK_.*mov.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK_.*add.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK-DAG: .*mov.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK-DAG: .*add.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK-NEXT: .*mov.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; CHECK-NEXT: .*add.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; OPTM1.*mov.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; OPTM1.*add.*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; SSE41: .*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; SSE41-NEXT: .*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; O2: .*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; O2-NEXT: .*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; OM1: .*), (.*)', r'\1,\2'),
+  MakeRegexRule(r'(; OM1-NEXT: .*), (.*)', r'\1,\2'),
+  # MakeRegexRule(r'(; CHECK: .*)\+ (.*)', r'\1+\2'),
+  # MakeRegexRule(r'(; CHECK: .*) \+(.*)', r'\1+\2'),
+  MakeRegexRule(r'(; CHECK_.*)\+ (.*)', r'\1+\2'),
+  MakeRegexRule(r'(; CHECK_.*) \+(.*)', r'\1+\2'),
+  # MakeRegexRule(r'(; CHECK-NEXT: .*)\+ (.*)', r'\1+\2'),
+  # MakeRegexRule(r'(; CHECK-NEXT: .*) \+(.*)', r'\1+\2'),
+  MakeRegexRule(r'(; OPTM1.*)\+ (.*)', r'\1+\2'),
+  MakeRegexRule(r'(; OPTM1.*) \+(.*)', r'\1+\2'),
+  # MakeRegexRule(r'(; OPTM1-NEXT: .*)\+ (.*)', r'\1+\2'),
+  # MakeRegexRule(r'(; OPTM1-NEXT: .*) \+(.*)', r'\1+\2'),
+  MakeRegexRule(r'(; O2: .*)\+ (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2: .*) \+(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2-NEXT: .*)\+ (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2-NEXT: .*) \+(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1: .*)\+ (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1: .*) \+(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1-NEXT: .*)\+ (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1-NEXT: .*) \+(.*)', r'\1-\2'),
+  # MakeHexRule(r'(; CHECK: .*), ([0-9]+)$'),
+  # MakeRegexRule(r'(; CHECK: .*)- (.*)', r'\1-\2'),
+  # MakeRegexRule(r'(; CHECK: .*) -(.*)', r'\1-\2'),
+  # MakeRegexRule(r'(; CHECK-NEXT: .*)- (.*)', r'\1-\2'),
+  # MakeRegexRule(r'(; CHECK-NEXT: .*) -(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OPTM1.*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OPTM1.*) -(.*)', r'\1-\2'),
+  # MakeRegexRule(r'(; OPTM1-NEXT: .*)- (.*)', r'\1-\2'),
+  # MakeRegexRule(r'(; OPTM1-NEXT: .*) -(.*)', r'\1-\2'),
+  MakeHexRule(r'(; CHECK_.*), ([0-9]+)$'),
+  MakeRegexRule(r'(; CHECK_.*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; CHECK_.*) -(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2: .*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2: .*) -(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2-NEXT: .*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; O2-NEXT: .*) -(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1: .*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1: .*) -(.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1-NEXT: .*)- (.*)', r'\1-\2'),
+  MakeRegexRule(r'(; OM1-NEXT: .*) -(.*)', r'\1-\2'),
+  # MakeHexRule(r'(; CHECK: .*), ([0-9]+)$'),
+  MakeHexRule(r'(; CHECK_.*), ([0-9]+)$'),
+  MakeHexRule(r'(; OPTM1.*), ([0-9]+)$'),
+  # MakeHexRule(r'(; CHECK-NEXT: .*), ([0-9]+)$'),
+  # MakeHexRule(r'(; OPTM1-NEXT: .*), ([0-9]+)$'),
+  #MakeHexRule(r'(; CHECK: .*),([0-9]+)$'),
+  MakeHexRule(r'(; CHECK_.*),([0-9]+)$'),
+  #MakeHexRule(r'(; OPTM1: .*),([0-9]+)$'),
+  #MakeHexRule(r'(; CHECK-NEXT: .*),([0-9]+)$'),
+  #MakeHexRule(r'(; OPTM1-NEXT: .*),([0-9]+)$'),
+  MakeHexRule(r'(; CHECK-DAG: .*),([0-9]+)$'),
+  MakeHexRule(r'(; CHECK-DAG: .*),([0-9]+)$'),
+  MakeHexRule(r'(; O2: .*),([0-9]+)$'),
+  MakeHexRule(r'(; O2-NEXT: .*),([0-9]+)$'),
+  MakeHexRule(r'(; OM1: .*),([0-9]+)$'),
+  MakeHexRule(r'(; OM1-NEXT: .*),([0-9]+)$'),
+  MakeHexRule(r'(; SSE41: .*),([0-9]+)$'),
+  MakeHexRule(r'(; SSE41: .*),([0-9]+)$'),
+  MakeHexRule(r'(; SSE41-NEXT: .*),([0-9]+)$'),
+  MakeHexRule(r'(; SSE41-NEXT: .*),([0-9]+)$'),
+  # This one is too blunt too, and usually they all double up the 0x0x.
+#  MakeHexOpRule(r'(; CHECK-NOT: .*)( )([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; CHECK: .*)(\+)([0-9]+)(.*)'),
+  MakeHexOpRule(r'(; CHECK_.*)(\+)([0-9]+)(.*)'),
+  MakeHexOpRule(r'(; OPTM1.*[xp])(\+)([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; CHECK-NEXT: .*)(\+)([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; OPTM1-NEXT: .*)(\+)([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; CHECK: .*[xp])(-)([0-9]+)(.*)'),
+  MakeHexOpRule(r'(; CHECK_.*[xp])(-)([0-9]+)(.*)'),
+  MakeHexOpRule(r'(; OPTM1.*[xp])(-)([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; CHECK-NEXT: .*[xp])(-)([0-9]+)(.*)'),
+  # MakeHexOpRule(r'(; OPTM1-NEXT: .*[xp])(-)([0-9]+)(.*)'),
+# This one is too blunt (convert indirect calls and non asm too).
+  #MakeRegexRule(r'(; CHECK: .*call) (.*)', r'\1 {{.*}} R_{{.*}} \2'),
+  #MakeRegexRule(r'(; CHECK-NEXT: .*call) (.*)', r'\1 {{.*}} R_{{.*}} \2'),
+  #MakeRegexRule(r'(; OPTM1: .*call) (.*)', r'\1 {{.*}} R_{{.*}} \2'),
+  #MakeRegexRule(r'(; OPTM1-NEXT: .*call) (.*)', r'\1 {{.*}} R_{{.*}} \2'),
+    ]
+
+
+def ApplyOnelinersToLine(line):
+  for r in ALL_RULES:
+    line = r(line)
+  return line
+
+
+def ApplyOnelinersToFile(filename):
+  print 'ApplyOnelinersToFile: %s' % filename
+  with open(filename, 'r') as orig:
+    # Create a temp file in the same directory so that it can be moved.
+    # Otherwise, we cannot move out of a different filesystem like /tmp
+    with tempfile.NamedTemporaryFile(dir=os.path.dirname(filename),
+                                     delete=False) as temp:
+      for line in orig.readlines():
+        newline = ApplyOnelinersToLine(line)
+        if line != newline:
+          print 'Rewriting %s' % line
+          print 'To %s' % newline
+        temp.write(newline)
+    os.rename(temp.name, filename)
+
+
+# THIS DOESN'T WORK YET... The spacing between tokens is all messed up.
+def ConvertNumbersToHexLine(line):
+  if not line.startswith('; CHECK'):
+    return line
+  result = []
+  g = tokenize.generate_tokens(StringIO.StringIO(line).readline)
+  for toknum, tokval, _, _, _  in g:
+    if toknum == tokenize.NUMBER:
+      print 'Abouts to convert :%s ' % tokval
+      result.append((tokenize.NUMBER, hex(int(tokval))))
+    else:
+      result.append((toknum, tokval))
+  return tokenize.untokenize(result)
+
+
+def ConvertNumbersToHex(filename):
+  print 'ConvertNumbersToHex: %s' % filename
+  with open(filename, 'r') as orig:
+    # Create a temp file in the same directory so that it can be moved.
+    # Otherwise, we cannot move out of a different filesystem like /tmp
+    with tempfile.NamedTemporaryFile(dir=os.path.dirname(filename),
+                                     delete=False) as temp:
+      for line in orig.readlines():
+        newline = ConvertNumbersToHexLine(line)
+        if line != newline:
+          print 'Rewriting %s' % line
+          print 'To %s' % newline
+        temp.write(newline)
+    os.rename(temp.name, filename)
+
+
+def ApplyFunkyHeaderChanges3(lines):
+  if len(lines) != 3:
+    return False, None
+  new1 = re.sub(r'; RUN: %p2i -i %s (.*) \\',
+                r'; RUN: %p2i -i %s --assemble --disassemble \1 \\',
+                lines[0])
+  match1 = new1 != lines[0]
+  match2 = re.match(
+    r'; RUN:   \| llvm-mc -triple=i686-none-nacl -filetype=obj \\', lines[1])
+  new3 = re.sub(
+    r'; RUN:   \| llvm-objdump -d --symbolize -x86-asm-syntax=intel - \| (.*)',
+    r'; RUN:   | \1',
+    lines[2])
+  match3 = new3 != lines[2]
+  # Try w/ -r also.
+  if not match3:
+    new3 = re.sub(
+      r'; RUN:   \| llvm-objdump -d -r --symbolize -x86-asm-syntax=intel - \| (.*)',
+      r'; RUN:   | \1',
+      lines[2])
+    match3 = new3 != lines[2]
+  if not (match1 and match2 and match3):
+    return False, None
+  maybe_wrap = textwrap.wrap(new1, 80, break_on_hyphens=False)
+  if len(maybe_wrap) > 1:
+    maybe_wrap[0] = maybe_wrap[0] + ' \\\n'
+    for i in xrange(1, len(maybe_wrap)):
+      maybe_wrap[i] = r'; RUN:   ' + maybe_wrap[i] + '\n'
+    return True, maybe_wrap + [new3]
+  else:
+    return True, [new1, new3]
+
+
+def ApplyFunkyHeaderChanges4(lines):
+  if len(lines) != 4:
+    return False, None
+  new1 = re.sub(r'; RUN: %p2i -i %s (.*) \\',
+                r'; RUN: %p2i -i %s --assemble --disassemble \1 \\',
+                lines[0])
+  match1 = new1 != lines[0]
+  match2 = re.match(
+    r'; RUN:   \| llvm-mc -triple=i686-none-nacl -filetype=obj \\', lines[1])
+  match3 = re.match(
+    r'; RUN:   \| llvm-objdump -d --symbolize -x86-asm-syntax=intel - \\',
+    lines[2])
+  if not match3:
+    match3 = re.match(
+      r'; RUN:   \| llvm-objdump -d -r --symbolize -x86-asm-syntax=intel - \\',
+    lines[2])
+  match4 = re.match(r'; RUN:   \| File.*', lines[3])
+  # There's no real change needed, but need to know if there's a match.
+  new4 = lines[3]
+  if not (match1 and match2 and match3 and match4):
+    return False, None
+  maybe_wrap = textwrap.wrap(new1, 80, break_on_hyphens=False)
+  if len(maybe_wrap) > 1:
+    maybe_wrap[0] = maybe_wrap[0] + ' \\\n'
+    for i in xrange(1, len(maybe_wrap)):
+      maybe_wrap[i] = r'; RUN:   ' + maybe_wrap[i] + '\n'
+    return True, maybe_wrap + [new4]
+  else:
+    return True, [new1, new4]
+
+
+def UndoTheCallTransformation(lines):
+  if len(lines) != 2:
+    return False, None
+  match1 = re.match(r'(; CHECK: .*call)', lines[0])
+  new2 = re.sub(
+    r'; CHECK-NEXT: (R_{{.*}} .*)',
+    r' {{.*}} \1',
+    lines[1])
+  match2 = new2 != lines[1]
+  if not (match1 and match2):
+    return False, None
+  return True, [match1.group(1) + new2]
+
+
+def FixLockChecks(lines):
+  if len(lines) != 2:
+    return False, None
+  match1 = re.match(r'(; CHECK: lock)', lines[0])
+  match2 = re.match(r'; CHECK-NEXT: (.*)', lines[1])
+  if not (match1 and match2):
+    return False, None
+  return True, [r'; CHECK: lock ' + match2.group(1) + '\n']
+
+
+def ApplyMultiLineEdits(filename, applier, num_lines):
+  print 'ApplyMultiLineEdits (%d): %s' % (num_lines, filename)
+  with open(filename, 'r') as orig:
+    lines = orig.readlines()
+    for i in xrange(0, len(lines) - (num_lines + 1)):
+      linesubs = lines[i:i + num_lines]
+      matched, newlines = applier(linesubs)
+      if matched:
+        print 'Rewriting %s' % linesubs
+        print 'To %s' % newlines
+        lines = lines[0:i] + newlines + lines[i + num_lines:]
+    with tempfile.NamedTemporaryFile(dir=os.path.dirname(filename),
+                                     delete=False) as temp:
+      for l in lines:
+        temp.write(l)
+      os.rename(temp.name, filename)
+
+
+def Main(argv):
+  if len(argv) != 1:
+    print 'Expected a directory base as args, got %s' % argv
+  files = GetFilesList(argv[0])
+  for f in files:
+    ApplyMultiLineEdits(f, ApplyFunkyHeaderChanges3, 3)
+    ApplyMultiLineEdits(f, ApplyFunkyHeaderChanges4, 4)
+#    ApplyMultiLineEdits(f, UndoTheCallTransformation, 2)
+    ApplyMultiLineEdits(f, FixLockChecks, 2)
+    ApplyOnelinersToFile(f)
+#    ConvertNumbersToHex(f)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(Main(sys.argv[1:]))