Support GLBIC example.

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.
 
 from __future__ import with_statement
 
 import errno
 import optparse
 import os
@@ skipping 11 matching lines @@
 NeededMatcher = re.compile('^ *NEEDED *([^ ]+)\n$')
 FormatMatcher = re.compile('^(.+):\\s*file format (.+)\n$')
 
 FORMAT_ARCH_MAP = {
     # Names returned by Linux's objdump:
     'elf64-x86-64': 'x86-64',
     'elf32-i386': 'x86-32',
     # Names returned by x86_64-nacl-objdump:
     'elf64-nacl': 'x86-64',
     'elf32-nacl': 'x86-32',
-    # TODO(mball): Add support for 'arm-32' and 'portable' architectures
-    # 'elf32-little': 'arm-32',
     }
 
+ARCH_LOCATION = {
+    'x86-32': 'lib32',
+    'x86-64': 'lib64',
+}
+
 # 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
 
 # The proper name of the dynamic linker, as kept in the IRT.  This is
 # excluded from the nmf file by convention.
 LD_NACL_MAP = {
@@ skipping 57 matching lines @@
           both for staging the libraries and for inclusion into the nmf file.
           Examples:  ['..'], ['lib_dir'] '''
     self.objdump = objdump
     self.main_files = main_files or []
     self.extra_files = extra_files or []
     self.lib_path = lib_path or []
     self.manifest = None
     self.needed = None
     self.lib_prefix = lib_prefix or []
 
+
   def GleanFromObjdump(self, files):
     '''Get architecture and dependency information for given files
 
     Args:
       files: A dict with key=filename and value=list or set of archs.  E.g.:
-          { '/path/to/my.nexe': ['x86-32', 'x86-64'],
-            '/path/to/libmy.so': ['x86-32'],
-            '/path/to/my2.nexe': None }  # Indicates all architectures
+          { '/path/to/my.nexe': ['x86-32']
+            '/path/to/lib64/libmy.so': ['x86-64'],
+            '/path/to/mydata.so': ['x86-32', 'x86-64'],
+            '/path/to/my.data': None }  # Indicates all architectures
 
     Returns: A tuple with the following members:
       input_info: A dict with key=filename and value=ArchFile of input files.
           Includes the input files as well, with arch filled in if absent.
           Example: { '/path/to/my.nexe': ArchFile(my.nexe),
                      '/path/to/libfoo.so': ArchFile(libfoo.so) }
       needed: A set of strings formatted as "arch/name".  Example:
           set(['x86-32/libc.so', 'x86-64/libgcc.so'])
     '''
     DebugPrint("GleanFromObjdump(%s)" % ([self.objdump, '-p'] + files.keys()))
     proc = subprocess.Popen([self.objdump, '-p'] + files.keys(),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE, bufsize=-1)
     input_info = {}
     needed = set()
     output, err_output = proc.communicate()
     for line in output.splitlines(True):
       # Objdump should display the architecture first and then the dependencies
       # second for each file in the list.
       matched = FormatMatcher.match(line)
       if matched is not None:
         filename = matched.group(1)
         arch = FORMAT_ARCH_MAP[matched.group(2)]
         if files[filename] is None or arch in files[filename]:
           name = os.path.basename(filename)
           input_info[filename] = ArchFile(
               arch=arch,
               name=name,
               path=filename,
-              url='/'.join(self.lib_prefix + [arch, name]))
+              url='/'.join(self.lib_prefix + [ARCH_LOCATION[arch], name]))
       matched = NeededMatcher.match(line)
       if matched is not None:
         if files[filename] is None or arch in files[filename]:
           needed.add('/'.join([arch, matched.group(1)]))
     status = proc.poll()
     if status != 0:
       raise Error('%s\nStdError=%s\nobjdump failed with error code: %d' %
                   (output, err_output, status))
     return input_info, needed
 
@@ skipping 21 matching lines @@
       A dict with key=filename and value=ArchFile of input files.
           Includes the input files as well, with arch filled in if absent.
           Example: { '/path/to/my.nexe': ArchFile(my.nexe),
                      '/path/to/libfoo.so': ArchFile(libfoo.so) }'''
     if not self.needed:
       DebugPrint('GetNeeded(%s)' % self.main_files)
       examined = set()
       all_files, unexamined = self.GleanFromObjdump(
           dict([(file, None) for file in self.main_files]))
       for name, arch_file in all_files.items():
-        arch_file.url = os.path.basename(name)
+        arch_file.url = name
         if unexamined:
           unexamined.add('/'.join([arch_file.arch, RUNNABLE_LD]))
       while unexamined:
         files_to_examine = {}
         for arch_name in unexamined:
           arch, name = arch_name.split('/')
           for path in self.FindLibsInPath(name):
             files_to_examine.setdefault(path, set()).add(arch)
         new_files, needed = self.GleanFromObjdump(files_to_examine)
         all_files.update(new_files)
@@ skipping 22 matching lines @@
                                  urllib.url2pathname(arch_file.url))
       try:
         os.makedirs(os.path.dirname(destination))
       except OSError as exception_info:
         if exception_info.errno != errno.EEXIST:
           raise
       if (os.path.normcase(os.path.abspath(source)) !=
           os.path.normcase(os.path.abspath(destination))):
         shutil.copy2(source, destination)
 
-  def _GenerateManifest(self):
-    programs = {}
-    files = {}
+  def _GenerateManifest(self, runnable=True):
+    '''Create a JSON formatted dict containing the files
+    
+    NaCl will map url requests based on architecture.  The startup NEXE
+    can always be found under the top key PROGRAM.  Additional files are under
+    the FILES key further mapped by file name.  In the case of 'runnable' the
+    PROGRAM key is populated with urls pointing the runnable-ld.so which acts
+    as the startup nexe.  The application itself, is then placed under the 
+    FILES key mapped as 'main.exe' instead of it's original name so that the
+    loader can find it.'''
+    manifest = { FILES_KEY: {}, PROGRAM_KEY: {} }
+    needed = self.GetNeeded()
 
-    def add_files(needed):
-      for filename, arch_file in needed.items():
-        files.setdefault(arch_file.arch, set()).add(arch_file.name)
+    for need in needed:
+      archinfo = needed[need]
+      urlinfo = { URL_KEY: archinfo.url }
+      name = archinfo.name
 
-    needed = self.GetNeeded()
-    add_files(needed)
+      # If starting with runnable-ld.so, make that the main executable.
+      if runnable:
+        if need.endswith(RUNNABLE_LD):
+          manifest[PROGRAM_KEY][archinfo.arch] = urlinfo
+          continue
 
-    for filename in self.main_files:
-      arch_file = needed[filename]
-      programs[arch_file.arch] = arch_file.name
+      # For the main nexes:
+      if need.endswith('.nexe') and need in self.main_files:
+        # Place it under program if we aren't using the runnable-ld.so.
+        if not runnable:
+          manifest[PROGRAM_KEY][archinfo.arch] = urlinfo
+          continue
+        # Otherwise, treat it like another another file named main.nexe.
+        name = MAIN_NEXE
 
-    filemap = {}
-    for arch in files:
-      for file in files[arch]:
-        if file not in programs.values() and file != RUNNABLE_LD:
-          filemap.setdefault(file, set()).add(arch)
+      fileinfo = manifest[FILES_KEY].get(name, {})
+      fileinfo[archinfo.arch] = urlinfo
+      manifest[FILES_KEY][name] = fileinfo
 
-    def arch_name(arch, file):
-      # nmf files expect unix-style path separators
-      return {URL_KEY: '/'.join(self.lib_prefix + [arch, file])}
-
-    # TODO(mcgrathr): perhaps notice a program with no deps
-    # (i.e. statically linked) and generate program=nexe instead?
-    manifest = {PROGRAM_KEY: {}, FILES_KEY: {MAIN_NEXE: {}}}
-    for arch in programs:
-      manifest[PROGRAM_KEY][arch] = arch_name(arch, RUNNABLE_LD)
-      manifest[FILES_KEY][MAIN_NEXE][arch] = {URL_KEY: programs[arch]}
-
-    for file in filemap:
-      manifest[FILES_KEY][file] = dict([(arch, arch_name(arch, file))
-                                      for arch in filemap[file]])
     self.manifest = manifest
 
   def GetManifest(self):
     '''Returns a JSON-formatted dict containing the NaCl dependencies'''
     if not self.manifest:
       self._GenerateManifest()
 
     return self.manifest
 
   def GetJson(self):
@@ skipping 14 matching lines @@
   parser.add_option('-D', '--objdump', dest='objdump', default='objdump',
                     help='Use TOOL as the "objdump" tool to run',
                     metavar='TOOL')
   parser.add_option('-L', '--library-path', dest='lib_path',
                     action='append', default=[],
                     help='Add DIRECTORY to library search path',
                     metavar='DIRECTORY')
   parser.add_option('-s', '--stage-dependencies', dest='stage_dependencies',
                     help='Destination directory for staging libraries',
                     metavar='DIRECTORY')
+  parser.add_option('-r', '--remove', dest='remove',
+                    help='Remove the prefix from the files.',
+                    metavar='PATH')
   (options, args) = parser.parse_args(argv)
 
   if len(args) < 1:
     parser.print_usage()
     sys.exit(1)
 
   nmf = NmfUtils(objdump=options.objdump,
                  main_files=args,
                  lib_path=options.lib_path)
 
   manifest = nmf.GetManifest()
 
   if options.output is None:
     sys.stdout.write(nmf.GetJson())
   else:
     with open(options.output, 'w') as output:
       output.write(nmf.GetJson())
 
   if options.stage_dependencies:
     nmf.StageDependencies(options.stage_dependencies)
 
 
 # Invoke this file directly for simple testing.
 if __name__ == '__main__':
   sys.exit(Main(sys.argv[1:]))