Some updates/fixes to the creduce script.

[akhuang]

Summary

This was motivated by changes to llvm's not --crash disabling symbolization
but I ended up removing not from the script entirely because it
returns differently depending on whether clang "crashes" or exits for some
other reason. The script had to choose between calling not and not --crash
and sometimes it was wrong.

The script also now disables symbolization when we don't read the stack
trace because symbolizing is kind of slow.

[george.burgess.iv]

thanks!

clang/utils/creduce-clang-crash.py

156

nit return any(name in func_name for name in filters)?

[akhuang]

address comment

clang/utils/creduce-clang-crash.py

 import shlex
 import tempfile
 import shutil
 from distutils.spawn import find_executable
 
 verbose = False
 creduce_cmd = None
 clang_cmd = None
-not_cmd = None
 
 def verbose_print(*args, **kwargs):
   if verbose:
     print(*args, **kwargs)
 
 def check_file(fname):
   fname = os.path.normpath(fname)
   if not os.path.isfile(fname):
def __init__(self, crash_script, file_to_reduce):
     self.testfile = file_reduce_name + '.test.sh'
     self.crash_script = crash_script_name + '.reduced' + crash_script_ext
     self.file_to_reduce = file_reduce_name + '.reduced' + file_reduce_ext
     shutil.copy(file_to_reduce, self.file_to_reduce)
 
     self.clang = clang_cmd
     self.clang_args = []
     self.expected_output = []
-    self.is_crash = True
+    self.needs_stack_trace = False
     self.creduce_flags = ["--tidy"]
 
     self.read_clang_args(crash_script, file_to_reduce)
     self.read_expected_output()
 
   def get_crash_cmd(self, cmd=None, args=None, filename=None):
     if not cmd:
       cmd = self.clang
def read_expected_output(self):
     crash_output, _ = p.communicate()
     result = []
 
     # Remove color codes
     ansi_escape = r'\x1b\[[0-?]*m'
     crash_output = re.sub(ansi_escape, '', crash_output.decode('utf-8'))
 
     # Look for specific error messages
-    regexes = [r"Assertion `(.+)' failed", # Linux assert()
-               r"Assertion failed: (.+),", # FreeBSD/Mac assert()
-               r"fatal error: error in backend: (.+)",
-               r"LLVM ERROR: (.+)",
-               r"UNREACHABLE executed (at .+)?!",
-               r"LLVM IR generation of declaration '(.+)'",
-               r"Generating code for declaration '(.+)'",
-               r"\*\*\* Bad machine code: (.+) \*\*\*"]
+    regexes = [r"Assertion .+ failed", # Linux assert()
+               r"Assertion failed: .+,", # FreeBSD/Mac assert()
+               r"fatal error: error in backend: .+",
+               r"LLVM ERROR: .+",
+               r"UNREACHABLE executed at .+?!",
+               r"LLVM IR generation of declaration '.+'",
+               r"Generating code for declaration '.+'",
+               r"\*\*\* Bad machine code: .+ \*\*\*"]
     for msg_re in regexes:
       match = re.search(msg_re, crash_output)
       if match:
-        msg = match.group(1)
+        msg = match.group(0)
         result = [msg]
         print("Found message:", msg)
-
-        if "fatal error:" in msg_re:
-          self.is_crash = False
         break
 
     # If no message was found, use the top five stack trace functions,
     # ignoring some common functions
     # Five is a somewhat arbitrary number; the goal is to get a small number
     # of identifying functions with some leeway for common functions
     if not result:
+      self.needs_stack_trace = True
       stacktrace_re = r'[0-9]+\s+0[xX][0-9a-fA-F]+\s*([^(]+)\('
-      filters = ["PrintStackTraceSignalHandler",
-                 "llvm::sys::RunSignalHandlers",
-                 "SignalHandler", "__restore_rt", "gsignal", "abort"]
+      filters = ["PrintStackTrace", "RunSignalHandlers", "CleanupOnSignal",
+                 "HandleCrash", "SignalHandler", "__restore_rt", "gsignal", "abort"]
+      def skip_function(func_name):
+        for name in filters:
+          if name in func_name:
+            return True
+        return False
+
       matches = re.findall(stacktrace_re, crash_output)
-      result = [x for x in matches if x and x.strip() not in filters][:5]
+      result = [x for x in matches if x and not skip_function(x)][:5]
       for msg in result:
         print("Found stack trace function:", msg)
 
     if not result:
       print("ERROR: no crash was found")
       print("The crash output was:\n========\n%s========" % crash_output)
       sys.exit(1)
 
p = subprocess.Popen(self.get_crash_cmd(args=args, filename=filename),
                          stderr=subprocess.STDOUT)
     crash_output, _ = p.communicate()
     return all(msg in crash_output.decode('utf-8') for msg in
                self.expected_output)
 
   def write_interestingness_test(self):
     print("\nCreating the interestingness test...")
 
-    crash_flag = "--crash" if self.is_crash else ""
-
-    output = "#!/bin/bash\n%s %s %s >& t.log || exit 1\n" % \
-        (pipes.quote(not_cmd), crash_flag, quote_cmd(self.get_crash_cmd()))
+    # Disable symbolization if it's not required to avoid slow symbolization.
+    disable_symbolization = ''
+    if not self.needs_stack_trace:
+      disable_symbolization = 'export LLVM_DISABLE_SYMBOLIZATION=1'
+
+    output = """#!/bin/bash
+%s
+if %s >& t.log ; then
+  exit 1
+fi
+""" % (disable_symbolization, quote_cmd(self.get_crash_cmd()))
 
     for msg in self.expected_output:
       output += 'grep -F %s t.log || exit 1\n' % pipes.quote(msg)
 
     write_to_script(output, self.testfile)
     self.check_interestingness()
 
   def check_interestingness(self):
except KeyboardInterrupt:
       # Hack to kill C-Reduce because it jumps into its own pgid
       print('\n\nctrl-c detected, killed creduce')
       p.kill()
 
 def main():
   global verbose
   global creduce_cmd
   global clang_cmd
-  global not_cmd
 
   parser = ArgumentParser(description=__doc__,
                           formatter_class=RawTextHelpFormatter)
   parser.add_argument('crash_script', type=str, nargs=1,
                       help="Name of the script that generates the crash.")
   parser.add_argument('file_to_reduce', type=str, nargs=1,
                       help="Name of the file to be reduced.")
   parser.add_argument('--llvm-bin', dest='llvm_bin', type=str,
                       help="Path to the LLVM bin directory.")
-  parser.add_argument('--llvm-not', dest='llvm_not', type=str,
-                      help="The path to the `not` executable. "
-                      "By default uses the llvm-bin directory.")
   parser.add_argument('--clang', dest='clang', type=str,
                       help="The path to the `clang` executable. "
                       "By default uses the llvm-bin directory.")
   parser.add_argument('--creduce', dest='creduce', type=str,
                       help="The path to the `creduce` executable. "
                       "Required if `creduce` is not in PATH environment.")
   parser.add_argument('-v', '--verbose', action='store_true')
   args = parser.parse_args()
 
   verbose = args.verbose
   llvm_bin = os.path.abspath(args.llvm_bin) if args.llvm_bin else None
   creduce_cmd = check_cmd('creduce', None, args.creduce)
   clang_cmd = check_cmd('clang', llvm_bin, args.clang)
-  not_cmd = check_cmd('not', llvm_bin, args.llvm_not)
 
   crash_script = check_file(args.crash_script[0])
   file_to_reduce = check_file(args.file_to_reduce[0])
 
   r = Reduce(crash_script, file_to_reduce)
 
   r.simplify_clang_args()
   r.write_interestingness_test()
   r.clang_preprocess()
   r.run_creduce()
   r.reduce_clang_args()
 
 if __name__ == '__main__':
   main()