Make asan_symbolize.py py3-compatible

[chapuni]

Summary

This patch is squashed from my two private commits.

asan_symbolize.py: [Py3] Get rid of "print" statement. Use print() or write() instead.

Let me know if style issues anything.

asan_symbolize.py: [Py3] Use text mode with universal_newlines=True for Popen.

With universal_newlines, readline() stalls to fill the buffer. Therefore, let the pipe unbuffered.

FIXME: Use Popen.communicate()

ATM, I didn't touch their logic. I think they may be rewritten in future.

Tested both 2.7.6 and 3.4.3 on Ubuntu. Not tested on Windows yet.

[kcc]

We want to stop using asan_symbolize.py in favor of the "sancov" tools.
If sancov works for you -- just use it.
If it does not, please tell us why.

[chapuni]

asan_symbolize.py is used from check-asan tests. If you would like to obsolete it, I could apply this just to let tests pass before obsolete.

[kcc]

In D27404#661303, @chapuni wrote:

asan_symbolize.py is used from check-asan tests. If you would like to obsolete it, I could apply this just to let tests pass before obsolete.

Of course, we'll do this before deleting asan_symbolize.py.
Do you need this change because some of the LLVM bots are starting to use Python3, or because you want to use asan_symbolize.py elesewhere?
If the latter, consider sancov instead.

[chapuni]

@kcc, the former! check-asan is the last py3-incompatible one.

Please look into https://reviews.llvm.org/D27405 too!

[mgorny]

compiler-rt/trunk/lib/asan/scripts/asan_symbolize.py

111

Not saying it's a problem but strictly speaking to preserve the original semantic, you could use:

print(symbolizer_input, file=self.pipe.stdin)

+ at the top:

from __future__ import print_function

(with the latter being a good idea anyway)

[chapuni]

compiler-rt/trunk/lib/asan/scripts/asan_symbolize.py

111

I was not noticed future when tweaking.

As Kostya says above, asan_symbolize will be obsoleted. I think it'd be trivial.

compiler-rt/trunk/lib/asan/scripts/asan_symbolize.py

cmd = [self.symbolizer_path,
            '--demangle=%s' % demangle,
            '--functions=linkage',
            '--inlining=true',
            '--default-arch=%s' % self.default_arch]
     if self.system == 'Darwin':
       for hint in self.dsym_hints:
         cmd.append('--dsym-hint=%s' % hint)
     if DEBUG:
-      print ' '.join(cmd)
+      print(' '.join(cmd))
     try:
       result = subprocess.Popen(cmd, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 bufsize=0,
                                 universal_newlines=True)
     except OSError:
       result = None
     return result
 
   def symbolize(self, addr, binary, offset):
     """Overrides Symbolizer.symbolize."""
     if not self.pipe:
       return None
     result = []
     try:
       symbolizer_input = '"%s" %s' % (binary, offset)
       if DEBUG:
-        print symbolizer_input
-      print >> self.pipe.stdin, symbolizer_input
+        print(symbolizer_input)
+      self.pipe.stdin.write("%s\n" % symbolizer_input)
       while True:
         function_name = self.pipe.stdout.readline().rstrip()
         if not function_name:
           break
         file_name = self.pipe.stdout.readline().rstrip()
         file_name = fix_filename(file_name)
         if (not function_name.startswith('??') or
             not file_name.startswith('??')):
def open_addr2line(self):
     addr2line_tool = 'addr2line'
     if binutils_prefix:
       addr2line_tool = binutils_prefix + addr2line_tool
     cmd = [addr2line_tool, '-fi']
     if demangle:
       cmd += ['--demangle']
     cmd += ['-e', self.binary]
     if DEBUG:
-      print ' '.join(cmd)
+      print(' '.join(cmd))
     return subprocess.Popen(cmd,
                             stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                             bufsize=0,
                             universal_newlines=True)
 
   def symbolize(self, addr, binary, offset):
     """Overrides Symbolizer.symbolize."""
     if self.binary != binary:
       return None
     lines = []
     try:
-      print >> self.pipe.stdin, offset
-      print >> self.pipe.stdin, self.output_terminator
+      self.pipe.stdin.write("%s\n" % offset)
+      self.pipe.stdin.write("%s\n" % self.output_terminator)
       is_first_frame = True
       while True:
         function_name = self.pipe.stdout.readline().rstrip()
         file_name = self.pipe.stdout.readline().rstrip()
         if is_first_frame:
           is_first_frame = False
         elif function_name in ['', '??']:
           assert file_name == function_name
class DarwinSymbolizer(Symbolizer):
   def __init__(self, addr, binary, arch):
     super(DarwinSymbolizer, self).__init__()
     self.binary = binary
     self.arch = arch
     self.open_atos()
 
   def open_atos(self):
     if DEBUG:
-      print 'atos -o %s -arch %s' % (self.binary, self.arch)
+      print('atos -o %s -arch %s' % (self.binary, self.arch))
     cmdline = ['atos', '-o', self.binary, '-arch', self.arch]
     self.atos = UnbufferedLineConverter(cmdline, close_stderr=True)
 
   def symbolize(self, addr, binary, offset):
     """Overrides Symbolizer.symbolize."""
     if self.binary != binary:
       return None
     atos_line = self.atos.convert('0x%x' % int(offset, 16))
     while "got symbolicator for" in atos_line:
       atos_line = self.atos.readline()
     # A well-formed atos response looks like this:
     #   foo(type1, type2) (in object.name) (filename.cc:80)
     match = re.match('^(.*) \(in (.*)\) \((.*:\d*)\)$', atos_line)
     if DEBUG:
-      print 'atos_line: ', atos_line
+      print('atos_line: ', atos_line)
     if match:
       function_name = match.group(1)
       function_name = re.sub('\(.*?\)', '', function_name)
       file_name = fix_filename(match.group(3))
       return ['%s in %s %s' % (addr, function_name, file_name)]
     else:
       return ['%s in %s' % (addr, atos_line)]
 
class BreakpadSymbolizer(Symbolizer):
   def symbolize(self, addr, binary, offset):
     if self.binary != binary:
       return None
     res = self.get_sym_file_line(int(offset, 16))
     if res:
       function_name, file_name, line_no = res
       result = ['%s in %s %s:%d' % (
           addr, function_name, file_name, line_no)]
-      print result
+      print(result)
       return result
     else:
       return None
 
 
 class SymbolizationLoop(object):
   def __init__(self, binary_name_filter=None, dsym_hint_producer=None):
     if sys.platform == 'win32':
else:
         result.append('    #%s %s' % (str(self.frame_no), symbolized_frame.rstrip()))
         self.frame_no += 1
       return result
 
   def process_logfile(self):
     self.frame_no = 0
     for line in logfile:
       processed = self.process_line(line)
-      print '\n'.join(processed)
+      print('\n'.join(processed))
 
   def process_line_echo(self, line):
     return [line.rstrip()]
 
   def process_line_posix(self, line):
     self.current_line = line.rstrip()
     #0 0x7f6e35cf2e45  (/blah/foo.so+0x11fe45)
     stack_trace_line_format = (
         '^( *#([0-9]+) *)(0x[0-9a-f]+) *\((.*)\+(0x[0-9a-f]+)\)')
     match = re.match(stack_trace_line_format, line)
     if not match:
       return [self.current_line]
     if DEBUG:
-      print line
+      print(line)
     _, frameno_str, addr, binary, offset = match.groups()
     arch = ""
     # Arch can be embedded in the filename, e.g.: "libabc.dylib:x86_64h"
     colon_pos = binary.rfind(":")
     if colon_pos != -1:
       maybe_arch = binary[colon_pos+1:]
       if is_valid_arch(maybe_arch):
         arch = maybe_arch