[gentoo-commits] proj/pax-utils:master commit in: /

[Mike Frysinger]

commit:     9a9adbf228320fdc135ad1457bb8bf586c71279c
Author:     Mike Frysinger <vapier <AT> chromium <DOT> org>
AuthorDate: Thu Mar 26 18:32:57 2020 +0000
Commit:     Mike Frysinger <vapier <AT> gentoo <DOT> org>
CommitDate: Thu Apr 15 23:10:24 2021 +0000
URL:        https://gitweb.gentoo.org/proj/pax-utils.git/commit/?id=9a9adbf2

pylintrc: adjust python code to 4 space indent

This aligns with the latest Google/PEP standards.
This doesn't add any pylint warnings as we've been disabling long
lines in here for a long time.  We don't do any other reformatting
to try and cut down on git log/diff noise.

Looking at this with --word-diff=color shows only whitespace changes.

Signed-off-by: Mike Frysinger <vapier <AT> gentoo.org>

 .pylintrc  |    2 +-
 lddtree.py | 1270 ++++++++++++++++++++++++++++++------------------------------
 pylint     |   46 +--
 3 files changed, 659 insertions(+), 659 deletions(-)

diff --git a/.pylintrc b/.pylintrc
index cf1379d..577641f 100644
--- a/.pylintrc
+++ b/.pylintrc
@@ -36,7 +36,7 @@ score=no
 
 [FORMAT]
 max-line-length=80
-indent-string='  '
+indent-string = '    '
 
 [BASIC]
 bad-functions=

diff --git a/lddtree.py b/lddtree.py
index 141195b..cdb3f1c 100755
--- a/lddtree.py
+++ b/lddtree.py
@@ -55,107 +55,107 @@ from elftools.common import exceptions
 
 
 def warn(msg, prefix='warning'):
-  """Write |msg| to stderr with a |prefix| before it"""
-  print('%s: %s: %s' % (os.path.basename(sys.argv[0]), prefix, msg), file=sys.stderr)
+    """Write |msg| to stderr with a |prefix| before it"""
+    print('%s: %s: %s' % (os.path.basename(sys.argv[0]), prefix, msg), file=sys.stderr)
 
 
 def err(msg, status=1):
-  """Write |msg| to stderr and exit with |status|"""
-  warn(msg, prefix='error')
-  sys.exit(status)
+    """Write |msg| to stderr and exit with |status|"""
+    warn(msg, prefix='error')
+    sys.exit(status)
 
 
 def dbg(debug, *args, **kwargs):
-  """Pass |args| and |kwargs| to print() when |debug| is True"""
-  if debug:
-    print(*args, **kwargs)
+    """Pass |args| and |kwargs| to print() when |debug| is True"""
+    if debug:
+        print(*args, **kwargs)
 
 
 def bstr(buf):
-  """Decode the byte string into a string"""
-  if isinstance(buf, str):
-    return buf
-  return buf.decode('utf-8')
+    """Decode the byte string into a string"""
+    if isinstance(buf, str):
+        return buf
+    return buf.decode('utf-8')
 
 
 def normpath(path):
-  """Normalize a path
+    """Normalize a path
 
-  Python's os.path.normpath() doesn't handle some cases:
-    // -> //
-    //..// -> //
-    //..//..// -> ///
-  """
-  return os.path.normpath(path).replace('//', '/')
+    Python's os.path.normpath() doesn't handle some cases:
+      // -> //
+      //..// -> //
+      //..//..// -> ///
+    """
+    return os.path.normpath(path).replace('//', '/')
 
 
 def readlink(path, root, prefixed=False):
-  """Like os.readlink(), but relative to a |root|
+    """Like os.readlink(), but relative to a |root|
 
-  This does not currently handle the pathological case:
-    /lib/foo.so -> ../../../../../../../foo.so
-  This relies on the .. entries in / to point to itself.
+    This does not currently handle the pathological case:
+      /lib/foo.so -> ../../../../../../../foo.so
+    This relies on the .. entries in / to point to itself.
 
-  Args:
-    path: The symlink to read
-    root: The path to use for resolving absolute symlinks
-    prefixed: When False, the |path| must not have |root| prefixed to it, nor
-              will the return value have |root| prefixed.  When True, |path|
-              must have |root| prefixed, and the return value will have |root|
-              added.
+    Args:
+      path: The symlink to read
+      root: The path to use for resolving absolute symlinks
+      prefixed: When False, the |path| must not have |root| prefixed to it, nor
+          will the return value have |root| prefixed.  When True, |path|
+          must have |root| prefixed, and the return value will have |root|
+          added.
 
-  Returns:
-    A fully resolved symlink path
-  """
-  root = root.rstrip('/')
-  if prefixed:
-    path = path[len(root):]
+    Returns:
+      A fully resolved symlink path
+    """
+    root = root.rstrip('/')
+    if prefixed:
+        path = path[len(root):]
 
-  while os.path.islink(root + path):
-    path = os.path.join(os.path.dirname(path), os.readlink(root + path))
+    while os.path.islink(root + path):
+        path = os.path.join(os.path.dirname(path), os.readlink(root + path))
 
-  return normpath((root + path) if prefixed else path)
+    return normpath((root + path) if prefixed else path)
 
 
 def makedirs(path):
-  """Like os.makedirs(), but ignore EEXIST errors"""
-  try:
-    os.makedirs(path)
-  except OSError as e:
-    if e.errno != errno.EEXIST:
-      raise
+    """Like os.makedirs(), but ignore EEXIST errors"""
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
 
 
 def dedupe(items):
-  """Remove all duplicates from |items| (keeping order)"""
-  seen = {}
-  return [seen.setdefault(x, x) for x in items if x not in seen]
+    """Remove all duplicates from |items| (keeping order)"""
+    seen = {}
+    return [seen.setdefault(x, x) for x in items if x not in seen]
 
 
 def GenerateLdsoWrapper(root, path, interp, libpaths=()):
-  """Generate a shell script wrapper which uses local ldso to run the ELF
-
-  Since we cannot rely on the host glibc (or other libraries), we need to
-  execute the local packaged ldso directly and tell it where to find our
-  copies of libraries.
-
-  Args:
-    root: The root tree to generate scripts inside of
-    path: The full path (inside |root|) to the program to wrap
-    interp: The ldso interpreter that we need to execute
-    libpaths: Extra lib paths to search for libraries
-  """
-  basedir = os.path.dirname(path)
-  interp_dir, interp_name = os.path.split(interp)
-  # Add ldso interpreter dir to end of libpaths as a fallback library path.
-  libpaths = dedupe(list(libpaths) + [interp_dir])
-  replacements = {
-      'interp': os.path.join(os.path.relpath(interp_dir, basedir),
-                             interp_name),
-      'libpaths': ':'.join(['${basedir}/' + os.path.relpath(p, basedir)
-                            for p in libpaths]),
-  }
-  wrapper = """#!/bin/sh
+    """Generate a shell script wrapper which uses local ldso to run the ELF
+
+    Since we cannot rely on the host glibc (or other libraries), we need to
+    execute the local packaged ldso directly and tell it where to find our
+    copies of libraries.
+
+    Args:
+      root: The root tree to generate scripts inside of
+      path: The full path (inside |root|) to the program to wrap
+      interp: The ldso interpreter that we need to execute
+      libpaths: Extra lib paths to search for libraries
+    """
+    basedir = os.path.dirname(path)
+    interp_dir, interp_name = os.path.split(interp)
+    # Add ldso interpreter dir to end of libpaths as a fallback library path.
+    libpaths = dedupe(list(libpaths) + [interp_dir])
+    replacements = {
+        'interp': os.path.join(os.path.relpath(interp_dir, basedir),
+                               interp_name),
+        'libpaths': ':'.join(['${basedir}/' + os.path.relpath(p, basedir)
+                              for p in libpaths]),
+    }
+    wrapper = """#!/bin/sh
 if ! base=$(realpath "$0" 2>/dev/null); then
   case $0 in
   /*) base=$0;;
@@ -171,635 +171,635 @@ exec \
   "${base}.elf" \
   "$@"
 """
-  wrappath = root + path
-  os.rename(wrappath, wrappath + '.elf')
-  with open(wrappath, 'w') as f:
-    f.write(wrapper % replacements)
-  os.chmod(wrappath, 0o0755)
+    wrappath = root + path
+    os.rename(wrappath, wrappath + '.elf')
+    with open(wrappath, 'w') as f:
+        f.write(wrapper % replacements)
+    os.chmod(wrappath, 0o0755)
 
 
 def ParseLdPaths(str_ldpaths, root='', path=None):
-  """Parse the colon-delimited list of paths and apply ldso rules to each
-
-  Note the special handling as dictated by the ldso:
-   - Empty paths are equivalent to $PWD
-   - $ORIGIN is expanded to the path of the given file
-   - (TODO) $LIB and friends
-
-  Args:
-    str_ldpaths: A colon-delimited string of paths
-    root: The path to prepend to all paths found
-    path: The object actively being parsed (used for $ORIGIN)
-
-  Returns:
-    list of processed paths
-  """
-  ldpaths = []
-  for ldpath in str_ldpaths.split(':'):
-    if not ldpath:
-      # The ldso treats "" paths as $PWD.
-      ldpath = os.getcwd()
-    elif '$ORIGIN' in ldpath:
-      ldpath = ldpath.replace('$ORIGIN', os.path.dirname(path))
-    else:
-      ldpath = root + ldpath
-    ldpaths.append(normpath(ldpath))
-  return dedupe(ldpaths)
+    """Parse the colon-delimited list of paths and apply ldso rules to each
+
+    Note the special handling as dictated by the ldso:
+     - Empty paths are equivalent to $PWD
+     - $ORIGIN is expanded to the path of the given file
+     - (TODO) $LIB and friends
+
+    Args:
+      str_ldpaths: A colon-delimited string of paths
+      root: The path to prepend to all paths found
+      path: The object actively being parsed (used for $ORIGIN)
+
+    Returns:
+      list of processed paths
+    """
+    ldpaths = []
+    for ldpath in str_ldpaths.split(':'):
+        if not ldpath:
+            # The ldso treats "" paths as $PWD.
+            ldpath = os.getcwd()
+        elif '$ORIGIN' in ldpath:
+            ldpath = ldpath.replace('$ORIGIN', os.path.dirname(path))
+        else:
+            ldpath = root + ldpath
+        ldpaths.append(normpath(ldpath))
+    return dedupe(ldpaths)
 
 
 def ParseLdSoConf(ldso_conf, root='/', debug=False, _first=True):
-  """Load all the paths from a given ldso config file
-
-  This should handle comments, whitespace, and "include" statements.
-
-  Args:
-    ldso_conf: The file to scan
-    root: The path to prepend to all paths found
-    debug: Enable debug output
-    _first: Recursive use only; is this the first ELF ?
-
-  Returns:
-    list of paths found
-  """
-  paths = []
-
-  dbg_pfx = '' if _first else '  '
-  try:
-    dbg(debug, '%sParseLdSoConf(%s)' % (dbg_pfx, ldso_conf))
-    with open(ldso_conf) as f:
-      for line in f.readlines():
-        line = line.split('#', 1)[0].strip()
-        if not line:
-          continue
-        if line.startswith('include '):
-          line = line[8:]
-          if line[0] == '/':
-            line = root + line.lstrip('/')
-          else:
-            line = os.path.dirname(ldso_conf) + '/' + line
-          dbg(debug, '%s  glob: %s' % (dbg_pfx, line))
-          # ldconfig in glibc uses glob() which returns entries sorted according
-          # to LC_COLLATE.  Further, ldconfig does not reset that but respects
-          # the active env settings (which might be a mistake).  Python does not
-          # sort its results by default though, so do it ourselves.
-          for path in sorted(glob.glob(line)):
-            paths += ParseLdSoConf(path, root=root, debug=debug, _first=False)
-        else:
-          paths += [normpath(root + line)]
-  except IOError as e:
-    if e.errno != errno.ENOENT:
-      warn(e)
+    """Load all the paths from a given ldso config file
+
+    This should handle comments, whitespace, and "include" statements.
 
-  if _first:
-    # XXX: Load paths from ldso itself.
-    # Remove duplicate entries to speed things up.
-    paths = dedupe(paths)
+    Args:
+      ldso_conf: The file to scan
+      root: The path to prepend to all paths found
+      debug: Enable debug output
+      _first: Recursive use only; is this the first ELF ?
 
-  return paths
+    Returns:
+      list of paths found
+    """
+    paths = []
+
+    dbg_pfx = '' if _first else '  '
+    try:
+        dbg(debug, '%sParseLdSoConf(%s)' % (dbg_pfx, ldso_conf))
+        with open(ldso_conf) as f:
+            for line in f.readlines():
+                line = line.split('#', 1)[0].strip()
+                if not line:
+                    continue
+                if line.startswith('include '):
+                    line = line[8:]
+                    if line[0] == '/':
+                        line = root + line.lstrip('/')
+                    else:
+                        line = os.path.dirname(ldso_conf) + '/' + line
+                    dbg(debug, '%s  glob: %s' % (dbg_pfx, line))
+                    # ldconfig in glibc uses glob() which returns entries sorted according
+                    # to LC_COLLATE.  Further, ldconfig does not reset that but respects
+                    # the active env settings (which might be a mistake).  Python does not
+                    # sort its results by default though, so do it ourselves.
+                    for path in sorted(glob.glob(line)):
+                        paths += ParseLdSoConf(path, root=root, debug=debug, _first=False)
+                else:
+                    paths += [normpath(root + line)]
+    except IOError as e:
+        if e.errno != errno.ENOENT:
+            warn(e)
+
+    if _first:
+        # XXX: Load paths from ldso itself.
+        # Remove duplicate entries to speed things up.
+        paths = dedupe(paths)
+
+    return paths
 
 
 def LoadLdpaths(root='/', prefix='', debug=False):
-  """Load linker paths from common locations
-
-  This parses the ld.so.conf and LD_LIBRARY_PATH env var.
-
-  Args:
-    root: The root tree to prepend to paths
-    prefix: The path under |root| to search
-    debug: Enable debug output
-
-  Returns:
-    dict containing library paths to search
-  """
-  ldpaths = {
-      'conf': [],
-      'env': [],
-      'interp': [],
-  }
-
-  # Load up $LD_LIBRARY_PATH.
-  ldpaths['env'] = []
-  env_ldpath = os.environ.get('LD_LIBRARY_PATH')
-  if not env_ldpath is None:
-    if root != '/':
-      warn('ignoring LD_LIBRARY_PATH due to ROOT usage')
-    else:
-      # XXX: If this contains $ORIGIN, we probably have to parse this
-      # on a per-ELF basis so it can get turned into the right thing.
-      ldpaths['env'] = ParseLdPaths(env_ldpath, path='')
+    """Load linker paths from common locations
+
+    This parses the ld.so.conf and LD_LIBRARY_PATH env var.
+
+    Args:
+      root: The root tree to prepend to paths
+      prefix: The path under |root| to search
+      debug: Enable debug output
+
+    Returns:
+      dict containing library paths to search
+    """
+    ldpaths = {
+        'conf': [],
+        'env': [],
+        'interp': [],
+    }
 
-  # Load up /etc/ld.so.conf.
-  ldpaths['conf'] = ParseLdSoConf(root + prefix + '/etc/ld.so.conf', root=root,
-                                  debug=debug)
+    # Load up $LD_LIBRARY_PATH.
+    ldpaths['env'] = []
+    env_ldpath = os.environ.get('LD_LIBRARY_PATH')
+    if not env_ldpath is None:
+        if root != '/':
+            warn('ignoring LD_LIBRARY_PATH due to ROOT usage')
+        else:
+            # XXX: If this contains $ORIGIN, we probably have to parse this
+            # on a per-ELF basis so it can get turned into the right thing.
+            ldpaths['env'] = ParseLdPaths(env_ldpath, path='')
+
+    # Load up /etc/ld.so.conf.
+    ldpaths['conf'] = ParseLdSoConf(root + prefix + '/etc/ld.so.conf', root=root,
+                                    debug=debug)
 
-  return ldpaths
+    return ldpaths
 
 
 def CompatibleELFs(elf1, elf2):
-  """See if two ELFs are compatible
+    """See if two ELFs are compatible
 
-  This compares the aspects of the ELF to see if they're compatible:
-  bit size, endianness, machine type, and operating system.
+    This compares the aspects of the ELF to see if they're compatible:
+    bit size, endianness, machine type, and operating system.
 
-  Args:
-    elf1: an ELFFile object
-    elf2: an ELFFile object
+    Args:
+      elf1: an ELFFile object
+      elf2: an ELFFile object
 
-  Returns:
-    True if compatible, False otherwise
-  """
-  osabis = frozenset([e.header['e_ident']['EI_OSABI'] for e in (elf1, elf2)])
-  compat_sets = (
-      frozenset('ELFOSABI_%s' % x for x in ('NONE', 'SYSV', 'GNU', 'LINUX',)),
-  )
-  return ((len(osabis) == 1 or any(osabis.issubset(x) for x in compat_sets)) and
-          elf1.elfclass == elf2.elfclass and
-          elf1.little_endian == elf2.little_endian and
-          elf1.header['e_machine'] == elf2.header['e_machine'])
+    Returns:
+      True if compatible, False otherwise
+    """
+    osabis = frozenset([e.header['e_ident']['EI_OSABI'] for e in (elf1, elf2)])
+    compat_sets = (
+        frozenset('ELFOSABI_%s' % x for x in ('NONE', 'SYSV', 'GNU', 'LINUX',)),
+    )
+    return ((len(osabis) == 1 or any(osabis.issubset(x) for x in compat_sets)) and
+            elf1.elfclass == elf2.elfclass and
+            elf1.little_endian == elf2.little_endian and
+            elf1.header['e_machine'] == elf2.header['e_machine'])
 
 
 def FindLib(elf, lib, ldpaths, root='/', debug=False):
-  """Try to locate a |lib| that is compatible to |elf| in the given |ldpaths|
-
-  Args:
-    elf: The elf which the library should be compatible with (ELF wise)
-    lib: The library (basename) to search for
-    ldpaths: A list of paths to search
-    root: The root path to resolve symlinks
-    debug: Enable debug output
-
-  Returns:
-    Tuple of the full path to the desired library and the real path to it
-  """
-  dbg(debug, '  FindLib(%s)' % lib)
-
-  for ldpath in ldpaths:
-    path = os.path.join(ldpath, lib)
-    target = readlink(path, root, prefixed=True)
-    if path != target:
-      dbg(debug, '    checking: %s -> %s' % (path, target))
-    else:
-      dbg(debug, '    checking:', path)
+    """Try to locate a |lib| that is compatible to |elf| in the given |ldpaths|
+
+    Args:
+      elf: The elf which the library should be compatible with (ELF wise)
+      lib: The library (basename) to search for
+      ldpaths: A list of paths to search
+      root: The root path to resolve symlinks
+      debug: Enable debug output
+
+    Returns:
+      Tuple of the full path to the desired library and the real path to it
+    """
+    dbg(debug, '  FindLib(%s)' % lib)
+
+    for ldpath in ldpaths:
+        path = os.path.join(ldpath, lib)
+        target = readlink(path, root, prefixed=True)
+        if path != target:
+            dbg(debug, '    checking: %s -> %s' % (path, target))
+        else:
+            dbg(debug, '    checking:', path)
 
-    if os.path.exists(target):
-      with open(target, 'rb') as f:
-        try:
-          libelf = ELFFile(f)
-          if CompatibleELFs(elf, libelf):
-            return (target, path)
-        except exceptions.ELFError as e:
-          warn('%s: %s' % (target, e))
+        if os.path.exists(target):
+            with open(target, 'rb') as f:
+                try:
+                    libelf = ELFFile(f)
+                    if CompatibleELFs(elf, libelf):
+                        return (target, path)
+                except exceptions.ELFError as e:
+                    warn('%s: %s' % (target, e))
 
-  return (None, None)
+    return (None, None)
 
 
 # We abuse the _all_libs state.  We probably shouldn't, but we do currently.
 # pylint: disable=dangerous-default-value
 def ParseELF(path, root='/', prefix='', ldpaths={'conf':[], 'env':[], 'interp':[]},
              display=None, debug=False, _first=True, _all_libs={}):
-  """Parse the ELF dependency tree of the specified file
+    """Parse the ELF dependency tree of the specified file
 
-  Args:
-    path: The ELF to scan
-    root: The root tree to prepend to paths; this applies to interp and rpaths
+    Args:
+      path: The ELF to scan
+      root: The root tree to prepend to paths; this applies to interp and rpaths
           only as |path| and |ldpaths| are expected to be prefixed already
-    prefix: The path under |root| to search
-    ldpaths: dict containing library paths to search; should have the keys:
-             conf, env, interp
-    display: The path to show rather than |path|
-    debug: Enable debug output
-    _first: Recursive use only; is this the first ELF ?
-    _all_libs: Recursive use only; dict of all libs we've seen
-
-  Returns:
-    a dict containing information about all the ELFs; e.g.
-    {
-      'interp': '/lib64/ld-linux.so.2',
-      'needed': ['libc.so.6', 'libcurl.so.4',],
-      'libs': {
-        'libc.so.6': {
-          'path': '/lib64/libc.so.6',
-          'needed': [],
-        },
-        'libcurl.so.4': {
-          'path': '/usr/lib64/libcurl.so.4',
-          'needed': ['libc.so.6', 'librt.so.1',],
+      prefix: The path under |root| to search
+      ldpaths: dict containing library paths to search; should have the keys:
+          conf, env, interp
+      display: The path to show rather than |path|
+      debug: Enable debug output
+      _first: Recursive use only; is this the first ELF ?
+      _all_libs: Recursive use only; dict of all libs we've seen
+
+    Returns:
+      a dict containing information about all the ELFs; e.g.
+      {
+        'interp': '/lib64/ld-linux.so.2',
+        'needed': ['libc.so.6', 'libcurl.so.4',],
+        'libs': {
+          'libc.so.6': {
+            'path': '/lib64/libc.so.6',
+            'needed': [],
+          },
+          'libcurl.so.4': {
+            'path': '/usr/lib64/libcurl.so.4',
+            'needed': ['libc.so.6', 'librt.so.1',],
+          },
         },
-      },
-    }
-  """
-  if _first:
-    _all_libs = {}
-    ldpaths = ldpaths.copy()
-  ret = {
-      'interp': None,
-      'path': path if display is None else display,
-      'realpath': path,
-      'needed': [],
-      'rpath': [],
-      'runpath': [],
-      'libs': _all_libs,
-  }
-
-  dbg(debug, 'ParseELF(%s)' % path)
-
-  with open(path, 'rb') as f:
-    elf = ELFFile(f)
-
-    # If this is the first ELF, extract the interpreter.
+      }
+    """
     if _first:
-      for segment in elf.iter_segments():
-        if segment.header.p_type != 'PT_INTERP':
-          continue
-
-        interp = bstr(segment.get_interp_name())
-        dbg(debug, '  interp           =', interp)
-        ret['interp'] = normpath(root + interp)
-        real_interp = readlink(ret['interp'], root, prefixed=True)
-        ret['libs'][os.path.basename(interp)] = {
-            'path': ret['interp'],
-            'realpath': real_interp,
-            'needed': [],
-        }
-        # XXX: Could read it and scan for /lib paths.
-        # If the interp is a symlink, lets follow it on the assumption that it
-        # is in this path purely for ABI reasons, and the distro is using a
-        # different (probably more correct) path.  This can come up in some
-        # multilib situations like s390x where /lib64/ contains all the native
-        # libraries, but /lib/ld64.so.1 is the interp hardcoded in gcc, so the
-        # ld64.so.1 is really a symlink to ../lib64/ld64.so.1.  In the multiarch
-        # setup, it'll be /lib/ld64.so.1 -> /lib/s390x-linux-gnu/ld64.so.1.
-        # That is why we use |real_interp| here instead of |interp|.
-        ldpaths['interp'] = [
-            os.path.dirname(real_interp),
-            normpath(root + prefix + '/usr/' + os.path.dirname(
-                real_interp)[len(root) + len(prefix):]),
-        ]
-        dbg(debug, '  ldpaths[interp]  =', ldpaths['interp'])
-        break
-
-    # Parse the ELF's dynamic tags.
-    libs = []
-    rpaths = []
-    runpaths = []
-    for segment in elf.iter_segments():
-      if segment.header.p_type != 'PT_DYNAMIC':
-        continue
-
-      for t in segment.iter_tags():
-        if t.entry.d_tag == 'DT_RPATH':
-          rpaths = ParseLdPaths(bstr(t.rpath), root=root, path=path)
-        elif t.entry.d_tag == 'DT_RUNPATH':
-          runpaths = ParseLdPaths(bstr(t.runpath), root=root, path=path)
-        elif t.entry.d_tag == 'DT_NEEDED':
-          libs.append(bstr(t.needed))
-      if runpaths:
-        # If both RPATH and RUNPATH are set, only the latter is used.
-        rpaths = []
+        _all_libs = {}
+        ldpaths = ldpaths.copy()
+    ret = {
+        'interp': None,
+        'path': path if display is None else display,
+        'realpath': path,
+        'needed': [],
+        'rpath': [],
+        'runpath': [],
+        'libs': _all_libs,
+    }
 
-      # XXX: We assume there is only one PT_DYNAMIC.  This is
-      # probably fine since the runtime ldso does the same.
-      break
-    if _first:
-      # Propagate the rpaths used by the main ELF since those will be
-      # used at runtime to locate things.
-      ldpaths['rpath'] = rpaths
-      ldpaths['runpath'] = runpaths
-      dbg(debug, '  ldpaths[rpath]   =', rpaths)
-      dbg(debug, '  ldpaths[runpath] =', runpaths)
-    ret['rpath'] = rpaths
-    ret['runpath'] = runpaths
-    ret['needed'] = libs
-
-    # Search for the libs this ELF uses.
-    all_ldpaths = None
-    for lib in libs:
-      if lib in _all_libs:
-        continue
-      if all_ldpaths is None:
-        all_ldpaths = rpaths + ldpaths['rpath'] + ldpaths['env'] + runpaths + ldpaths['runpath'] + ldpaths['conf'] + ldpaths['interp']
-      realpath, fullpath = FindLib(elf, lib, all_ldpaths, root, debug=debug)
-      _all_libs[lib] = {
-          'realpath': realpath,
-          'path': fullpath,
-          'needed': [],
-      }
-      if fullpath:
-        try:
-          lret = ParseELF(realpath, root, prefix, ldpaths, display=fullpath,
-                          debug=debug, _first=False, _all_libs=_all_libs)
-        except exceptions.ELFError as e:
-          warn('%s: %s' % (realpath, e))
-        _all_libs[lib]['needed'] = lret['needed']
+    dbg(debug, 'ParseELF(%s)' % path)
+
+    with open(path, 'rb') as f:
+        elf = ELFFile(f)
+
+        # If this is the first ELF, extract the interpreter.
+        if _first:
+            for segment in elf.iter_segments():
+                if segment.header.p_type != 'PT_INTERP':
+                    continue
+
+                interp = bstr(segment.get_interp_name())
+                dbg(debug, '  interp           =', interp)
+                ret['interp'] = normpath(root + interp)
+                real_interp = readlink(ret['interp'], root, prefixed=True)
+                ret['libs'][os.path.basename(interp)] = {
+                    'path': ret['interp'],
+                    'realpath': real_interp,
+                    'needed': [],
+                }
+                # XXX: Could read it and scan for /lib paths.
+                # If the interp is a symlink, lets follow it on the assumption that it
+                # is in this path purely for ABI reasons, and the distro is using a
+                # different (probably more correct) path.  This can come up in some
+                # multilib situations like s390x where /lib64/ contains all the native
+                # libraries, but /lib/ld64.so.1 is the interp hardcoded in gcc, so the
+                # ld64.so.1 is really a symlink to ../lib64/ld64.so.1.  In the multiarch
+                # setup, it'll be /lib/ld64.so.1 -> /lib/s390x-linux-gnu/ld64.so.1.
+                # That is why we use |real_interp| here instead of |interp|.
+                ldpaths['interp'] = [
+                    os.path.dirname(real_interp),
+                    normpath(root + prefix + '/usr/' + os.path.dirname(
+                        real_interp)[len(root) + len(prefix):]),
+                ]
+                dbg(debug, '  ldpaths[interp]  =', ldpaths['interp'])
+                break
+
+        # Parse the ELF's dynamic tags.
+        libs = []
+        rpaths = []
+        runpaths = []
+        for segment in elf.iter_segments():
+            if segment.header.p_type != 'PT_DYNAMIC':
+                continue
+
+            for t in segment.iter_tags():
+                if t.entry.d_tag == 'DT_RPATH':
+                    rpaths = ParseLdPaths(bstr(t.rpath), root=root, path=path)
+                elif t.entry.d_tag == 'DT_RUNPATH':
+                    runpaths = ParseLdPaths(bstr(t.runpath), root=root, path=path)
+                elif t.entry.d_tag == 'DT_NEEDED':
+                    libs.append(bstr(t.needed))
+            if runpaths:
+                # If both RPATH and RUNPATH are set, only the latter is used.
+                rpaths = []
+
+            # XXX: We assume there is only one PT_DYNAMIC.  This is
+            # probably fine since the runtime ldso does the same.
+            break
+        if _first:
+            # Propagate the rpaths used by the main ELF since those will be
+            # used at runtime to locate things.
+            ldpaths['rpath'] = rpaths
+            ldpaths['runpath'] = runpaths
+            dbg(debug, '  ldpaths[rpath]   =', rpaths)
+            dbg(debug, '  ldpaths[runpath] =', runpaths)
+        ret['rpath'] = rpaths
+        ret['runpath'] = runpaths
+        ret['needed'] = libs
+
+        # Search for the libs this ELF uses.
+        all_ldpaths = None
+        for lib in libs:
+            if lib in _all_libs:
+                continue
+            if all_ldpaths is None:
+                all_ldpaths = rpaths + ldpaths['rpath'] + ldpaths['env'] + runpaths + ldpaths['runpath'] + ldpaths['conf'] + ldpaths['interp']
+            realpath, fullpath = FindLib(elf, lib, all_ldpaths, root, debug=debug)
+            _all_libs[lib] = {
+                'realpath': realpath,
+                'path': fullpath,
+                'needed': [],
+            }
+            if fullpath:
+                try:
+                    lret = ParseELF(realpath, root, prefix, ldpaths, display=fullpath,
+                                    debug=debug, _first=False, _all_libs=_all_libs)
+                except exceptions.ELFError as e:
+                    warn('%s: %s' % (realpath, e))
+                _all_libs[lib]['needed'] = lret['needed']
 
-    del elf
+        del elf
 
-  return ret
+    return ret
 # pylint: enable=dangerous-default-value
 
 
 class _NormalizePathAction(argparse.Action):
-  def __call__(self, parser, namespace, values, option_string=None):
-    setattr(namespace, self.dest, normpath(values))
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, normpath(values))
 
 
 def _ActionShow(options, elf):
-  """Show the dependency tree for this ELF"""
-  def _show(lib, depth):
-    chain_libs.append(lib)
-    fullpath = elf['libs'][lib]['path']
+    """Show the dependency tree for this ELF"""
+    def _show(lib, depth):
+        chain_libs.append(lib)
+        fullpath = elf['libs'][lib]['path']
+        if options.list:
+            print(fullpath or lib)
+        else:
+            print('%s%s => %s' % ('    ' * depth, lib, fullpath))
+
+        new_libs = []
+        for lib in elf['libs'][lib]['needed']:
+            if lib in chain_libs:
+                if not options.list:
+                    print('%s%s => !!! circular loop !!!' % ('    ' * depth, lib))
+                continue
+            if options.all or not lib in shown_libs:
+                shown_libs.add(lib)
+                new_libs.append(lib)
+
+        for lib in new_libs:
+            _show(lib, depth + 1)
+        chain_libs.pop()
+
+    shown_libs = set(elf['needed'])
+    new_libs = elf['needed'][:]
+    chain_libs = []
+    interp = elf['interp']
+    if interp:
+        lib = os.path.basename(interp)
+        shown_libs.add(lib)
+        # If we are in non-list mode, then we want to show the "duplicate" interp
+        # lines -- first the header (interp=>xxx), and then the DT_NEEDED line to
+        # show that the ELF is directly linked against the interp.
+        # If we're in list mode though, we only want to show the interp once.
+        # Unless of course we have the --all flag active, then we show everything.
+        if not options.all and options.list and lib in new_libs:
+            new_libs.remove(lib)
     if options.list:
-      print(fullpath or lib)
+        print(elf['path'])
+        if not interp is None:
+            print(interp)
     else:
-      print('%s%s => %s' % ('    ' * depth, lib, fullpath))
-
-    new_libs = []
-    for lib in elf['libs'][lib]['needed']:
-      if lib in chain_libs:
-        if not options.list:
-          print('%s%s => !!! circular loop !!!' % ('    ' * depth, lib))
-        continue
-      if options.all or not lib in shown_libs:
-        shown_libs.add(lib)
-        new_libs.append(lib)
-
+        print('%s (interpreter => %s)' % (elf['path'], interp))
     for lib in new_libs:
-      _show(lib, depth + 1)
-    chain_libs.pop()
-
-  shown_libs = set(elf['needed'])
-  new_libs = elf['needed'][:]
-  chain_libs = []
-  interp = elf['interp']
-  if interp:
-    lib = os.path.basename(interp)
-    shown_libs.add(lib)
-    # If we are in non-list mode, then we want to show the "duplicate" interp
-    # lines -- first the header (interp=>xxx), and then the DT_NEEDED line to
-    # show that the ELF is directly linked against the interp.
-    # If we're in list mode though, we only want to show the interp once.
-    # Unless of course we have the --all flag active, then we show everything.
-    if not options.all and options.list and lib in new_libs:
-      new_libs.remove(lib)
-  if options.list:
-    print(elf['path'])
-    if not interp is None:
-      print(interp)
-  else:
-    print('%s (interpreter => %s)' % (elf['path'], interp))
-  for lib in new_libs:
-    _show(lib, 1)
+        _show(lib, 1)
 
 
 def _ActionCopy(options, elf):
-  """Copy the ELF and its dependencies to a destination tree"""
-  def _StripRoot(path):
-    return path[len(options.root) - 1:]
-
-  def _copy(realsrc, src, striproot=True, wrapit=False, libpaths=(),
-            outdir=None):
-    if realsrc is None:
-      return
+    """Copy the ELF and its dependencies to a destination tree"""
+    def _StripRoot(path):
+        return path[len(options.root) - 1:]
 
-    if wrapit:
-      # Static ELFs don't need to be wrapped.
-      if not elf['interp']:
-        wrapit = False
+    def _copy(realsrc, src, striproot=True, wrapit=False, libpaths=(),
+              outdir=None):
+        if realsrc is None:
+            return
 
-    striproot = _StripRoot if striproot else lambda x: x
+        if wrapit:
+            # Static ELFs don't need to be wrapped.
+            if not elf['interp']:
+                wrapit = False
 
-    if outdir:
-      subdst = os.path.join(outdir, os.path.basename(src))
-    else:
-      subdst = striproot(src)
-    dst = options.dest + subdst
+        striproot = _StripRoot if striproot else lambda x: x
 
-    try:
-      # See if they're the same file.
-      nstat = os.stat(dst + ('.elf' if wrapit else ''))
-      ostat = os.stat(realsrc)
-      for field in ('mode', 'mtime', 'size'):
-        if getattr(ostat, 'st_' + field) != \
-           getattr(nstat, 'st_' + field):
-          break
-      else:
-        return
-    except OSError as e:
-      if e.errno != errno.ENOENT:
-        raise
+        if outdir:
+            subdst = os.path.join(outdir, os.path.basename(src))
+        else:
+            subdst = striproot(src)
+        dst = options.dest + subdst
 
-    if options.verbose:
-      print('%s -> %s' % (src, dst))
+        try:
+            # See if they're the same file.
+            nstat = os.stat(dst + ('.elf' if wrapit else ''))
+            ostat = os.stat(realsrc)
+            for field in ('mode', 'mtime', 'size'):
+                if getattr(ostat, 'st_' + field) != \
+                   getattr(nstat, 'st_' + field):
+                    break
+            else:
+                return
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+        if options.verbose:
+            print('%s -> %s' % (src, dst))
+
+        makedirs(os.path.dirname(dst))
+        try:
+            shutil.copy2(realsrc, dst)
+        except IOError:
+            os.unlink(dst)
+            shutil.copy2(realsrc, dst)
+
+        if wrapit:
+            if options.verbose:
+                print('generate wrapper %s' % (dst,))
+
+            if options.libdir:
+                interp = os.path.join(options.libdir, os.path.basename(elf['interp']))
+            else:
+                interp = _StripRoot(elf['interp'])
+            GenerateLdsoWrapper(options.dest, subdst, interp, libpaths)
+
+    # XXX: We should automatically import libgcc_s.so whenever libpthread.so
+    # is copied over (since we know it can be dlopen-ed by NPTL at runtime).
+    # Similarly, we should provide an option for automatically copying over
+    # the libnsl.so and libnss_*.so libraries, as well as an open ended list
+    # for known libs that get loaded (e.g. curl will dlopen(libresolv)).
+    uniq_libpaths = set()
+    for lib in elf['libs']:
+        libdata = elf['libs'][lib]
+        path = libdata['realpath']
+        if path is None:
+            warn('could not locate library: %s' % lib)
+            continue
+        if not options.libdir:
+            uniq_libpaths.add(_StripRoot(os.path.dirname(path)))
+        _copy(path, libdata['path'], outdir=options.libdir)
 
-    makedirs(os.path.dirname(dst))
-    try:
-      shutil.copy2(realsrc, dst)
-    except IOError:
-      os.unlink(dst)
-      shutil.copy2(realsrc, dst)
-
-    if wrapit:
-      if options.verbose:
-        print('generate wrapper %s' % (dst,))
-
-      if options.libdir:
-        interp = os.path.join(options.libdir, os.path.basename(elf['interp']))
-      else:
-        interp = _StripRoot(elf['interp'])
-      GenerateLdsoWrapper(options.dest, subdst, interp, libpaths)
-
-  # XXX: We should automatically import libgcc_s.so whenever libpthread.so
-  # is copied over (since we know it can be dlopen-ed by NPTL at runtime).
-  # Similarly, we should provide an option for automatically copying over
-  # the libnsl.so and libnss_*.so libraries, as well as an open ended list
-  # for known libs that get loaded (e.g. curl will dlopen(libresolv)).
-  uniq_libpaths = set()
-  for lib in elf['libs']:
-    libdata = elf['libs'][lib]
-    path = libdata['realpath']
-    if path is None:
-      warn('could not locate library: %s' % lib)
-      continue
     if not options.libdir:
-      uniq_libpaths.add(_StripRoot(os.path.dirname(path)))
-    _copy(path, libdata['path'], outdir=options.libdir)
-
-  if not options.libdir:
-    libpaths = list(uniq_libpaths)
-    if elf['runpath']:
-      libpaths = elf['runpath'] + libpaths
+        libpaths = list(uniq_libpaths)
+        if elf['runpath']:
+            libpaths = elf['runpath'] + libpaths
+        else:
+            libpaths = elf['rpath'] + libpaths
     else:
-      libpaths = elf['rpath'] + libpaths
-  else:
-    uniq_libpaths.add(options.libdir)
-    libpaths = list(uniq_libpaths)
+        uniq_libpaths.add(options.libdir)
+        libpaths = list(uniq_libpaths)
 
-  # We don't bother to copy this as ParseElf adds the interp to the 'libs',
-  # so it was already copied in the libs loop above.
-  #_copy(elf['interp'], outdir=options.libdir)
-  _copy(elf['realpath'], elf['path'], striproot=options.auto_root,
-        wrapit=options.generate_wrappers, libpaths=libpaths,
-        outdir=options.bindir)
+    # We don't bother to copy this as ParseElf adds the interp to the 'libs',
+    # so it was already copied in the libs loop above.
+    #_copy(elf['interp'], outdir=options.libdir)
+    _copy(elf['realpath'], elf['path'], striproot=options.auto_root,
+          wrapit=options.generate_wrappers, libpaths=libpaths,
+          outdir=options.bindir)
 
 
 def GetParser():
-  """Get a CLI parser."""
-  parser = argparse.ArgumentParser(
-      description=__doc__,
-      formatter_class=argparse.RawDescriptionHelpFormatter)
-  parser.add_argument('-a', '--all',
-                      action='store_true', default=False,
-                      help='Show all duplicated dependencies')
-  parser.add_argument('-R', '--root',
-                      default=os.environ.get('ROOT', ''), type=str,
-                      action=_NormalizePathAction,
-                      help='Search for all files/dependencies in ROOT')
-  parser.add_argument('-P', '--prefix',
-                      default=os.environ.get(
-                          'EPREFIX', '@GENTOO_PORTAGE_EPREFIX@'), type=str,
-                      action=_NormalizePathAction,
-                      help='Specify EPREFIX for binaries (for Gentoo Prefix)')
-  parser.add_argument('--no-auto-root',
-                      dest='auto_root', action='store_false', default=True,
-                      help='Do not automatically prefix input ELFs with ROOT')
-  parser.add_argument('-l', '--list',
-                      action='store_true', default=False,
-                      help='Display output in a simple list (easy for copying)')
-  parser.add_argument('-x', '--debug',
-                      action='store_true', default=False,
-                      help='Run with debugging')
-  parser.add_argument('-v', '--verbose',
-                      action='store_true', default=False,
-                      help='Be verbose')
-  parser.add_argument('--skip-non-elfs',
-                      action='store_true', default=False,
-                      help='Skip plain (non-ELF) files instead of warning')
-  parser.add_argument('-V', '--version',
-                      action='version',
-                      version='lddtree by Mike Frysinger <vapier@g.o>',
-                      help='Show version information')
-  parser.add_argument('path', nargs='+')
-
-  group = parser.add_argument_group('Copying options')
-  group.add_argument('--copy-to-tree',
-                     dest='dest', default=None, type=str,
-                     action=_NormalizePathAction,
-                     help='Copy all files to the specified tree')
-  group.add_argument('--bindir',
-                     default=None, type=str,
-                     action=_NormalizePathAction,
-                     help='Dir to store all ELFs specified on the command line')
-  group.add_argument('--libdir',
-                     default=None, type=str,
-                     action=_NormalizePathAction,
-                     help='Dir to store all ELF libs')
-  group.add_argument('--generate-wrappers',
-                     action='store_true', default=False,
-                     help='Wrap executable ELFs with scripts for local ldso')
-  group.add_argument('--copy-non-elfs',
-                     action='store_true', default=False,
-                     help='Copy over plain (non-ELF) files instead of warn+ignore')
-
-  return parser
+    """Get a CLI parser."""
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('-a', '--all',
+                        action='store_true', default=False,
+                        help='Show all duplicated dependencies')
+    parser.add_argument('-R', '--root',
+                        default=os.environ.get('ROOT', ''), type=str,
+                        action=_NormalizePathAction,
+                        help='Search for all files/dependencies in ROOT')
+    parser.add_argument('-P', '--prefix',
+                        default=os.environ.get(
+                            'EPREFIX', '@GENTOO_PORTAGE_EPREFIX@'), type=str,
+                        action=_NormalizePathAction,
+                        help='Specify EPREFIX for binaries (for Gentoo Prefix)')
+    parser.add_argument('--no-auto-root',
+                        dest='auto_root', action='store_false', default=True,
+                        help='Do not automatically prefix input ELFs with ROOT')
+    parser.add_argument('-l', '--list',
+                        action='store_true', default=False,
+                        help='Display output in a simple list (easy for copying)')
+    parser.add_argument('-x', '--debug',
+                        action='store_true', default=False,
+                        help='Run with debugging')
+    parser.add_argument('-v', '--verbose',
+                        action='store_true', default=False,
+                        help='Be verbose')
+    parser.add_argument('--skip-non-elfs',
+                        action='store_true', default=False,
+                        help='Skip plain (non-ELF) files instead of warning')
+    parser.add_argument('-V', '--version',
+                        action='version',
+                        version='lddtree by Mike Frysinger <vapier@g.o>',
+                        help='Show version information')
+    parser.add_argument('path', nargs='+')
+
+    group = parser.add_argument_group('Copying options')
+    group.add_argument('--copy-to-tree',
+                       dest='dest', default=None, type=str,
+                       action=_NormalizePathAction,
+                       help='Copy all files to the specified tree')
+    group.add_argument('--bindir',
+                       default=None, type=str,
+                       action=_NormalizePathAction,
+                       help='Dir to store all ELFs specified on the command line')
+    group.add_argument('--libdir',
+                       default=None, type=str,
+                       action=_NormalizePathAction,
+                       help='Dir to store all ELF libs')
+    group.add_argument('--generate-wrappers',
+                       action='store_true', default=False,
+                       help='Wrap executable ELFs with scripts for local ldso')
+    group.add_argument('--copy-non-elfs',
+                       action='store_true', default=False,
+                       help='Copy over plain (non-ELF) files instead of warn+ignore')
+
+    return parser
 
 
 def main(argv):
-  """The main entry point!"""
-  parser = GetParser()
-  options = parser.parse_args(argv)
-  paths = options.path
-
-  if options.root != '/':
-    options.root += '/'
-  if options.prefix == '@''GENTOO_PORTAGE_EPREFIX''@':
-    options.prefix = ''
-
-  if options.bindir and options.bindir[0] != '/':
-    parser.error('--bindir accepts absolute paths only')
-  if options.libdir and options.libdir[0] != '/':
-    parser.error('--libdir accepts absolute paths only')
-
-  if options.skip_non_elfs and options.copy_non_elfs:
-    parser.error('pick one handler for non-ELFs: skip or copy')
-
-  dbg(options.debug, 'root =', options.root)
-  if options.dest:
-    dbg(options.debug, 'dest =', options.dest)
-  if not paths:
-    err('missing ELF files to scan')
-
-  ldpaths = LoadLdpaths(options.root, options.prefix, debug=options.debug)
-  dbg(options.debug, 'ldpaths[conf] =', ldpaths['conf'])
-  dbg(options.debug, 'ldpaths[env]  =', ldpaths['env'])
-
-  # Process all the files specified.
-  ret = 0
-  for path in paths:
-    dbg(options.debug, 'argv[x]       =', path)
-    # Only auto-prefix the path if the ELF is absolute.
-    # If it's a relative path, the user most likely wants
-    # the local path.
-    if options.auto_root and path.startswith('/'):
-      path = options.root + path.lstrip('/')
-      dbg(options.debug, '  +auto-root  =', path)
-
-    matched = False
-    for p in glob.iglob(path):
-      # Once we've processed the globs, resolve the symlink.  This way you can
-      # operate on a path that is an absolute symlink itself.  e.g.:
-      #   $ ln -sf /bin/bash $PWD/root/bin/sh
-      #   $ lddtree --root $PWD/root /bin/sh
-      # First we'd turn /bin/sh into $PWD/root/bin/sh, then we want to resolve
-      # the symlink to $PWD/root/bin/bash rather than a plain /bin/bash.
-      dbg(options.debug, '  globbed     =', p)
-      if not path.startswith('/'):
-        realpath = os.path.realpath(path)
-      elif options.auto_root:
-        realpath = readlink(p, options.root, prefixed=True)
-      else:
-        realpath = path
-      if path != realpath:
-        dbg(options.debug, '  resolved    =', realpath)
-
-      matched = True
-      try:
-        elf = ParseELF(realpath, options.root, options.prefix, ldpaths,
-                       display=p, debug=options.debug)
-      except exceptions.ELFError as e:
-        if options.skip_non_elfs:
-          continue
-        # XXX: Ugly.  Should unify with _Action* somehow.
-        if options.dest is not None and options.copy_non_elfs:
-          if os.path.exists(p):
-            elf = {
-                'interp': None,
-                'libs': [],
-                'runpath': [],
-                'rpath': [],
-                'path': p,
-                'realpath': realpath,
-            }
-            _ActionCopy(options, elf)
-            continue
-        ret = 1
-        warn('%s: %s' % (p, e))
-        continue
-      except IOError as e:
-        ret = 1
-        warn('%s: %s' % (p, e))
-        continue
-
-      if options.dest is None:
-        _ActionShow(options, elf)
-      else:
-        _ActionCopy(options, elf)
-
-    if not matched:
-      ret = 1
-      warn('%s: did not match any paths' % (path,))
-
-  return ret
+    """The main entry point!"""
+    parser = GetParser()
+    options = parser.parse_args(argv)
+    paths = options.path
+
+    if options.root != '/':
+        options.root += '/'
+    if options.prefix == '@''GENTOO_PORTAGE_EPREFIX''@':
+        options.prefix = ''
+
+    if options.bindir and options.bindir[0] != '/':
+        parser.error('--bindir accepts absolute paths only')
+    if options.libdir and options.libdir[0] != '/':
+        parser.error('--libdir accepts absolute paths only')
+
+    if options.skip_non_elfs and options.copy_non_elfs:
+        parser.error('pick one handler for non-ELFs: skip or copy')
+
+    dbg(options.debug, 'root =', options.root)
+    if options.dest:
+        dbg(options.debug, 'dest =', options.dest)
+    if not paths:
+        err('missing ELF files to scan')
+
+    ldpaths = LoadLdpaths(options.root, options.prefix, debug=options.debug)
+    dbg(options.debug, 'ldpaths[conf] =', ldpaths['conf'])
+    dbg(options.debug, 'ldpaths[env]  =', ldpaths['env'])
+
+    # Process all the files specified.
+    ret = 0
+    for path in paths:
+        dbg(options.debug, 'argv[x]       =', path)
+        # Only auto-prefix the path if the ELF is absolute.
+        # If it's a relative path, the user most likely wants
+        # the local path.
+        if options.auto_root and path.startswith('/'):
+            path = options.root + path.lstrip('/')
+            dbg(options.debug, '  +auto-root  =', path)
+
+        matched = False
+        for p in glob.iglob(path):
+            # Once we've processed the globs, resolve the symlink.  This way you can
+            # operate on a path that is an absolute symlink itself.  e.g.:
+            #   $ ln -sf /bin/bash $PWD/root/bin/sh
+            #   $ lddtree --root $PWD/root /bin/sh
+            # First we'd turn /bin/sh into $PWD/root/bin/sh, then we want to resolve
+            # the symlink to $PWD/root/bin/bash rather than a plain /bin/bash.
+            dbg(options.debug, '  globbed     =', p)
+            if not path.startswith('/'):
+                realpath = os.path.realpath(path)
+            elif options.auto_root:
+                realpath = readlink(p, options.root, prefixed=True)
+            else:
+                realpath = path
+            if path != realpath:
+                dbg(options.debug, '  resolved    =', realpath)
+
+            matched = True
+            try:
+                elf = ParseELF(realpath, options.root, options.prefix, ldpaths,
+                               display=p, debug=options.debug)
+            except exceptions.ELFError as e:
+                if options.skip_non_elfs:
+                    continue
+                # XXX: Ugly.  Should unify with _Action* somehow.
+                if options.dest is not None and options.copy_non_elfs:
+                    if os.path.exists(p):
+                        elf = {
+                            'interp': None,
+                            'libs': [],
+                            'runpath': [],
+                            'rpath': [],
+                            'path': p,
+                            'realpath': realpath,
+                        }
+                        _ActionCopy(options, elf)
+                        continue
+                ret = 1
+                warn('%s: %s' % (p, e))
+                continue
+            except IOError as e:
+                ret = 1
+                warn('%s: %s' % (p, e))
+                continue
+
+            if options.dest is None:
+                _ActionShow(options, elf)
+            else:
+                _ActionCopy(options, elf)
+
+        if not matched:
+            ret = 1
+            warn('%s: did not match any paths' % (path,))
+
+    return ret
 
 
 if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+    sys.exit(main(sys.argv[1:]))

diff --git a/pylint b/pylint
index 965537d..38d77a2 100755
--- a/pylint
+++ b/pylint
@@ -12,38 +12,38 @@ import sys
 
 
 def find_all_modules(source_root):
-  """Locate all python modules in the tree for scanning"""
-  ret = []
+    """Locate all python modules in the tree for scanning"""
+    ret = []
 
-  for root, _dirs, files in os.walk(source_root, topdown=False):
-    # Add all of the .py modules in the tree.
-    ret += [os.path.join(root, x) for x in files if x.endswith('.py')]
+    for root, _dirs, files in os.walk(source_root, topdown=False):
+        # Add all of the .py modules in the tree.
+        ret += [os.path.join(root, x) for x in files if x.endswith('.py')]
 
-  # Add the main scripts that don't end in .py.
-  ret += [os.path.join(source_root, x) for x in ('pylint',)]
+    # Add the main scripts that don't end in .py.
+    ret += [os.path.join(source_root, x) for x in ('pylint',)]
 
-  return ret
+    return ret
 
 
 def main(argv):
-  """The main entry point"""
-  source_root = os.path.dirname(os.path.realpath(__file__))
+    """The main entry point"""
+    source_root = os.path.dirname(os.path.realpath(__file__))
 
-  if not argv:
-    argv = find_all_modules(source_root)
+    if not argv:
+        argv = find_all_modules(source_root)
 
-  pympath = source_root
-  pythonpath = os.environ.get('PYTHONPATH')
-  if pythonpath is None:
-    pythonpath = pympath
-  else:
-    pythonpath = pympath + ':' + pythonpath
-  os.environ['PYTHONPATH'] = pythonpath
+    pympath = source_root
+    pythonpath = os.environ.get('PYTHONPATH')
+    if pythonpath is None:
+        pythonpath = pympath
+    else:
+        pythonpath = pympath + ':' + pythonpath
+    os.environ['PYTHONPATH'] = pythonpath
 
-  pylintrc = os.path.join(source_root, '.pylintrc')
-  cmd = ['pylint', '--rcfile', pylintrc]
-  os.execvp(cmd[0], cmd + argv)
+    pylintrc = os.path.join(source_root, '.pylintrc')
+    cmd = ['pylint', '--rcfile', pylintrc]
+    os.execvp(cmd[0], cmd + argv)
 
 
 if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
+    sys.exit(main(sys.argv[1:]))