Retain the unstripped nexe at a predictable location.

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
 import tempfile
@@ skipping 189 matching lines @@
       return self.GetBinName('g++')
 
   def GetAr(self):
     """Helper which returns ar path."""
     return self.GetBinName('ar')
 
   def GetStrip(self):
     """Helper which returns strip path."""
     return self.GetBinName('strip')
 
+  def GetObjCopy(self):
+    """Helper which returns objcopy path."""
+    return self.GetBinName('objcopy')
+
   def GetPnaclFinalize(self):
     """Helper which returns pnacl-finalize path."""
     assert self.is_pnacl_toolchain
     return self.GetBinName('finalize')
 
   def BuildAssembleOptions(self, options):
     options = ArgToList(options)
     self.assemble_options = options + ['-I' + name for name in self.inc_paths]
 
+  def DebugName(self):
+    return self.name + '.debug'
+
+  def UntaggedName(self):
+    return self.name + '.untagged'
+
+  def LinkOutputName(self):
+    if (self.is_pnacl_toolchain and self.finalize_pexe or
+        self.strip_all or self.strip_debug):
+      return self.DebugName()
+    else:
+      return self.name
+
+  def ArchiveOutputName(self):
+    if self.strip_debug:
+      return self.DebugName()
+    else:
+      return self.name
+
+  def StripOutputName(self):
+    return self.name
+
+  def TranslateOutputName(self):
+    return self.name
+
+  def Soname(self):
+    return self.name
+
   def BuildCompileOptions(self, options, define_list):
     """Generates compile options, called once by __init__."""
     options = ArgToList(options)
     # We want to shared gyp 'defines' with other targets, but not
     # ones that are host system dependent. Filtering them out.
     # This really should be better.
     # See: http://code.google.com/p/nativeclient/issues/detail?id=2936
     define_list = [define for define in define_list
                    if not (define.startswith('NACL_TARGET_ARCH=') or
                            define.startswith('NACL_TARGET_SUBARCH=') or
                            define.startswith('NACL_WINDOWS=') or
                            define.startswith('NACL_OSX=') or
                            define.startswith('NACL_LINUX=') or
                            define == 'COMPONENT_BUILD' or
                            'WIN32' in define or
                            'WINDOWS' in define or
                            'WINVER' in define)]
     define_list.extend(['NACL_WINDOWS=0',
                         'NACL_OSX=0',
                         'NACL_LINUX=0'])
     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.outtype == 'nso':
       options += ['-Wl,-rpath-link,' + name for name in self.lib_paths]
       options += ['-shared']
-      options += ['-Wl,-soname,' + os.path.basename(self.name)]
+      options += ['-Wl,-soname,' + os.path.basename(self.Soname())]
     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 Log(self, msg):
     if self.verbose:
       print str(msg)
 
@@ skipping 164 matching lines @@
     if err:
       self.CleanOutput(outd)
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     elif self.NeedsRebuild(outd, out, src, True):
       ErrOut('\nFailed to compile %s to %s with deps %s and cmdline:\t%s' %
           (src, out, outd, ' '.join(cmd_line)))
     return out
 
   def Link(self, srcs):
     """Link these objects with predetermined options and output name."""
-    out = self.name
+    out = self.LinkOutputName()
     self.Log('\nLink %s' % out)
     bin_name = self.GetCXXCompiler()
     MakeDir(os.path.dirname(out))
     self.CleanOutput(out)
 
     cmd_line = [bin_name, '-o', out, '-Wl,--as-needed']
     if not self.empty:
       cmd_line += srcs
     cmd_line += self.link_options
 
     err = self.RunWithRetry(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
   # For now, only support translating a pexe, and not .o file(s)
   def Translate(self, src):
     """Translate a pexe to a nexe."""
-    out = self.name
+    out = self.TranslateOutputName()
     self.Log('\nTranslate %s' % out)
     bin_name = self.GetBinName('translate')
     cmd_line = [bin_name, '-arch', self.arch, src, '-o', out]
     cmd_line += self.link_options
 
     err = self.RunWithRetry(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
   def Archive(self, srcs):
     """Archive these objects with predetermined options and output name."""
-    out = self.name
+    out = self.ArchiveOutputName()
     self.Log('\nArchive %s' % out)
 
     if '-r' in self.link_options:
       bin_name = self.GetCXXCompiler()
       cmd_line = [bin_name, '-o', out, '-Wl,--as-needed']
       if not self.empty:
         cmd_line += srcs
       cmd_line += self.link_options
     else:
       bin_name = self.GetAr()
       cmd_line = [bin_name, '-rc', out]
       if not self.empty:
         cmd_line += srcs
 
     MakeDir(os.path.dirname(out))
     self.CleanOutput(out)
     err = self.RunWithRetry(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
     return out
 
-  def Strip(self, out):
+  def Strip(self, src):
     """Strip the NEXE"""
-    self.Log('\nStrip %s' % out)
+    self.Log('\nStrip %s' % src)
 
-    tmp = out + '.tmp'
-    self.CleanOutput(tmp)
-    os.rename(out, tmp)
-    bin_name = self.GetStrip()
+    out = self.StripOutputName()
+    pre_debug_tagging = self.UntaggedName()
+    self.CleanOutput(out)
+    self.CleanOutput(pre_debug_tagging)
+
+    # Strip from foo.debug to foo.untagged.
+    strip_name = self.GetStrip()
     strip_option = '--strip-all' if self.strip_all else '--strip-debug'
-    cmd_line = [bin_name, strip_option, tmp, '-o', out]
+    cmd_line = [strip_name, strip_option, src, '-o', pre_debug_tagging]
+    err = self.RunWithRetry(cmd_line, pre_debug_tagging)
+    if err:
+      ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
+
+    # Tag with a debug link to foo.debug copying from foo.untagged to foo.
+    objcopy_name = self.GetObjCopy()
+    cmd_line = [objcopy_name, '--add-gnu-debuglink', src,
+                pre_debug_tagging, out]
     err = self.RunWithRetry(cmd_line, out)
     if err:
       ErrOut('\nFAILED with %d: %s\n\n' % (err, ' '.join(cmd_line)))
+
+    # Drop the untagged intermediate.
+    self.CleanOutput(pre_debug_tagging)
+
     return out
 
-  def Finalize(self, out):
+  def Finalize(self, src):
     """Finalize the PEXE"""
-    self.Log('\nFinalize %s' % out)
+    self.Log('\nFinalize %s' % src)
 
-    tmp = out + '.nonfinal'
-    self.CleanOutput(tmp)
-    os.rename(out, tmp)
+    out = self.StripOutputName()
+    self.CleanOutput(out)
     bin_name = self.GetPnaclFinalize()
-    cmd_line = [bin_name, tmp, '-o', out]
+    cmd_line = [bin_name, src, '-o', out]
     err = self.RunWithRetry(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.
     """
@@ skipping 90 matching lines @@
     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))