| #!/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. |
| |
| """Tool for automatically creating .nmf files from .nexe/.pexe/.bc executables. |
| |
| As well as creating the nmf file this tool can also find and stage |
| any shared libraries dependencies that the executables might have. |
| """ |
| |
| import argparse |
| import errno |
| import json |
| import os |
| import posixpath |
| import shutil |
| import sys |
| |
| import getos |
| |
| if sys.version_info < (2, 7, 0): |
| sys.stderr.write("python 2.7 or later is required run this script\n") |
| sys.exit(1) |
| |
| SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) |
| LIB_DIR = os.path.join(SCRIPT_DIR, 'lib') |
| |
| sys.path.append(LIB_DIR) |
| |
| import elf |
| import get_shared_deps |
| import quote |
| |
| |
| ARCH_LOCATION = { |
| 'x86-32': 'lib32', |
| 'x86-64': 'lib64', |
| 'arm': 'libarm', |
| } |
| |
| |
| # These constants are used within nmf files. |
| 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 |
| PNACL_OPTLEVEL_KEY = 'optlevel' # key for PNaCl optimization level |
| PORTABLE_KEY = 'portable' # key for portable section of manifest |
| TRANSLATE_KEY = 'pnacl-translate' # key for translatable objects |
| TRANSLATE_DEBUG_KEY = 'pnacl-debug' # key for translatable debug objects |
| |
| |
| def DebugPrint(message): |
| if DebugPrint.debug_mode: |
| sys.stderr.write('%s\n' % message) |
| |
| |
| DebugPrint.debug_mode = False # Set to True to enable extra debug prints |
| |
| |
| def SplitPath(path): |
| """Returns all components of a path as a list. |
| |
| e.g. |
| 'foo/bar/baz.blah' => ['foo', 'bar', 'baz.blah'] |
| """ |
| result = [] |
| while path: |
| path, part = os.path.split(path) |
| result.append(part) |
| return result[::-1] # Reverse. |
| |
| |
| def MakePosixPath(path): |
| """Converts from the native format to posixpath format. |
| |
| e.g. on Windows, "foo\\bar\\baz.blah" => "foo/bar/baz.blah" |
| on Mac/Linux this is a no-op. |
| """ |
| if os.path == posixpath: |
| return path |
| return posixpath.join(*SplitPath(path)) |
| |
| |
| def PosixRelPath(path, start): |
| """Takes two paths in native format, and produces a relative path in posix |
| format. |
| |
| e.g. |
| For Windows: "foo\\bar\\baz.blah", "foo" => "bar/baz.blah" |
| For Mac/Linux: "foo/bar/baz.blah", "foo" => "bar/baz.blah" |
| |
| NOTE: This function uses os.path.realpath to create a canonical path for |
| |path| and |start|. |
| """ |
| real_path = os.path.realpath(path) |
| real_start = os.path.realpath(start) |
| return MakePosixPath(os.path.relpath(real_path, real_start)) |
| |
| |
| def DirectoryTreeContainsFile(dirname, filename): |
| """Returns True if a file is in a directory, or any of that directory's |
| subdirectories recursively. |
| |
| e.g. |
| DirectoryTreeContainsFile("foo", "foo/quux.txt") => True |
| DirectoryTreeContainsFile("foo", "foo/bar/baz/blah.txt") => True |
| DirectoryTreeContainsFile("foo", "bar/blah.txt") => False |
| """ |
| real_dirname = os.path.realpath(dirname) |
| real_filename = os.path.realpath(filename) |
| return real_filename.startswith(real_dirname) |
| |
| |
| def MakeDir(dirname): |
| """Just like os.makedirs but doesn't generate errors when dirname |
| already exists. |
| """ |
| if os.path.isdir(dirname): |
| return |
| |
| Trace("mkdir: %s" % dirname) |
| try: |
| os.makedirs(dirname) |
| except OSError as exception_info: |
| if exception_info.errno != errno.EEXIST: |
| raise |
| |
| |
| def ParseElfHeader(path): |
| """Wrap elf.ParseElfHeader to return raise this module's Error on failure.""" |
| try: |
| return elf.ParseElfHeader(path) |
| except elf.Error as e: |
| raise Error(str(e)) |
| |
| |
| class Error(Exception): |
| """Local Error class for this file.""" |
| pass |
| |
| |
| def IsLoader(filename): |
| return (filename.endswith(get_shared_deps.LOADER_X86) or |
| filename.endswith(get_shared_deps.LOADER_ARM)) |
| |
| |
| class ArchFile(object): |
| """Simple structure containing information about an architecture-specific |
| file. |
| |
| Attributes: |
| name: Name of this file |
| path: Full path to this file on the build system |
| arch: Architecture of this file (e.g., x86-32) |
| url: Relative path to file in the staged web directory. |
| Used for specifying the "url" attribute in the nmf file.""" |
| |
| def __init__(self, name, path, url=None, arch=None): |
| self.name = name |
| self.path = path |
| self.url = url |
| self.arch = arch |
| if arch is None: |
| self.arch = ParseElfHeader(path)[0] |
| |
| def __repr__(self): |
| return '<ArchFile %s>' % self.path |
| |
| def __str__(self): |
| """Return the file path when invoked with the str() function""" |
| return self.path |
| |
| |
| class NmfUtils(object): |
| """Helper class for creating and managing nmf files""" |
| |
| def __init__(self, main_files=None, objdump=None, |
| lib_path=None, extra_files=None, lib_prefix=None, |
| nexe_prefix=None, no_arch_prefix=None, remap=None, |
| pnacl_optlevel=None, pnacl_debug_optlevel=None, |
| nmf_root=None): |
| """Constructor |
| |
| Args: |
| main_files: List of main entry program files. These will be named |
| files->main.nexe for dynamic nexes, and program for static nexes |
| objdump: path to x86_64-nacl-objdump tool (or Linux equivalent) |
| lib_path: List of paths to library directories |
| extra_files: List of extra files to include in the nmf |
| lib_prefix: A path prefix to prepend to the library paths, both for |
| staging the libraries and for inclusion into the nmf file. |
| Example: '../lib_dir' |
| nexe_prefix: Like lib_prefix, but is prepended to the nexes instead. |
| no_arch_prefix: Don't prefix shared libraries by lib32/lib64. |
| remap: Remaps the library name in the manifest. |
| pnacl_optlevel: Optimization level for PNaCl translation. |
| pnacl_debug_optlevel: Optimization level for debug PNaCl translation. |
| nmf_root: Directory of the NMF. All urls are relative to this directory. |
| """ |
| assert len(main_files) > 0 |
| self.objdump = objdump |
| self.main_files = main_files |
| self.extra_files = extra_files or [] |
| self.lib_path = lib_path or [] |
| self.manifest = None |
| self.needed = None |
| self.lib_prefix = lib_prefix or '' |
| self.nexe_prefix = nexe_prefix or '' |
| self.no_arch_prefix = no_arch_prefix |
| self.remap = remap or {} |
| self.pnacl = main_files[0].endswith(('.pexe', '.bc')) |
| self.pnacl_optlevel = pnacl_optlevel |
| self.pnacl_debug_optlevel = pnacl_debug_optlevel |
| if nmf_root is not None: |
| self.nmf_root = nmf_root |
| else: |
| # To match old behavior, if there is no nmf_root, use the directory of |
| # the first nexe found in main_files. |
| self.nmf_root = os.path.dirname(main_files[0]) |
| |
| for filename in self.main_files: |
| if not os.path.exists(filename): |
| raise Error('Input file not found: %s' % filename) |
| if not os.path.isfile(filename): |
| raise Error('Input is not a file: %s' % filename) |
| |
| def GetNeeded(self): |
| """Collect the list of dependencies for the main_files |
| |
| Returns: |
| 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 self.needed: |
| return self.needed |
| |
| DebugPrint('GetNeeded(%s)' % self.main_files) |
| |
| if not self.objdump: |
| self.objdump = FindObjdumpExecutable() |
| |
| try: |
| all_files = get_shared_deps.GetNeeded(self.main_files, self.objdump, |
| self.lib_path) |
| except get_shared_deps.NoObjdumpError: |
| raise Error('No objdump executable found (see --help for more info)') |
| except get_shared_deps.Error as e: |
| raise Error(str(e)) |
| |
| self.needed = {} |
| |
| # all_files is a dictionary mapping filename to architecture. self.needed |
| # should be a dictionary of filename to ArchFile. |
| for filename, arch in all_files.items(): |
| name = os.path.basename(filename) |
| self.needed[filename] = ArchFile(name=name, path=filename, arch=arch) |
| |
| self._SetArchFileUrls() |
| |
| return self.needed |
| |
| def _SetArchFileUrls(self): |
| """Fill in the url member of all ArchFiles in self.needed. |
| |
| All urls are relative to the nmf_root. In addition, architecture-specific |
| files are relative to the .nexe with the matching architecture. This is |
| useful when making a multi-platform packaged app, so each architecture's |
| files are in a different directory. |
| """ |
| # self.GetNeeded() should have already been called. |
| assert self.needed is not None |
| |
| main_nexes = [f for f in self.main_files if f.endswith('.nexe')] |
| |
| # map from each arch to its corresponding main nexe. |
| arch_to_main_dir = {} |
| for main_file in main_nexes: |
| arch, _ = ParseElfHeader(main_file) |
| main_dir = os.path.dirname(main_file) |
| main_dir = PosixRelPath(main_dir, self.nmf_root) |
| if main_dir == '.': |
| main_dir = '' |
| arch_to_main_dir[arch] = main_dir |
| |
| for arch_file in self.needed.values(): |
| prefix = '' |
| if DirectoryTreeContainsFile(self.nmf_root, arch_file.path): |
| # This file is already in the nmf_root tree, so it does not need to be |
| # staged. Just make the URL relative to the .nmf. |
| url = PosixRelPath(arch_file.path, self.nmf_root) |
| else: |
| # This file is outside of the nmf_root subtree, so it needs to be |
| # staged. Its path should be relative to the main .nexe with the same |
| # architecture. |
| prefix = arch_to_main_dir[arch_file.arch] |
| url = os.path.basename(arch_file.path) |
| |
| if arch_file.name.endswith('.nexe') and not IsLoader(arch_file.name): |
| prefix = posixpath.join(prefix, self.nexe_prefix) |
| elif self.no_arch_prefix: |
| prefix = posixpath.join(prefix, self.lib_prefix) |
| else: |
| prefix = posixpath.join( |
| prefix, self.lib_prefix, ARCH_LOCATION[arch_file.arch]) |
| arch_file.url = posixpath.join(prefix, url) |
| |
| def StageDependencies(self, destination_dir): |
| """Copies over the dependencies into a given destination directory |
| |
| Each library will be put into a subdirectory that corresponds to the arch. |
| |
| Args: |
| destination_dir: The destination directory for staging the dependencies |
| """ |
| assert self.needed is not None |
| for arch_file in self.needed.values(): |
| source = arch_file.path |
| destination = os.path.join(destination_dir, arch_file.url) |
| |
| if (os.path.normcase(os.path.realpath(source)) == |
| os.path.normcase(os.path.realpath(destination))): |
| continue |
| |
| # make sure target dir exists |
| MakeDir(os.path.dirname(destination)) |
| |
| Trace('copy: %s -> %s' % (source, destination)) |
| shutil.copy2(source, destination) |
| |
| def _GeneratePNaClManifest(self): |
| manifest = {} |
| manifest[PROGRAM_KEY] = {} |
| manifest[PROGRAM_KEY][PORTABLE_KEY] = {} |
| portable = manifest[PROGRAM_KEY][PORTABLE_KEY] |
| for filename in self.main_files: |
| translate_dict = { |
| 'url': os.path.basename(filename), |
| } |
| if filename.endswith('.pexe'): |
| if self.pnacl_optlevel is not None: |
| translate_dict[PNACL_OPTLEVEL_KEY] = self.pnacl_optlevel |
| if TRANSLATE_KEY in portable: |
| raise Error('Multiple .pexe files') |
| portable[TRANSLATE_KEY] = translate_dict |
| elif filename.endswith('.bc'): |
| if self.pnacl_debug_optlevel is not None: |
| translate_dict[PNACL_OPTLEVEL_KEY] = self.pnacl_debug_optlevel |
| if TRANSLATE_DEBUG_KEY in portable: |
| raise Error('Multiple .bc files') |
| portable[TRANSLATE_DEBUG_KEY] = translate_dict |
| else: |
| raise Error('Unexpected executable type: %s' % filename) |
| self.manifest = manifest |
| |
| def _GenerateManifest(self): |
| """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 the original name so that the |
| loader can find it. |
| """ |
| manifest = { FILES_KEY: {}, PROGRAM_KEY: {} } |
| |
| needed = self.GetNeeded() |
| |
| extra_files_kv = [(key, ArchFile(name=key, |
| arch=arch, |
| path=url, |
| url=url)) |
| for key, arch, url in self.extra_files] |
| |
| manifest_items = list(needed.items()) + extra_files_kv |
| |
| # Add dynamic loader to the program section. |
| for need, archinfo in manifest_items: |
| if IsLoader(need): |
| urlinfo = { URL_KEY: archinfo.url } |
| manifest[PROGRAM_KEY][archinfo.arch] = urlinfo |
| |
| for need, archinfo in manifest_items: |
| urlinfo = { URL_KEY: archinfo.url } |
| name = archinfo.name |
| arch = archinfo.arch |
| |
| if IsLoader(need): |
| continue |
| |
| if need in self.main_files: |
| if need.endswith(".nexe"): |
| # Place it under program if we aren't using the runnable-ld.so. |
| program = manifest[PROGRAM_KEY] |
| if arch not in program: |
| program[arch] = urlinfo |
| continue |
| # Otherwise, treat it like another another file named main.nexe. |
| name = MAIN_NEXE |
| |
| name = self.remap.get(name, name) |
| fileinfo = manifest[FILES_KEY].get(name, {}) |
| fileinfo[arch] = urlinfo |
| manifest[FILES_KEY][name] = fileinfo |
| self.manifest = manifest |
| |
| def GetManifest(self): |
| """Returns a JSON-formatted dict containing the NaCl dependencies""" |
| if self.manifest is None: |
| if self.pnacl: |
| self._GeneratePNaClManifest() |
| else: |
| self._GenerateManifest() |
| return self.manifest |
| |
| def GetJson(self): |
| """Returns the Manifest as a JSON-formatted string""" |
| pretty_string = json.dumps(self.GetManifest(), indent=2) |
| # json.dumps sometimes returns trailing whitespace and does not put |
| # a newline at the end. This code fixes these problems. |
| pretty_lines = pretty_string.split('\n') |
| return '\n'.join([line.rstrip() for line in pretty_lines]) + '\n' |
| |
| |
| def Trace(msg): |
| if Trace.verbose: |
| sys.stderr.write(str(msg) + '\n') |
| |
| Trace.verbose = False |
| |
| |
| def ParseExtraFiles(encoded_list, err): |
| """Parse the extra-files list and return a canonicalized list of |
| [key, arch, url] triples. The |encoded_list| should be a list of |
| strings of the form 'key:url' or 'key:arch:url', where an omitted |
| 'arch' is taken to mean 'portable'. |
| |
| All entries in |encoded_list| are checked for syntax errors before |
| returning. Error messages are written to |err| (typically |
| sys.stderr) so that the user has actionable feedback for fixing all |
| errors, rather than one at a time. If there are any errors, None is |
| returned instead of a list, since an empty list is a valid return |
| value. |
| """ |
| seen_error = False |
| canonicalized = [] |
| for ix in range(len(encoded_list)): |
| kv = encoded_list[ix] |
| unquoted = quote.unquote(kv, ':') |
| if len(unquoted) == 3: |
| if unquoted[1] != ':': |
| err.write('Syntax error for key:value tuple ' + |
| 'for --extra-files argument: ' + kv + '\n') |
| seen_error = True |
| else: |
| canonicalized.append([unquoted[0], 'portable', unquoted[2]]) |
| elif len(unquoted) == 5: |
| if unquoted[1] != ':' or unquoted[3] != ':': |
| err.write('Syntax error for key:arch:url tuple ' + |
| 'for --extra-files argument: ' + |
| kv + '\n') |
| seen_error = True |
| else: |
| canonicalized.append([unquoted[0], unquoted[2], unquoted[4]]) |
| else: |
| err.write('Bad key:arch:url tuple for --extra-files: ' + kv + '\n') |
| if seen_error: |
| return None |
| return canonicalized |
| |
| |
| def GetSDKRoot(): |
| """Returns the root directory of the NaCl SDK. |
| """ |
| # This script should be installed in NACL_SDK_ROOT/tools. Assert that |
| # the 'toolchain' folder exists within this directory in case, for |
| # example, this script is moved to a different location. |
| # During the Chrome build this script is sometimes run outside of |
| # of an SDK but in these cases it should always be run with --objdump= |
| # and --no-default-libpath which avoids the need to call this function. |
| sdk_root = os.path.dirname(SCRIPT_DIR) |
| assert(os.path.exists(os.path.join(sdk_root, 'toolchain'))) |
| return sdk_root |
| |
| |
| def FindObjdumpExecutable(): |
| """Derive path to objdump executable to use for determining shared |
| object dependencies. |
| """ |
| osname = getos.GetPlatform() |
| toolchain = os.path.join(GetSDKRoot(), 'toolchain', '%s_x86_glibc' % osname) |
| objdump = os.path.join(toolchain, 'bin', 'x86_64-nacl-objdump') |
| if osname == 'win': |
| objdump += '.exe' |
| |
| if not os.path.exists(objdump): |
| sys.stderr.write('WARNING: failed to find objdump in default ' |
| 'location: %s' % objdump) |
| return None |
| |
| return objdump |
| |
| |
| def GetDefaultLibPath(config): |
| """Derive default library path. |
| |
| This path is used when searching for shared objects. This currently includes |
| the toolchain library folders and the top level SDK lib folder. |
| """ |
| sdk_root = GetSDKRoot() |
| |
| osname = getos.GetPlatform() |
| libpath = [ |
| # Core toolchain libraries |
| 'toolchain/%s_x86_glibc/x86_64-nacl/lib' % osname, |
| 'toolchain/%s_x86_glibc/x86_64-nacl/lib32' % osname, |
| 'toolchain/%s_arm_glibc/arm-nacl/lib' % osname, |
| # user installed libraries (used by webports) |
| 'toolchain/%s_x86_glibc/x86_64-nacl/usr/lib' % osname, |
| 'toolchain/%s_x86_glibc/i686-nacl/usr/lib' % osname, |
| 'toolchain/%s_arm_glibc/arm-nacl/usr/lib' % osname, |
| # SDK bundle libraries |
| 'lib/glibc_x86_32/%s' % config, |
| 'lib/glibc_x86_64/%s' % config, |
| 'lib/glibc_arm/%s' % config, |
| ] |
| |
| # In some cases (e.g. ASAN, TSAN, STANDALONE) the name of the configuration |
| # can be different to simply Debug or Release. For example 'msan_Release'. |
| # In this case we search for libraries first in this directory and then |
| # fall back to 'Release'. |
| if config not in ['Debug', 'Release']: |
| config_fallback = 'Release' |
| if 'Debug' in config: |
| config_fallback = 'Debug' |
| |
| libpath += [ |
| 'lib/glibc_x86_32/%s' % config_fallback, |
| 'lib/glibc_x86_64/%s' % config_fallback, |
| 'lib/glibc_arm/%s' % config_fallback, |
| 'ports/lib/glibc_x86_32/%s' % config_fallback, |
| 'ports/lib/glibc_x86_64/%s' % config_fallback, |
| 'ports/lib/glibc_arm/%s' % config_fallback, |
| ] |
| |
| libpath = [os.path.normpath(p) for p in libpath] |
| libpath = [os.path.join(sdk_root, p) for p in libpath] |
| libpath.append(os.path.join(sdk_root, 'tools')) |
| return libpath |
| |
| |
| def main(args): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('-o', '--output', dest='output', |
| help='Write manifest file to FILE (default is stdout)', |
| metavar='FILE') |
| parser.add_argument('-D', '--objdump', dest='objdump', |
| help='Override the default "objdump" tool used to find ' |
| 'shared object dependencies', |
| metavar='TOOL') |
| parser.add_argument('--no-default-libpath', action='store_true', |
| help="Don't include the SDK default library paths") |
| parser.add_argument('--debug-libs', action='store_true', |
| help='Legacy option, do not use') |
| parser.add_argument('--config', default='Release', |
| help='Use a particular library configuration (normally ' |
| 'Debug or Release)') |
| parser.add_argument('-L', '--library-path', dest='lib_path', |
| action='append', default=[], |
| help='Add DIRECTORY to library search path', |
| metavar='DIRECTORY') |
| parser.add_argument('-P', '--path-prefix', dest='path_prefix', default='', |
| help='Deprecated. An alias for --lib-prefix.', |
| metavar='DIRECTORY') |
| parser.add_argument('-p', '--lib-prefix', dest='lib_prefix', default='', |
| help='A path to prepend to shared libraries in the .nmf', |
| metavar='DIRECTORY') |
| parser.add_argument('-N', '--nexe-prefix', dest='nexe_prefix', default='', |
| help='A path to prepend to nexes in the .nmf', |
| metavar='DIRECTORY') |
| parser.add_argument('-s', '--stage-dependencies', dest='stage_dependencies', |
| help='Destination directory for staging libraries', |
| metavar='DIRECTORY') |
| parser.add_argument('--no-arch-prefix', action='store_true', |
| help='Don\'t put shared libraries in the lib32/lib64 ' |
| 'directories. Instead, they will be put in the same ' |
| 'directory as the .nexe that matches its architecture.') |
| parser.add_argument('-t', '--toolchain', help='Legacy option, do not use') |
| parser.add_argument('-n', '--name', dest='name', |
| help='Rename FOO as BAR', |
| action='append', default=[], metavar='FOO,BAR') |
| parser.add_argument('-x', '--extra-files', |
| help='Add extra key:file tuple to the "files"' |
| ' section of the .nmf', |
| action='append', default=[], metavar='FILE') |
| parser.add_argument('-O', '--pnacl-optlevel', |
| help='Set the optimization level to N in PNaCl manifests', |
| metavar='N') |
| parser.add_argument('--pnacl-debug-optlevel', |
| help='Set the optimization level to N for debugging ' |
| 'sections in PNaCl manifests', |
| metavar='N') |
| parser.add_argument('-v', '--verbose', |
| help='Verbose output', action='store_true') |
| parser.add_argument('-d', '--debug-mode', |
| help='Debug mode', action='store_true') |
| parser.add_argument('executables', metavar='EXECUTABLE', nargs='+') |
| |
| # To enable bash completion for this command first install optcomplete |
| # and then add this line to your .bashrc: |
| # complete -F _optcomplete create_nmf.py |
| try: |
| import optcomplete |
| optcomplete.autocomplete(parser) |
| except ImportError: |
| pass |
| |
| options = parser.parse_args(args) |
| if options.verbose: |
| Trace.verbose = True |
| if options.debug_mode: |
| DebugPrint.debug_mode = True |
| |
| if options.toolchain is not None: |
| sys.stderr.write('warning: option -t/--toolchain is deprecated.\n') |
| if options.debug_libs: |
| sys.stderr.write('warning: --debug-libs is deprecated (use --config).\n') |
| # Implement legacy behavior |
| options.config = 'Debug' |
| |
| canonicalized = ParseExtraFiles(options.extra_files, sys.stderr) |
| if canonicalized is None: |
| parser.error('Bad --extra-files (-x) argument syntax') |
| |
| remap = {} |
| for ren in options.name: |
| parts = ren.split(',') |
| if len(parts) != 2: |
| parser.error('Expecting --name=<orig_arch.so>,<new_name.so>') |
| remap[parts[0]] = parts[1] |
| |
| if options.path_prefix: |
| options.lib_prefix = options.path_prefix |
| |
| for libpath in options.lib_path: |
| if not os.path.exists(libpath): |
| sys.stderr.write('Specified library path does not exist: %s\n' % libpath) |
| elif not os.path.isdir(libpath): |
| sys.stderr.write('Specified library is not a directory: %s\n' % libpath) |
| |
| if not options.no_default_libpath: |
| # Add default libraries paths to the end of the search path. |
| options.lib_path += GetDefaultLibPath(options.config) |
| for path in options.lib_path: |
| Trace('libpath: %s' % path) |
| |
| pnacl_optlevel = None |
| if options.pnacl_optlevel is not None: |
| pnacl_optlevel = int(options.pnacl_optlevel) |
| if pnacl_optlevel < 0 or pnacl_optlevel > 3: |
| sys.stderr.write( |
| 'warning: PNaCl optlevel %d is unsupported (< 0 or > 3)\n' % |
| pnacl_optlevel) |
| if options.pnacl_debug_optlevel is not None: |
| pnacl_debug_optlevel = int(options.pnacl_debug_optlevel) |
| else: |
| pnacl_debug_optlevel = pnacl_optlevel |
| |
| nmf_root = None |
| if options.output: |
| nmf_root = os.path.dirname(options.output) |
| |
| nmf = NmfUtils(objdump=options.objdump, |
| main_files=options.executables, |
| lib_path=options.lib_path, |
| extra_files=canonicalized, |
| lib_prefix=options.lib_prefix, |
| nexe_prefix=options.nexe_prefix, |
| no_arch_prefix=options.no_arch_prefix, |
| remap=remap, |
| pnacl_optlevel=pnacl_optlevel, |
| pnacl_debug_optlevel=pnacl_debug_optlevel, |
| nmf_root=nmf_root) |
| |
| 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 and not nmf.pnacl: |
| Trace('Staging dependencies...') |
| nmf.StageDependencies(options.stage_dependencies) |
| |
| return 0 |
| |
| |
| if __name__ == '__main__': |
| try: |
| rtn = main(sys.argv[1:]) |
| except Error as e: |
| sys.stderr.write('%s: %s\n' % (os.path.basename(__file__), e)) |
| rtn = 1 |
| except KeyboardInterrupt: |
| sys.stderr.write('%s: interrupted\n' % os.path.basename(__file__)) |
| rtn = 1 |
| sys.exit(rtn) |
