[NaCl SDK] Fix create_nmf to include arm/glibc ELF loader

native_client_sdk/src/tools/create_nmf.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Tool for automatically creating .nmf files from .nexe/.pexe/.bc executables.
 
 As well as creating the nmf file this tool can also find and stage
 any shared libraries dependencies that the executables might have.
 """
@@ skipping 18 matching lines @@
 sys.path.append(LIB_DIR)
 
 import elf
 import get_shared_deps
 import quote
 
 
 ARCH_LOCATION = {
     'x86-32': 'lib32',
     'x86-64': 'lib64',
-    'arm': 'lib',
+    'arm': 'libarm',
 }
 
 
 # These constants are used within nmf files.
-RUNNABLE_LD = 'runnable-ld.so'  # Name of the dynamic loader
 MAIN_NEXE = 'main.nexe'  # Name of entry point for execution
 PROGRAM_KEY = 'program'  # Key of the program section in an nmf file
 URL_KEY = 'url'  # Key of the url field for a particular file in an nmf file
 FILES_KEY = 'files'  # Key of the files section in an nmf file
 PNACL_OPTLEVEL_KEY = 'optlevel' # key for PNaCl optimization level
 PORTABLE_KEY = 'portable' # key for portable section of manifest
 TRANSLATE_KEY = 'pnacl-translate' # key for translatable objects
 TRANSLATE_DEBUG_KEY = 'pnacl-debug' # key for translatable debug objects
 
 
@@ skipping 80 matching lines @@
     return elf.ParseElfHeader(path)
   except elf.Error, e:
     raise Error(str(e))
 
 
 class Error(Exception):
   """Local Error class for this file."""
   pass
 
 
+def IsLoader(filename):
+  return (filename.endswith(get_shared_deps.LOADER_X86) or
+      filename.endswith(get_shared_deps.LOADER_ARM))
+
+
 class ArchFile(object):
   """Simple structure containing information about an architecture-specific
      file.
 
   Attributes:
     name: Name of this file
     path: Full path to this file on the build system
     arch: Architecture of this file (e.g., x86-32)
     url: Relative path to file in the staged web directory.
         Used for specifying the "url" attribute in the nmf file."""
@@ skipping 133 matching lines @@
         # This file is already in the nmf_root tree, so it does not need to be
         # staged. Just make the URL relative to the .nmf.
         url = PosixRelPath(arch_file.path, self.nmf_root)
       else:
         # This file is outside of the nmf_root subtree, so it needs to be
         # staged. Its path should be relative to the main .nexe with the same
         # architecture.
         prefix = arch_to_main_dir[arch_file.arch]
         url = os.path.basename(arch_file.path)
 
-      if arch_file.name.endswith('.nexe'):
+      if arch_file.name.endswith('.nexe') and not IsLoader(arch_file.name):
         prefix = posixpath.join(prefix, self.nexe_prefix)
       elif self.no_arch_prefix:
         prefix = posixpath.join(prefix, self.lib_prefix)
       else:
         prefix = posixpath.join(
             prefix, self.lib_prefix, ARCH_LOCATION[arch_file.arch])
       arch_file.url = posixpath.join(prefix, url)
 
   def StageDependencies(self, destination_dir):
     """Copies over the dependencies into a given destination directory
@@ skipping 59 matching lines @@
     needed = self.GetNeeded()
 
     extra_files_kv = [(key, ArchFile(name=key,
                                      arch=arch,
                                      path=url,
                                      url=url))
                       for key, arch, url in self.extra_files]
 
     manifest_items = needed.items() + extra_files_kv
 
-    # Add in runnable-ld.so entries to the program section.
+    # Add dynamic loader to the program section.
     for need, archinfo in manifest_items:
-      urlinfo = { URL_KEY: archinfo.url }
-      if need.endswith(RUNNABLE_LD):
+      if IsLoader(need):
+        urlinfo = { URL_KEY: archinfo.url }
         manifest[PROGRAM_KEY][archinfo.arch] = urlinfo
 
     for need, archinfo in manifest_items:
       urlinfo = { URL_KEY: archinfo.url }
       name = archinfo.name
       arch = archinfo.arch
 
-      if need.endswith(RUNNABLE_LD):
+      if IsLoader(need):
         continue
 
       if need in self.main_files:
         if need.endswith(".nexe"):
           # Place it under program if we aren't using the runnable-ld.so.
           program = manifest[PROGRAM_KEY]
           if arch not in program:
             program[arch] = urlinfo
             continue
           # Otherwise, treat it like another another file named main.nexe.
@@ skipping 150 matching lines @@
 
   bionic_dir = 'toolchain/%s_arm_bionic' % osname
   if os.path.isdir(os.path.join(sdk_root, bionic_dir)):
     libpath += [
       '%s/arm-nacl/lib' % bionic_dir,
       '%s/arm-nacl/usr/lib' % bionic_dir,
       'lib/bionic_arm/%s' % config,
     ]
   libpath = [os.path.normpath(p) for p in libpath]
   libpath = [os.path.join(sdk_root, p) for p in libpath]
+  libpath.append(os.path.join(sdk_root, 'tools'))
   return libpath
 
 
 def main(args):
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('-o', '--output', dest='output',
                       help='Write manifest file to FILE (default is stdout)',
                       metavar='FILE')
   parser.add_argument('-D', '--objdump', dest='objdump',
                       help='Override the default "objdump" tool used to find '
@@ skipping 139 matching lines @@
 if __name__ == '__main__':
   try:
     rtn = main(sys.argv[1:])
   except Error, e:
     sys.stderr.write('%s: %s\n' % (os.path.basename(__file__), e))
     rtn = 1
   except KeyboardInterrupt:
     sys.stderr.write('%s: interrupted\n' % os.path.basename(__file__))
     rtn = 1
   sys.exit(rtn)