Enable win64 stub library generation

tools/generate_stubs/generate_stubs.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.
 
 """Creates windows and posix stub files for a given set of signatures.
 
 For libraries that need to be loaded outside of the standard executable startup
 path mechanism, stub files need to be generated for the wanted functions.  In
 windows, this is done via "def" files and the delay load mechanism.  On a posix
@@ skipping 58 matching lines @@
 # Trailing characters should have a substring matching the form (.*).  That
 # is considered the arguments.
 SIGNATURE_REGEX = re.compile('(?P<return_type>.+?)'
                              '(?P<name>[_a-zA-Z][_a-zA-Z0-9]+)\s*'
                              '\((?P<params>.*?)\)')
 
 # Used for generating C++ identifiers.
 INVALID_C_IDENT_CHARS = re.compile('[^_a-zA-Z0-9]')
 
 # Constants defning the supported file types options.
-FILE_TYPE_WIN = 'windows_lib'
+FILE_TYPE_WIN_X86 = 'windows_lib'
+FILE_TYPE_WIN_X64 = 'windows_lib_x64'
 FILE_TYPE_POSIX_STUB = 'posix_stubs'
 FILE_TYPE_WIN_DEF = 'windows_def'
 
 # Template for generating a stub function definition.  Includes a forward
 # declaration marking the symbol as weak.  This template takes the following
 # named parameters.
 #   return_type: The return type.
 #   name: The name of the function.
 #   params: The parameters to the function.
 #   return_prefix: 'return ' if this function is not void. '' otherwise.
@@ skipping 355 matching lines @@
   """Invoke |args| as command via subprocess.Popen, filtering lines starting
   with |filter|."""
   popen = subprocess.Popen(args, stdout=subprocess.PIPE)
   out, _ = popen.communicate()
   for line in out.splitlines():
     if not filter or not line.startswith(filter):
       write_to.write(line + '\n')
   return popen.returncode
 
 
-def CreateWindowsLib(module_name, signatures, intermediate_dir, outdir_path):
+def CreateWindowsLib(module_name, signatures, intermediate_dir, outdir_path,
+                     machine):
   """Creates a windows library file.
 
   Calling this function will create a lib file in the outdir_path that exports
   the signatures passed into the object.  A temporary def file will be created
   in the intermediate_dir.
 
   Args:
     module_name: The name of the module we are writing a stub for.
     signatures: The list of signature hashes, as produced by ParseSignatures,
                 to create stubs for.
     intermediate_dir: The directory where the generated .def files should go.
     outdir_path: The directory where generated .lib files should go.
+    machine: String holding the machine type, 'X86' or 'X64'.
 
   Raises:
     SubprocessError: If invoking the windows "lib" tool fails, this is raised
                      with the error code.
   """
   def_file_path = os.path.join(intermediate_dir,
                                module_name + '.def')
   lib_file_path = os.path.join(outdir_path,
                                module_name + '.lib')
   outfile = open(def_file_path, 'w')
   try:
     WriteWindowsDefFile(module_name, signatures, outfile)
   finally:
     outfile.close()
 
   # Invoke the "lib" program on Windows to create stub .lib files for the
   # generated definitions.  These .lib files can then be used during
   # delayloading of the dynamic libraries.
-  ret = QuietRun(['lib', '/nologo', '/machine:X86',
+  ret = QuietRun(['lib', '/nologo',
+                  '/machine:' + machine,
                   '/def:' + def_file_path,
                   '/out:' + lib_file_path],
                  filter='   Creating library')
   if ret != 0:
     raise SubprocessError(
         'Failed creating %s for %s' % (lib_file_path, def_file_path),
         ret)
 
 
 class PosixStubWriter(object):
@@ skipping 377 matching lines @@
                     help='Output location.')
   parser.add_option('-i',
                     '--intermediate_dir',
                     dest='intermediate_dir',
                     default=None,
                     help=('Location of intermediate files. Ignored for %s type'
                           % FILE_TYPE_WIN_DEF))
   parser.add_option('-t',
                     '--type',
                     dest='type',
                     default=None,

[DaleCurtis, 2013/02/01 19:07:40]

I think you'll need to keep the old FILE_TYPE_WIN around until you convert all
the GYP's over to use the new syntax; otherwise you've got a chicken and egg
problem.

[wolenetz, 2013/02/01 19:16:21]

The neat bit about this change is that I actually did.  See above, where
FILE_TYPE_WIN_X86 is still "windows_lib" for backwards win32 compatibility.  I
added "windows_lib_x64" in this patch, as "FILE_TYPE_WIN_X64".

-                    help=('Type of file. Valid types are "%s" or "%s" or "%s"' %
-                          (FILE_TYPE_POSIX_STUB, FILE_TYPE_WIN,
-                           FILE_TYPE_WIN_DEF)))
+                    help=('Type of file. Valid types are "%s" or "%s" or "%s" '
+                          'or "%s"' %
+                          (FILE_TYPE_POSIX_STUB, FILE_TYPE_WIN_X86,
+                           FILE_TYPE_WIN_X64, FILE_TYPE_WIN_DEF)))
   parser.add_option('-s',
                     '--stubfile_name',
                     dest='stubfile_name',
                     default=None,
                     help=('Name of posix_stubs output file. Only valid with '
                           '%s type.' % FILE_TYPE_POSIX_STUB))
   parser.add_option('-p',
                     '--path_from_source',
                     dest='path_from_source',
                     default=None,
                     help=('The relative path from the project root that the '
                           'generated file should consider itself part of (eg. '
                           'third_party/ffmpeg).  This is used to generate the '
                           'header guard and namespace for our initializer '
                           'functions and does NOT affect the physical output '
                           'location of the file like -o does.  Ignored for '
-                          ' %s type.' % FILE_TYPE_WIN))
+                          '%s and %s types.' %
+                          (FILE_TYPE_WIN_X86, FILE_TYPE_WIN_X64)))
   parser.add_option('-e',
                     '--extra_stub_header',
                     dest='extra_stub_header',
                     default=None,
                     help=('File to insert after the system includes in the '
                           'generated stub implemenation file. Ignored for '
-                          '%s type.' % FILE_TYPE_WIN))
+                          '%s and %s types.' %
+                          (FILE_TYPE_WIN_X86, FILE_TYPE_WIN_X64)))
   parser.add_option('-m',
                     '--module_name',
                     dest='module_name',
                     default=None,
                     help=('Name of output DLL or LIB for DEF creation using '
                           '%s type.' % FILE_TYPE_WIN_DEF))
 
   return parser
 
 
 def ParseOptions():
   """Parses the options and terminates program if they are not sane.
 
   Returns:
     The pair (optparse.OptionValues, [string]), that is the output of
     a successful call to parser.parse_args().
   """
   parser = CreateOptionParser()
   options, args = parser.parse_args()
 
   if not args:
     parser.error('No inputs specified')
 
   if options.out_dir is None:
     parser.error('Output location not specified')
 
   if (options.type not in
-      [FILE_TYPE_WIN, FILE_TYPE_POSIX_STUB, FILE_TYPE_WIN_DEF]):
+      [FILE_TYPE_WIN_X86, FILE_TYPE_WIN_X64, FILE_TYPE_POSIX_STUB,
+       FILE_TYPE_WIN_DEF]):
     parser.error('Invalid output file type: %s' % options.type)
 
   if options.type == FILE_TYPE_POSIX_STUB:
     if options.stubfile_name is None:
       parser.error('Output file name needed for %s' % FILE_TYPE_POSIX_STUB)
     if options.path_from_source is None:
       parser.error('Path from source needed for %s' % FILE_TYPE_POSIX_STUB)
 
   if options.type == FILE_TYPE_WIN_DEF:
     if options.module_name is None:
@@ skipping 31 matching lines @@
   intermediate_dir = os.path.normpath(options.intermediate_dir)
   if intermediate_dir is None:
     intermediate_dir = out_dir
 
   EnsureDirExists(out_dir)
   EnsureDirExists(intermediate_dir)
 
   return out_dir, intermediate_dir
 
 
-def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir):
+def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir, machine):
   """For each signature file, create a windows lib.
 
   Args:
     sig_files: Array of strings with the paths to each signature file.
     out_dir: String holding path to directory where the generated libs go.
     intermediate_dir: String holding path to directory generated intermdiate
                       artifacts.
+    machine: String holding the machine type, 'X86' or 'X64'.
   """
   for input_path in sig_files:
     infile = open(input_path, 'r')
     try:
       signatures = ParseSignatures(infile)
       module_name = ExtractModuleName(os.path.basename(input_path))
-      CreateWindowsLib(module_name, signatures, intermediate_dir, out_dir)
+      CreateWindowsLib(module_name, signatures, intermediate_dir, out_dir,
+                       machine)
     finally:
       infile.close()
 
 
 def CreateWindowsDefForSigFiles(sig_files, out_dir, module_name):
   """For all signature files, create a single windows def file.
 
   Args:
     sig_files: Array of strings with the paths to each signature file.
     out_dir: String holding path to directory where the generated def goes.
@@ skipping 82 matching lines @@
     PosixStubWriter.WriteHeaderContents(module_names, namespace,
                                         header_guard, header_file)
   finally:
     header_file.close()
 
 
 def main():
   options, args = ParseOptions()
   out_dir, intermediate_dir = CreateOutputDirectories(options)
 
-  if options.type == FILE_TYPE_WIN:
-    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir)
+  if options.type == FILE_TYPE_WIN_X86:
+    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X86')
+  elif options.type == FILE_TYPE_WIN_X64:
+    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X64')
   elif options.type == FILE_TYPE_POSIX_STUB:
     CreatePosixStubsForSigFiles(args, options.stubfile_name, out_dir,
                                 intermediate_dir, options.path_from_source,
                                 options.extra_stub_header)
   elif options.type == FILE_TYPE_WIN_DEF:
     CreateWindowsDefForSigFiles(args, out_dir, options.module_name)
 
 
 if __name__ == '__main__':
   main()