Add options for base dir and redirecting files to IRT open resource and use it.

pnacl/driver/nativeld.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 #
 #
 # This is a thin wrapper for native LD. This is not meant to be
 # used by the user, but is called from pnacl-translate.
 # This implements the native linking part of translation.
 #
 # All inputs must be native objects or linker scripts.
 #
 # --pnacl-sb will cause the sandboxed LD to be used.
 # The bulk of this file is logic to invoke the sandboxed translator.
 
 import subprocess
 
 from driver_tools import CheckTranslatorPrerequisites, GetArch, ParseArgs, \
     Run, UnrecognizedOption
 from driver_env import env
 from driver_log import Log
 import ldtools
 import pathtools
 
 
 EXTRA_ENV = {
   'INPUTS'   : '',
   'OUTPUT'   : '',
 
-  # the INPUTS file coming from the llc translation step
+  # The INPUTS file coming from the llc translation step
   'LLC_TRANSLATED_FILE' : '',
+  # Number of separate modules used for multi-threaded translation. This should
+  # have been set by pnacl-translate, but default to 0 for checking.
   'SPLIT_MODULE' : '0',
   'USE_STDLIB': '1',
 
   # Upstream gold has the segment gap built in, but the gap can be modified
   # when not using the IRT. The gap does need to be at least one bundle so the
   # halt sled can be added for the TCB in case the segment ends up being a
   # multiple of 64k.
   # --eh-frame-hdr asks the linker to generate an .eh_frame_hdr section,
   # which is a presorted list of registered frames. This section is
   # used by libgcc_eh/libgcc_s to avoid doing the sort during runtime.
@@ skipping 134 matching lines @@
   # The "main" input file is the application's combined object file.
   all_inputs = env.get('inputs')
 
   main_input = env.getone('LLC_TRANSLATED_FILE')
   if not main_input:
     Log.Fatal("Sandboxed LD requires one shm input file")
 
   outfile = env.getone('output')
 
   modules = int(env.getone('SPLIT_MODULE'))
-  if modules > 1:
-    first_mainfile = all_inputs.index(main_input)
-    first_extra = all_inputs.index(main_input) + modules
-    # Just the split module files
-    llc_outputs = all_inputs[first_mainfile:first_extra]
-    # everything else
-    all_inputs = all_inputs[:first_mainfile] + all_inputs[first_extra:]
-  else:
-    llc_outputs = [main_input]
+  assert modules >= 1
+  first_mainfile = all_inputs.index(main_input)

[Mark Seaborn, 2014/12/01 20:54:16]

Is this part just general cleanup, on the grounds that the "if" case can handle
what the "else" case was handling?

This would be worth explaining in the commit message.

[jvoung (off chromium), 2014/12/01 22:00:09]

I want the "else" case to be the same as the "if" case, so that the llc files
don't get mixed up with the libraries, when num modules == 1.

Otherwise, the GetNativeLibsDirname() call below will end up seeing some files
in the native lib directory, and a file (the llc output file) in a different
directory, and that breaks the check that all native libs use the same base
directory when setting the env var.

+  first_extra = all_inputs.index(main_input) + modules
+  # Have a list of just the split module files.
+  llc_outputs = all_inputs[first_mainfile:first_extra]
+  # Have a list of everything else.
+  other_inputs = all_inputs[:first_mainfile] + all_inputs[first_extra:]
 
-  files = LinkerFiles(all_inputs)
   ld_flags = env.get('LD_FLAGS')
 
   script = MakeSelUniversalScriptForLD(ld_flags,
                                        llc_outputs,
-                                       files,
                                        outfile)
 
-
+  native_libs_dirname = pathtools.tosys(GetNativeLibsDirname(other_inputs))
   Run('${SEL_UNIVERSAL_PREFIX} ${SEL_UNIVERSAL} ' +
-      '${SEL_UNIVERSAL_FLAGS} -B ${IRT_BLOB} -- ${LD_SB}',
+      '${SEL_UNIVERSAL_FLAGS} -a -B ${IRT_BLOB} ' +
+      '-E NACL_IRT_OPEN_RESOURCE_BASE=' + native_libs_dirname + ' ' +
+      '-E NACL_IRT_OPEN_RESOURCE_REMAP=' +
+      'libpnacl_irt_shim.a:libpnacl_irt_shim_dummy.a' +
+      ' -- ${LD_SB}',
       stdin_contents=script,
       # stdout/stderr will be automatically dumped
       # upon failure
       redirect_stderr=subprocess.PIPE,
       redirect_stdout=subprocess.PIPE)
 
 
 def MakeSelUniversalScriptForLD(ld_flags,
                                 llc_outputs,
-                                files,
                                 outfile):
   """ Return sel_universal script text for invoking LD.nexe with the
-  given ld_flags, llc_outputs (which are treated specially), and
-  other input files (for native libraries). The output will be written
-  to outfile.  """
+  given ld_flags, and llc_outputs (which are treated specially).
+  The output will be written to outfile.  """
   script = []
 
   # Open the output file.
   script.append('readwrite_file nexefile %s' % outfile)
 
-  files_to_map = list(files)
-  # Create a reverse-service mapping for each input file and add it to
-  # the sel universal script.
-  for f in files_to_map:
-    basename = pathtools.basename(f)
-    # If we are using the dummy shim, map it with the filename of the real
-    # shim, so the baked-in commandline will work.
-    if basename == 'libpnacl_irt_shim_dummy.a':
-      basename = 'libpnacl_irt_shim.a'
-    script.append('reverse_service_add_manifest_mapping files/%s %s' %
-                  (basename, f))
-
   modules = len(llc_outputs)
   script.extend(['readonly_file objfile%d %s' % (i, f)
                  for i, f in zip(range(modules), llc_outputs)])
   script.append('rpc RunWithSplit i(%d) ' % modules +
                 ' '.join(['h(objfile%s)' % m for m in range(modules)] +
                          ['h(invalid)' for x in range(modules, 16)]) +
                 ' h(nexefile) *')
   script.append('echo "ld complete"')
   script.append('')
   return '\n'.join(script)
 
-# Given linker arguments (including -L, -l, and filenames),
-# returns the list of files which are pulled by the linker,
-# with real path names set set up the real -> flat name mapping.
-def LinkerFiles(args):
-  ret = []
-  for f in args:
+
+def GetNativeLibsDirname(other_inputs):
+  """Check that native libs have a common directory and return the directory."""
+  dirname = None
+  for f in other_inputs:
     if IsFlag(f):
       continue
     else:
       if not pathtools.exists(f):
         Log.Fatal("Unable to open '%s'", pathtools.touser(f))
-      ret.append(f)
-  return ret
+      if dirname is None:
+        dirname = pathtools.dirname(f)
+      else:
+        if dirname != pathtools.dirname(f):
+          Log.Fatal('Need a common directory for native libs: %s != %s',
+                    dirname, pathtools.dirname(f))
+  if not dirname:
+    Log.Fatal('No native libraries found')
+  return dirname + '/'