Reapply change 9663

build/build_nexe.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.
 
 from optparse import OptionParser
 import os
 import subprocess
 import sys
 
@@ skipping 92 matching lines @@
     if toolname not in ['newlib', 'glibc', 'pnacl']:
       ErrOut('Toolchain of type %s not supported.' % toolname)
 
     self.root_path = options.root
     self.nacl_path = os.path.join(self.root_path, 'native_client')
 
     project_path, project_name = os.path.split(options.name)
     self.outdir = options.objdir
 
     # Set the toolchain directories
+    print 'toolpath=' + options.toolpath
+    print 'toolname=' + self.toolname
     self.toolchain = os.path.join(options.toolpath, self.toolname)
     self.toolbin = os.path.join(self.toolchain, tool_subdir, 'bin')
 
     if self.pnacl:
       self.toollib = os.path.join(self.toolchain, tool_subdir,'lib')
       self.toolinc = os.path.join(self.toolchain, tool_subdir, 'sysroot',
                                   'include')
     else:
       self.toollib = os.path.join(self.toolchain,
                                   tool_subdir,
@@ skipping 76 matching lines @@
                            'WINDOWS' in define or
                            'WINVER' in define)]
     options += ['-D' + define for define in define_list]
     self.compile_options = options + ['-I' + name for name in self.inc_paths]
 
   def BuildLinkOptions(self, options):
     """Generates link options, called once by __init__."""
     options = ArgToList(options)
     if self.toolname in ['glibc', 'newlib'] and self.mainarch == 'x86':
       options += ['-B' + self.toollib]
+    if self.outtype == 'nso':
+      options += ['-Wl,-rpath-link,' + name for name in self.lib_paths]
+      options += ['-shared']
+      options += ['-Wl,-soname,' + os.path.basename(self.name)]
     self.link_options = options + ['-L' + name for name in self.lib_paths]
 
   def BuildArchiveOptions(self):
     """Generates link options, called once by __init__."""
     self.archive_options = []
 
   def Run(self, cmd_line, out):
     """Helper which runs a command line."""
 
     # For POSIX style path on windows for POSIX based toolchain
@@ skipping 126 matching lines @@
       err = self.Run(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
   def Generate(self, srcs):
     """Generate final output file.
 
     Link or Archive the final output file, from the compiled sources.
     """
-    if self.outtype == 'nexe':
+    if self.outtype in ['nexe', 'nso']:
       out = self.Link(srcs)
       if self.strip_debug:
         self.Strip(out)
     elif self.outtype == 'nlib':
       self.Archive(srcs)
 
 
 def Main(argv):
   parser = OptionParser()
   parser.add_option('--empty', dest='empty', default=False,
@@ skipping 34 matching lines @@
                     help='Enable verbosity', action='store_true')
   parser.add_option('-t', '--toolpath', dest='toolpath',
                     help='Set the path for of the toolchains.')
   (options, files) = parser.parse_args(argv[1:])
 
   if not argv:
     parser.print_help()
     return 1
 
   options.verbose = True
+  print ' '.join(argv)
   if options.source_list:
     source_list_handle = open(options.source_list, 'r')
     source_list = source_list_handle.read().splitlines()
     source_list_handle.close()
     files = files + source_list
 
   build = Builder(options)
   objs = []
   for filename in files:
     out = build.Compile(filename)
     if out:
       objs.append(out)
   # Do not link if building an object
   if not options.compile_only:
     build.Generate(objs)
   return 0
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))