From 2ac1e7ca438583c681cbb686122f3ec69fa1d5ff Mon Sep 17 00:00:00 2001 From: "hclam@chromium.org" Date: Tue, 2 Mar 2010 20:50:56 +0000 Subject: Generate stubs for OpenMAX IL Generate stubs for OpenMAX IL so we don't need a real OpenMAX library for building. The actual library is loaded during runtime. TEST=Build is green TEST=Running omx_test works on hardware with OpenMAX support Review URL: http://codereview.chromium.org/661135 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@40418 0039d316-1c4b-4281-b951-d872f2087c98 --- chrome/renderer/render_process.cc | 9 +- media/base/media.h | 8 +- media/base/media_posix.cc | 33 +- media/base/media_win.cc | 5 + media/tools/omx_test/omx_test.cc | 6 + media/tools/player_x11/player_x11.cc | 8 + third_party/ffmpeg/ffmpeg.gyp | 2 +- third_party/ffmpeg/generate_stubs.py | 968 ------------------------ third_party/ffmpeg/generate_stubs_unittest.py | 283 ------- third_party/openmax/il.sigs | 11 + third_party/openmax/il_stub_headers.fragment | 8 + third_party/openmax/openmax.gyp | 78 +- tools/generate_stubs/generate_stubs.py | 968 ++++++++++++++++++++++++ tools/generate_stubs/generate_stubs_unittest.py | 283 +++++++ 14 files changed, 1393 insertions(+), 1277 deletions(-) delete mode 100755 third_party/ffmpeg/generate_stubs.py delete mode 100755 third_party/ffmpeg/generate_stubs_unittest.py create mode 100644 third_party/openmax/il.sigs create mode 100644 third_party/openmax/il_stub_headers.fragment create mode 100755 tools/generate_stubs/generate_stubs.py create mode 100755 tools/generate_stubs/generate_stubs_unittest.py diff --git a/chrome/renderer/render_process.cc b/chrome/renderer/render_process.cc index 5a5bfe7..f5d72c8 100644 --- a/chrome/renderer/render_process.cc +++ b/chrome/renderer/render_process.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -31,6 +31,7 @@ #include "ipc/ipc_channel.h" #include "ipc/ipc_message_utils.h" #include "media/base/media.h" +#include "media/base/media_switches.h" #include "native_client/src/trusted/plugin/nacl_entry_points.h" #include "webkit/glue/webkit_glue.h" @@ -105,6 +106,12 @@ RenderProcess::RenderProcess() initialized_media_library_ = PathService::Get(base::DIR_MODULE, &module_path) && media::InitializeMediaLibrary(module_path); + + // TODO(hclam): Add more checks here. Currently this is not used. + if (CommandLine::ForCurrentProcess()->HasSwitch( + switches::kEnableOpenMax)) { + media::InitializeOpenMaxLibrary(module_path); + } #endif } diff --git a/media/base/media.h b/media/base/media.h index 171d4e8..3d1a83a 100644 --- a/media/base/media.h +++ b/media/base/media.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -20,7 +20,11 @@ namespace media { // Returns true if everything was successfully initialized, false otherwise. bool InitializeMediaLibrary(const FilePath& module_dir); +// Attempts to initialize OpenMAX library. +// +// Returns true if OpenMAX was successfully initialized and loaded. +bool InitializeOpenMaxLibrary(const FilePath& module_dir); + } // namespace media #endif // MEDIA_BASE_MEDIA_H_ - diff --git a/media/base/media_posix.cc b/media/base/media_posix.cc index 9b1035c..210bea3 100644 --- a/media/base/media_posix.cc +++ b/media/base/media_posix.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2010 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. @@ -12,6 +12,10 @@ #include "base/logging.h" #include "base/path_service.h" #include "third_party/ffmpeg/ffmpeg_stubs.h" +#if defined(OS_LINUX) +// OpenMAX IL stub is generated only on Linux. +#include "third_party/openmax/il_stubs.h" +#endif namespace tp_ffmpeg = third_party_ffmpeg; @@ -29,6 +33,7 @@ const FilePath::CharType sumo_name[] = FILE_PATH_LITERAL("libffmpegsumo.so"); #else #error "Do not know how to construct DSO name for this OS." #endif +const FilePath::CharType openmax_name[] = FILE_PATH_LITERAL("libOmxCore.so"); // Retrieves the DSOName for the given key. std::string GetDSOName(tp_ffmpeg::StubModules stub_key) { @@ -68,4 +73,30 @@ bool InitializeMediaLibrary(const FilePath& module_dir) { return tp_ffmpeg::InitializeStubs(paths); } +#if defined(OS_LINUX) +namespace tp_openmax = third_party_openmax; +bool InitializeOpenMaxLibrary(const FilePath& module_dir) { + // TODO(ajwong): We need error resolution. + tp_openmax::StubPathMap paths; + for (int i = 0; i < static_cast(tp_openmax::kNumStubModules); ++i) { + tp_openmax::StubModules module = static_cast(i); + + // Add the OpenMAX library first so it takes precedence. + paths[module].push_back(module_dir.Append(openmax_name).value()); + } + + bool result = tp_openmax::InitializeStubs(paths); + if (!result) { + LOG(FATAL) << "Cannot load " << openmax_name << "." + << " Make sure it exists for OpenMAX."; + } + return result; +} +#else +bool InitializeOpenMaxLibrary(const FilePath& module_dir) { + NOTIMPLEMENTED() << "OpenMAX is only used in Linux."; + return false; +} +#endif + } // namespace media diff --git a/media/base/media_win.cc b/media/base/media_win.cc index 975a301..e4d67f5 100644 --- a/media/base/media_win.cc +++ b/media/base/media_win.cc @@ -96,4 +96,9 @@ bool InitializeMediaLibrary(const FilePath& base_path) { return false; } +bool InitializeOpenMaxLibrary(const FilePath& module_dir) { + NOTIMPLEMENTED() << "OpenMAX is not used in Windows."; + return false; +} + } // namespace media diff --git a/media/tools/omx_test/omx_test.cc b/media/tools/omx_test/omx_test.cc index 428bacc..e90f150 100644 --- a/media/tools/omx_test/omx_test.cc +++ b/media/tools/omx_test/omx_test.cc @@ -320,6 +320,12 @@ int main(int argc, char** argv) { loop_count = 1; DCHECK_GE(loop_count, 1); + // Initialize OpenMAX. + if (!media::InitializeOpenMaxLibrary(FilePath())) { + LOG(ERROR) << "Unable to initialize OpenMAX library."; + return false; + } + // If FFmpeg should be used for demuxing load the library here and do // the initialization. if (use_ffmpeg && !InitFFmpeg()) { diff --git a/media/tools/player_x11/player_x11.cc b/media/tools/player_x11/player_x11.cc index 41207fd..24ba556 100644 --- a/media/tools/player_x11/player_x11.cc +++ b/media/tools/player_x11/player_x11.cc @@ -64,6 +64,14 @@ bool InitX11() { bool InitPipeline(MessageLoop* message_loop, const char* filename, bool enable_audio, scoped_refptr* pipeline) { + // Initialize OpenMAX. + if (CommandLine::ForCurrentProcess()->HasSwitch( + switches::kEnableOpenMax) && + !media::InitializeOpenMaxLibrary(FilePath())) { + std::cout << "Unable to initialize OpenMAX library."<< std::endl; + return false; + } + // Load media libraries. if (!media::InitializeMediaLibrary(FilePath())) { std::cout << "Unable to initialize the media library." << std::endl; diff --git a/third_party/ffmpeg/ffmpeg.gyp b/third_party/ffmpeg/ffmpeg.gyp index 1886d63..b093a75 100755 --- a/third_party/ffmpeg/ffmpeg.gyp +++ b/third_party/ffmpeg/ffmpeg.gyp @@ -592,7 +592,7 @@ 'targets': [ { 'variables': { - 'generate_stubs_script': 'generate_stubs.py', + 'generate_stubs_script': '../../tools/generate_stubs/generate_stubs.py', 'sig_files': [ # Note that these must be listed in dependency order. # (i.e. if A depends on B, then B must be listed before A.) diff --git a/third_party/ffmpeg/generate_stubs.py b/third_party/ffmpeg/generate_stubs.py deleted file mode 100755 index e1ba671..0000000 --- a/third_party/ffmpeg/generate_stubs.py +++ /dev/null @@ -1,968 +0,0 @@ -#!/usr/bin/python -# -# Copyright (c) 2009 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 -system, a set of stub functions need to be generated that dispatch to functions -found via dlsym. - -This script takes a set of files, where each file is a list of C-style -signatures (one signature per line). The output is either a windows def file, -or a header + implementation file of stubs suitable for use in a posix system. -""" - -__author__ = 'ajwong@chromium.org (Albert J. Wong)' - -import optparse -import os -import re -import string -import subprocess - - -class Error(Exception): - pass - - -class BadSignatureError(Error): - pass - - -class SubprocessError(Error): - def __init__(self, message, error_code): - Error.__init__(self) - self.message = message - self.error_code = error_code - - def __str__(self): - return 'Failed with code %s: %s' % (self.message, repr(self.error_code)) - - -# Regular expression used to parse signatures in the input files. The regex -# is built around identifying the "identifier" for the function name. We -# consider the identifier to be the string that follows these constraints: -# -# 1) Starts with [_a-ZA-Z] (C++ spec 2.10). -# 2) Continues with [_a-ZA-Z0-9] (C++ spec 2.10). -# 3) Preceeds an opening parenthesis by 0 or more whitespace chars. -# -# From that, all preceeding characters are considered the return value. -# Trailing characters should have a substring matching the form (.*). That -# is considered the arguments. -SIGNATURE_REGEX = re.compile('(?P.+?)' - '(?P[_a-zA-Z][_a-zA-Z0-9]+)\s*' - '\((?P.*?)\)') - -# 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_POSIX_STUB = 'posix_stubs' - -# 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. -# arg_list: The arguments used to call the stub function. -STUB_FUNCTION_DEFINITION = ( - """extern %(return_type)s %(name)s(%(params)s) __attribute__((weak)); -%(return_type)s %(name)s(%(params)s) { - %(return_prefix)s%(name)s_ptr(%(arg_list)s); -}""") - -# Template for the preamble for the stub header file with the header guards, -# standard set of includes, and namespace opener. This template takes the -# following named parameters: -# guard_name: The macro to use as the header guard. -# namespace: The namespace for the stub functions. -STUB_HEADER_PREAMBLE = """// This is generated file. Do not modify directly. - -#ifndef %(guard_name)s -#define %(guard_name)s - -#include -#include -#include - -namespace %(namespace)s { -""" - -# Template for the end of the stub header. This closes the namespace and the -# header guards. This template takes the following named parameters: -# guard_name: The macro to use as the header guard. -# namespace: The namespace for the stub functions. -STUB_HEADER_CLOSER = """} // namespace %(namespace)s - -#endif // %(guard_name)s -""" - -# The standard includes needed for the stub implementation file. Takes one -# string substition with the path to the associated stub header file. -IMPLEMENTATION_PREAMBLE = """// This is generated file. Do not modify directly. - -#include "%s" - -#include // For NULL. -#include // For dysym, dlopen. - -#include -#include -""" - -# The start and end templates for the enum definitions used by the Umbrella -# initializer. -UMBRELLA_ENUM_START = """// Enum and typedef for umbrella initializer. -enum StubModules { -""" -UMBRELLA_ENUM_END = """ kNumStubModules -}; - -""" - -# Start and end of the extern "C" section for the implementation contents. -IMPLEMENTATION_CONTENTS_C_START = """extern "C" { - -""" -IMPLEMENTATION_CONTENTS_C_END = """ -} // extern "C" - - -""" - -# Templates for the start and end of a namespace. Takes one parameter, the -# namespace name. -NAMESPACE_START = """namespace %s { - -""" -NAMESPACE_END = """} // namespace %s - -""" - -# Comment to include before the section declaring all the function pointers -# used by the stub functions. -FUNCTION_POINTER_SECTION_COMMENT = ( - """// Static pointers that will hold the location of the real function -// implementations after the module has been loaded. -""") - -# Template for the module initialization check function. This template -# takes two parameteres: the function name, and the conditional used to -# verify the module's initialization. -MODULE_INITIALIZATION_CHECK_FUNCTION = ( - """// Returns true if all stubs have been properly initialized. -bool %s() { - if (%s) { - return true; - } else { - return false; - } -} - -""") - -# Template for the line that initialize the stub pointer. This template takes -# the following named parameters: -# name: The name of the function. -# return_type: The return type. -# params: The parameters to the function. -STUB_POINTER_INITIALIZER = """ %(name)s_ptr = - reinterpret_cast<%(return_type)s (*)(%(parameters)s)>( - dlsym(module, "%(name)s")); -""" - -# Template for module initializer function start and end. This template takes -# one parameter which is the initializer function name. -MODULE_INITIALIZE_START = """// Initializes the module stubs. -void %s(void* module) { -""" -MODULE_INITIALIZE_END = """} - -""" - -# Template for module uninitializer function start and end. This template -# takes one parameter which is the initializer function name. -MODULE_UNINITIALIZE_START = ( - """// Uninitialize the module stubs. Reset pointers to NULL. -void %s() { -""") -MODULE_UNINITIALIZE_END = """} - -""" - - -# Open namespace and add typedef for internal data structures used by the -# umbrella initializer. -UMBRELLA_INITIALIZER_START = """namespace %s { -typedef std::map StubHandleMap; -""" - -# Function close DSOs on error and clean up dangling references. -UMBRELLA_INITIALIZER_CLEANUP_FUNCTION = ( - """static void CloseLibraries(StubHandleMap* stub_handles) { - for (StubHandleMap::const_iterator it = stub_handles->begin(); - it != stub_handles->end(); - ++it) { - dlclose(it->second); - } - - stub_handles->clear(); -} -""") - -# Function to initialize each DSO for the given paths. -UMBRELLA_INITIALIZER_INITIALIZE_FUNCTION_START = ( - """bool InitializeStubs(const StubPathMap& path_map) { - StubHandleMap opened_libraries; - for (int i = 0; i < kNumStubModules; ++i) { - StubModules cur_module = static_cast(i); - // If a module is missing, we fail. - StubPathMap::const_iterator it = path_map.find(cur_module); - if (it == path_map.end()) { - CloseLibraries(&opened_libraries); - return false; - } - - // Otherwise, attempt to dlopen the library. - const std::vector& paths = it->second; - bool module_opened = false; - for (std::vector::const_iterator dso_path = paths.begin(); - !module_opened && dso_path != paths.end(); - ++dso_path) { - void* handle = dlopen(dso_path->c_str(), RTLD_LAZY); - if (handle != NULL) { - module_opened = true; - opened_libraries[cur_module] = handle; - } - } - - if (!module_opened) { - CloseLibraries(&opened_libraries); - return false; - } - } -""") - -# Template to generate code to check if each module initializer correctly -# completed, and cleanup on failures. This template takes the following -# named parameters. -# conditional: The conditional expression for successful initialization. -# uninitializers: The statements needed to uninitialize the modules. -UMBRELLA_INITIALIZER_CHECK_AND_CLEANUP = ( - """ // Check that each module is initialized correctly. - // Close all previously opened libraries on failure. - if (%(conditional)s) { - %(uninitializers)s; - CloseLibraries(&opened_libraries); - return false; - } - - return true; -} -""") - -# Template for Initialize, Unininitialize, and IsInitialized functions for each -# module. This template takes the following named parameters: -# initialize: Name of the Initialize function. -# uninitialize: Name of the Uninitialize function. -# is_initialized: Name of the IsInitialized function. -MODULE_FUNCTION_PROTOTYPES = """bool %(is_initialized)s(); -void %(initialize)s(void* module); -void %(uninitialize)s(); - -""" - -# Template for umbrella initializer declaration and associated datatypes. -UMBRELLA_INITIALIZER_PROTOTYPE = ( - """typedef std::map > StubPathMap; - -// Umbrella initializer for all the modules in this stub file. -bool InitializeStubs(const StubPathMap& path_map); -""") - - -def ExtractModuleName(infile_path): - """Infers the module name from the input file path. - - The input filename is supposed to be in the form "ModuleName.sigs". - This function splits the filename from the extention on that basename of - the path and returns that as the module name. - - Args: - infile_path: String holding the path to the input file. - - Returns: - The module name as a string. - """ - basename = os.path.basename(infile_path) - return os.path.splitext(basename)[0] - - -def ParseSignatures(infile): - """Parses function signatures in the input file. - - This function parses a file of signatures into a list of dictionaries that - represent the function signatures in the input file. Each dictionary has - the following keys: - return_type: A string with the return type. - name: A string with the name of the function. - params: A list of each function parameter declaration (type + name) - - The format of the input file is one C-style function signature per line, no - trailing semicolon. Empty lines are allowed. An empty line is a line that - consists purely of whitespace. Lines that begin with a # are considered - comment lines and are ignored. - - We assume that "int foo(void)" is the same as "int foo()", which is not - true in C where "int foo()" is equivalent to "int foo(...)". Our generated - code is C++, and we do not handle varargs, so this is a case that can be - ignored for now. - - Args: - infile: File object holding a text file of function signatures. - - Returns: - A list of dictionaries, where each dictionary represents one function - signature. - - Raises: - BadSignatureError: A line could not be parsed as a signature. - """ - signatures = [] - for line in infile: - line = line.strip() - if line and line[0] != '#': - m = SIGNATURE_REGEX.match(line) - if m is None: - raise BadSignatureError('Unparsable line: %s' % line) - signatures.append( - {'return_type': m.group('return_type').strip(), - 'name': m.group('name').strip(), - 'params': [arg.strip() for arg in m.group('params').split(',')]}) - return signatures - - -def WriteWindowsDefFile(module_name, signatures, outfile): - """Writes a windows def file to the given output file object. - - The def file format is basically a list of function names. Generation is - simple. After outputting the LIBRARY and EXPORTS lines, print out each - function name, one to a line, preceeded by 2 spaces. - - 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. - outfile: File handle to populate with definitions. - """ - outfile.write('LIBRARY %s\n' % module_name) - outfile.write('EXPORTS\n') - - for sig in signatures: - outfile.write(' %s\n' % sig['name']) - - -def CreateWindowsLib(module_name, signatures, intermediate_dir, outdir_path): - """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. - - 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 = subprocess.call(['lib', '/nologo', '/machine:X86', - '/def:' + def_file_path, - '/out:' + lib_file_path]) - if ret != 0: - raise SubprocessError( - 'Failed creating %s for %s' % (lib_file_path, def_file_path), - ret) - - -class PosixStubWriter(object): - """Creates a file of stub functions for a library that is opened via dlopen. - - Windows provides a function in their compiler known as delay loading, which - effectively generates a set of stub functions for a dynamic library that - delays loading of the dynamic library/resolution of the symbols until one of - the needed functions are accessed. - - In posix, RTLD_LAZY does something similar with DSOs. This is the default - link mode for DSOs. However, even though the symbol is not resolved until - first usage, the DSO must be present at load time of the main binary. - - To simulate the windows delay load procedure, we need to create a set of - stub functions that allow for correct linkage of the main binary, but - dispatch to the dynamically resolved symbol when the module is initialized. - - This class takes a list of function signatures, and generates a set of stub - functions plus initialization code for them. - """ - - def __init__(self, module_name, signatures): - """Initializes PosixStubWriter for this set of signatures and module_name. - - 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. - """ - self.signatures = signatures - self.module_name = module_name - - @classmethod - def CStyleIdentifier(cls, identifier): - """Generates a C style identifier. - - The module_name has all invalid identifier characters removed (anything - that's not [_a-zA-Z0-9]) and is run through string.capwords to try - and approximate camel case. - - Args: - identifier: The string with the module name to turn to C-style. - - Returns: - A string that can be used as part of a C identifier. - """ - return string.capwords(re.sub(INVALID_C_IDENT_CHARS, '', identifier)) - - @classmethod - def EnumName(cls, module_name): - """Gets the enum name for the module. - - Takes the module name and creates a suitable enum name. The module_name - is munged to be a valid C identifier then prefixed with the string - "kModule" to generate a Google style enum name. - - Args: - module_name: The name of the module to generate an enum name for. - - Returns: - A string with the name of the enum value representing this module. - """ - return 'kModule%s' % PosixStubWriter.CStyleIdentifier(module_name) - - @classmethod - def IsInitializedName(cls, module_name): - """Gets the name of function that checks initialization of this module. - - The name is in the format IsModuleInitialized. Where "Module" is replaced - with the module name, munged to be a valid C identifier. - - Args: - module_name: The name of the module to generate the function name for. - - Returns: - A string with the name of the initialization check function. - """ - return 'Is%sInitialized' % PosixStubWriter.CStyleIdentifier(module_name) - - @classmethod - def InitializeModuleName(cls, module_name): - """Gets the name of the function that initializes this module. - - The name is in the format InitializeModule. Where "Module" is replaced - with the module name, munged to be a valid C identifier. - - Args: - module_name: The name of the module to generate the function name for. - - Returns: - A string with the name of the initialization function. - """ - return 'Initialize%s' % PosixStubWriter.CStyleIdentifier(module_name) - - @classmethod - def UninitializeModuleName(cls, module_name): - """Gets the name of the function that uninitializes this module. - - The name is in the format UninitializeModule. Where "Module" is replaced - with the module name, munged to be a valid C identifier. - - Args: - module_name: The name of the module to generate the function name for. - - Returns: - A string with the name of the uninitialization function. - """ - return 'Uninitialize%s' % PosixStubWriter.CStyleIdentifier(module_name) - - @classmethod - def StubFunctionPointer(cls, signature): - """Generates a function pointer declaration for the given signature. - - Args: - signature: A signature hash, as produced by ParseSignatures, - representating the function signature. - - Returns: - A string with the declaration of the function pointer for the signature. - """ - return 'static %s (*%s_ptr)(%s) = NULL;' % (signature['return_type'], - signature['name'], - ', '.join(signature['params'])) - - @classmethod - def StubFunction(cls, signature): - """Generates a stub function definition for the given signature. - - The function definitions are created with __attribute__((weak)) so that - they may be overridden by a real static link or mock versions to be used - when testing. - - Args: - signature: A signature hash, as produced by ParseSignatures, - representating the function signature. - - Returns: - A string with the stub function definition. - """ - return_prefix = '' - if signature['return_type'] != 'void': - return_prefix = 'return ' - - # Generate the argument list. - arguments = [re.split('[\*& ]', arg)[-1].strip() for arg in - signature['params']] - arg_list = ', '.join(arguments) - if arg_list == 'void': - arg_list = '' - - return STUB_FUNCTION_DEFINITION % { - 'return_type': signature['return_type'], - 'name': signature['name'], - 'params': ', '.join(signature['params']), - 'return_prefix': return_prefix, - 'arg_list': arg_list} - - @classmethod - def WriteImplementationPreamble(cls, header_path, outfile): - """Write the necessary includes for the implementation file. - - Args: - header_path: The path to the header file. - outfile: The file handle to populate. - """ - outfile.write(IMPLEMENTATION_PREAMBLE % header_path) - - @classmethod - def WriteUmbrellaInitializer(cls, module_names, namespace, outfile): - """Writes a single function that will open + initialize each module. - - This intializer will take in an stl map of that lists the correct - dlopen target for each module. The map type is - std::map> which matches one module - to a list of paths to try in dlopen. - - This function is an all-or-nothing function. If any module fails to load, - all other modules are dlclosed, and the function returns. Though it is - not enforced, this function should only be called once. - - Args: - module_names: A list with the names of the modules in this stub file. - namespace: The namespace these functions should be in. - outfile: The file handle to populate with pointer definitions. - """ - outfile.write(UMBRELLA_INITIALIZER_START % namespace) - outfile.write(UMBRELLA_INITIALIZER_CLEANUP_FUNCTION) - - # Create the initializaiton function that calls all module initializers, - # checks if they succeeded, and backs out module loads on an error. - outfile.write(UMBRELLA_INITIALIZER_INITIALIZE_FUNCTION_START) - outfile.write( - '\n // Initialize each module if we have not already failed.\n') - for module in module_names: - outfile.write(' %s(opened_libraries[%s]);\n' % - (PosixStubWriter.InitializeModuleName(module), - PosixStubWriter.EnumName(module))) - outfile.write('\n') - - # Output code to check the initialization status, clean up on error. - initializer_checks = ['!%s()' % PosixStubWriter.IsInitializedName(name) - for name in module_names] - uninitializers = ['%s()' % PosixStubWriter.UninitializeModuleName(name) - for name in module_names] - outfile.write(UMBRELLA_INITIALIZER_CHECK_AND_CLEANUP % { - 'conditional': ' ||\n '.join(initializer_checks), - 'uninitializers': ';\n '.join(uninitializers)}) - outfile.write('\n} // namespace %s\n' % namespace) - - @classmethod - def WriteHeaderContents(cls, module_names, namespace, header_guard, outfile): - """Writes a header file for the stub file generated for module_names. - - The header file exposes the following: - 1) An enum, StubModules, listing with an entry for each enum. - 2) A typedef for a StubPathMap allowing for specification of paths to - search for each module. - 3) The IsInitialized/Initialize/Uninitialize functions for each module. - 4) An umbrella initialize function for all modules. - - Args: - module_names: A list with the names of each module in this stub file. - namespace: The namespace these functions should be in. - header_guard: The macro to use as our header guard. - outfile: The output handle to populate. - """ - outfile.write(STUB_HEADER_PREAMBLE % - {'guard_name': header_guard, 'namespace': namespace}) - - # Generate the Initializer protoypes for each module. - outfile.write('// Individual module initializer functions.\n') - for name in module_names: - outfile.write(MODULE_FUNCTION_PROTOTYPES % { - 'is_initialized': PosixStubWriter.IsInitializedName(name), - 'initialize': PosixStubWriter.InitializeModuleName(name), - 'uninitialize': PosixStubWriter.UninitializeModuleName(name)}) - - # Generate the enum for umbrella initializer. - outfile.write(UMBRELLA_ENUM_START) - outfile.write(' %s = 0,\n' % PosixStubWriter.EnumName(module_names[0])) - for name in module_names[1:]: - outfile.write(' %s,\n' % PosixStubWriter.EnumName(name)) - outfile.write(UMBRELLA_ENUM_END) - - outfile.write(UMBRELLA_INITIALIZER_PROTOTYPE) - outfile.write(STUB_HEADER_CLOSER % { - 'namespace': namespace, 'guard_name': - header_guard}) - - def WriteImplementationContents(self, namespace, outfile): - """Given a file handle, write out the stub definitions for this module. - - Args: - namespace: The namespace these functions should be in. - outfile: The file handle to populate. - """ - outfile.write(IMPLEMENTATION_CONTENTS_C_START) - self.WriteFunctionPointers(outfile) - self.WriteStubFunctions(outfile) - outfile.write(IMPLEMENTATION_CONTENTS_C_END) - - outfile.write(NAMESPACE_START % namespace) - self.WriteModuleInitializeFunctions(outfile) - outfile.write(NAMESPACE_END % namespace) - - def WriteFunctionPointers(self, outfile): - """Write the function pointer declarations needed by the stubs. - - We need function pointers to hold the actual location of the function - implementation returned by dlsym. This function outputs a pointer - definition for each signature in the module. - - Pointers will be named with the following pattern "FuntionName_ptr". - - Args: - outfile: The file handle to populate with pointer definitions. - """ - outfile.write(FUNCTION_POINTER_SECTION_COMMENT) - - for sig in self.signatures: - outfile.write('%s\n' % PosixStubWriter.StubFunctionPointer(sig)) - outfile.write('\n') - - def WriteStubFunctions(self, outfile): - """Write the function stubs to handle dispatching to real implementations. - - Functions that have a return type other than void will look as follows: - - ReturnType FunctionName(A a) { - return FunctionName_ptr(a); - } - - Functions with a return type of void will look as follows: - - void FunctionName(A a) { - FunctionName_ptr(a); - } - - Args: - outfile: The file handle to populate. - """ - outfile.write('// Stubs that dispatch to the real implementations.\n') - for sig in self.signatures: - outfile.write('%s\n' % PosixStubWriter.StubFunction(sig)) - - def WriteModuleInitializeFunctions(self, outfile): - """Write functions to initialize/query initlialization of the module. - - This creates 2 functions IsModuleInitialized and InitializeModule where - "Module" is replaced with the module name, first letter capitalized. - - The InitializeModule function takes a handle that is retrieved from dlopen - and attempts to assign each function pointer above via dlsym. - - The IsModuleInitialized returns true if none of the required functions - pointers are NULL. - - Args: - outfile: The file handle to populate. - """ - ptr_names = ['%s_ptr' % sig['name'] for sig in self.signatures] - - # Construct the conditional expression to check the initialization of - # all the function pointers above. It should generate a conjuntion - # with each pointer on its own line, indented by six spaces to match - # the indentation level of MODULE_INITIALIZATION_CHECK_FUNCTION. - initialization_conditional = ' &&\n '.join(ptr_names) - - outfile.write(MODULE_INITIALIZATION_CHECK_FUNCTION % ( - PosixStubWriter.IsInitializedName(self.module_name), - initialization_conditional)) - - # Create function that initializes the module. - outfile.write(MODULE_INITIALIZE_START % - PosixStubWriter.InitializeModuleName(self.module_name)) - for sig in self.signatures: - outfile.write(STUB_POINTER_INITIALIZER % { - 'name': sig['name'], - 'return_type': sig['return_type'], - 'parameters': ', '.join(sig['params'])}) - outfile.write(MODULE_INITIALIZE_END) - - # Create function that uninitializes the module (sets all pointers to - # NULL). - outfile.write(MODULE_UNINITIALIZE_START % - PosixStubWriter.UninitializeModuleName(self.module_name)) - for sig in self.signatures: - outfile.write(' %s_ptr = NULL;\n' % sig['name']) - outfile.write(MODULE_UNINITIALIZE_END) - - -def CreateOptionParser(): - """Creates an OptionParser for the configuration options of script. - - Returns: - A OptionParser object. - """ - parser = optparse.OptionParser(usage='usage: %prog [options] input') - parser.add_option('-o', - '--output', - dest='out_dir', - default=None, - help='Output location.') - parser.add_option('-i', - '--intermediate_dir', - dest='intermediate_dir', - default=None, - help='Locaiton of intermediate files.') - parser.add_option('-t', - '--type', - dest='type', - default=None, - help=('Type of file. Either "%s" or "%s"' % - (FILE_TYPE_POSIX_STUB, FILE_TYPE_WIN))) - parser.add_option('-s', - '--stubfile_name', - dest='stubfile_name', - default=None, - help=('Name of posix_stubs output file. Ignored for ' - '%s type.' % FILE_TYPE_WIN)) - 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)) - 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)) - 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]: - parser.error('Invalid output file type') - - if options.type == FILE_TYPE_POSIX_STUB: - if options.stubfile_name is None: - parser.error('Output file name need 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) - - return options, args - - -def CreateOutputDirectories(options): - """Creates the intermediate and final output directories. - - Given the parsed options, create the intermediate and final output - directories if they do not exist. Returns the paths to both directories - as a pair. - - Args: - options: An OptionParser.OptionValues object with the parsed options. - - Returns: - The pair (out_dir, intermediate_dir), both of which are strings. - """ - out_dir = os.path.normpath(options.out_dir) - intermediate_dir = os.path.normpath(options.intermediate_dir) - if intermediate_dir is None: - intermediate_dir = out_dir - - if not os.path.exists(out_dir): - os.makedirs(out_dir) - if not os.path.exists(intermediate_dir): - os.makedirs(intermediate_dir) - - return out_dir, intermediate_dir - - -def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir): - """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. - """ - 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) - finally: - infile.close() - - -def CreatePosixStubsForSigFiles(sig_files, stub_name, out_dir, - intermediate_dir, path_from_source, - extra_stub_header): - """Create a posix stub library with a module for each signature file. - - Args: - sig_files: Array of Strings with the paths to each signature file. - stub_name: String with the basename of the generated stub file. - out_dir: String holding path to directory for the .h files. - intermediate_dir: String holding path to directory for the .cc files. - path_from_source: String with relative path of generated files from the - project root. - extra_stub_header: String with path to file of extra lines to insert - into the generated header for the stub library. - """ - header_base_name = stub_name + '.h' - header_path = os.path.join(out_dir, header_base_name) - impl_path = os.path.join(intermediate_dir, stub_name + '.cc') - - module_names = [ExtractModuleName(path) for path in sig_files] - namespace = path_from_source.replace('/', '_').lower() - header_guard = '%s_' % namespace.upper() - header_include_path = os.path.join(path_from_source, header_base_name) - - # First create the implementation file. - impl_file = open(impl_path, 'w') - try: - # Open the file, and create the preamble which consists of a file - # header plus any necessary includes. - PosixStubWriter.WriteImplementationPreamble(header_include_path, - impl_file) - if extra_stub_header is not None: - extra_header_file = open(extra_stub_header, 'r') - try: - impl_file.write('\n') - for line in extra_header_file: - impl_file.write(line) - impl_file.write('\n') - finally: - extra_header_file.close() - - # For each signature file, generate the stub population functions - # for that file. Each file represents one module. - for input_path in sig_files: - name = ExtractModuleName(input_path) - infile = open(input_path, 'r') - try: - signatures = ParseSignatures(infile) - finally: - infile.close() - writer = PosixStubWriter(name, signatures) - writer.WriteImplementationContents(namespace, impl_file) - - # Lastly, output the umbrella function for the file. - PosixStubWriter.WriteUmbrellaInitializer(module_names, namespace, - impl_file) - finally: - impl_file.close() - - # Then create the associated header file. - header_file = open(header_path, 'w') - try: - 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) - elif options.type == FILE_TYPE_POSIX_STUB: - CreatePosixStubsForSigFiles(args, options.stubfile_name, out_dir, - intermediate_dir, options.path_from_source, - options.extra_stub_header) - - -if __name__ == '__main__': - main() diff --git a/third_party/ffmpeg/generate_stubs_unittest.py b/third_party/ffmpeg/generate_stubs_unittest.py deleted file mode 100755 index cfab996..0000000 --- a/third_party/ffmpeg/generate_stubs_unittest.py +++ /dev/null @@ -1,283 +0,0 @@ -#!/usr/bin/python -# Copyright (c) 2009 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. - -"""Unittest for the generate_stubs.py. - -Since generate_stubs.py is a code generator, it is hard to do a very good -test. Instead of creating a golden-file test, which might be flakey, this -test elects instead to verify that various components "exist" within the -generated file as a sanity check. In particular, there is a simple hit -test to make sure that umbrella functions, etc., do try and include every -function they are responsible for invoking. Missing an invocation is quite -easily missed. - -There is no attempt to verify ordering of different components, or whether -or not those components are going to parse incorrectly because of prior -errors or positioning. Most of that should be caught really fast anyways -during any attempt to use a badly behaving script. -""" - -import re -import StringIO -import unittest -import generate_stubs as gs - - -def _MakeSignature(return_type, name, params): - return {'return_type': return_type, - 'name': name, - 'params': params} - - -SIMPLE_SIGNATURES = [ - ('int foo(int a)', _MakeSignature('int', 'foo', ['int a'])), - ('int bar(int a, double b)', _MakeSignature('int', 'bar', - ['int a', 'double b'])), - ('int baz(void)', _MakeSignature('int', 'baz', ['void'])), - ('void quux(void)', _MakeSignature('void', 'quux', ['void'])), - ('void waldo(void);', _MakeSignature('void', 'waldo', ['void'])), - ('int corge(void);', _MakeSignature('int', 'corge', ['void'])), - ] - -TRICKY_SIGNATURES = [ - ('const struct name *foo(int a, struct Test* b); ', - _MakeSignature('const struct name *', - 'foo', - ['int a', 'struct Test* b'])), - ('const struct name &foo(int a, struct Test* b);', - _MakeSignature('const struct name &', - 'foo', - ['int a', 'struct Test* b'])), - ('const struct name &_foo(int a, struct Test* b);', - _MakeSignature('const struct name &', - '_foo', - ['int a', 'struct Test* b'])), - ('struct name const * const _foo(int a, struct Test* b) ' - '__attribute__((inline));', - _MakeSignature('struct name const * const', - '_foo', - ['int a', 'struct Test* b'])) - ] - -INVALID_SIGNATURES = ['I am bad', 'Seriously bad(', ';;;'] - - -class GenerateStubModuleFunctionsUnittest(unittest.TestCase): - def testExtractModuleName(self): - self.assertEqual('somefile-2', gs.ExtractModuleName('somefile-2.ext')) - - def testParseSignatures_EmptyFile(self): - # Empty file just generates empty signatures. - infile = StringIO.StringIO() - signatures = gs.ParseSignatures(infile) - self.assertEqual(0, len(signatures)) - - def testParseSignatures_SimpleSignatures(self): - file_contents = '\n'.join([x[0] for x in SIMPLE_SIGNATURES]) - infile = StringIO.StringIO(file_contents) - signatures = gs.ParseSignatures(infile) - self.assertEqual(len(SIMPLE_SIGNATURES), len(signatures)) - - # We assume signatures are in order. - for i in xrange(len(SIMPLE_SIGNATURES)): - self.assertEqual(SIMPLE_SIGNATURES[i][1], signatures[i], - msg='Expected %s\nActual %s\nFor %s' % - (SIMPLE_SIGNATURES[i][1], - signatures[i], - SIMPLE_SIGNATURES[i][0])) - - def testParseSignatures_TrickySignatures(self): - file_contents = '\n'.join([x[0] for x in TRICKY_SIGNATURES]) - infile = StringIO.StringIO(file_contents) - signatures = gs.ParseSignatures(infile) - self.assertEqual(len(TRICKY_SIGNATURES), len(signatures)) - - # We assume signatures are in order. - for i in xrange(len(TRICKY_SIGNATURES)): - self.assertEqual(TRICKY_SIGNATURES[i][1], signatures[i], - msg='Expected %s\nActual %s\nFor %s' % - (TRICKY_SIGNATURES[i][1], - signatures[i], - TRICKY_SIGNATURES[i][0])) - - def testParseSignatures_InvalidSignatures(self): - for i in INVALID_SIGNATURES: - infile = StringIO.StringIO(i) - self.assertRaises(gs.BadSignatureError, gs.ParseSignatures, infile) - - def testParseSignatures_CommentsIgnored(self): - my_sigs = [] - my_sigs.append('# a comment') - my_sigs.append(SIMPLE_SIGNATURES[0][0]) - my_sigs.append('# another comment') - my_sigs.append(SIMPLE_SIGNATURES[0][0]) - my_sigs.append('# a third comment') - my_sigs.append(SIMPLE_SIGNATURES[0][0]) - - file_contents = '\n'.join(my_sigs) - infile = StringIO.StringIO(file_contents) - signatures = gs.ParseSignatures(infile) - self.assertEqual(3, len(signatures)) - - -class WindowsLibUnittest(unittest.TestCase): - def testWriteWindowsDefFile(self): - module_name = 'my_module-1' - signatures = [sig[1] for sig in SIMPLE_SIGNATURES] - outfile = StringIO.StringIO() - gs.WriteWindowsDefFile(module_name, signatures, outfile) - contents = outfile.getvalue() - - # Check that the file header is correct. - self.assertTrue(contents.startswith("""LIBRARY %s -EXPORTS -""" % module_name)) - - # Check that the signatures were exported. - for sig in signatures: - pattern = '\n %s\n' % sig['name'] - self.assertTrue(re.search(pattern, contents), - msg='Expected match of "%s" in %s' % (pattern, contents)) - - -class PosixStubWriterUnittest(unittest.TestCase): - def setUp(self): - self.module_name = 'my_module-1' - self.signatures = [sig[1] for sig in SIMPLE_SIGNATURES] - self.out_dir = 'out_dir' - self.writer = gs.PosixStubWriter(self.module_name, self.signatures) - - def testEnumName(self): - self.assertEqual('kModuleMy_module1', - gs.PosixStubWriter.EnumName(self.module_name)) - - def testIsInitializedName(self): - self.assertEqual('IsMy_module1Initialized', - gs.PosixStubWriter.IsInitializedName(self.module_name)) - - def testInitializeModuleName(self): - self.assertEqual( - 'InitializeMy_module1', - gs.PosixStubWriter.InitializeModuleName(self.module_name)) - - def testUninitializeModuleName(self): - self.assertEqual( - 'UninitializeMy_module1', - gs.PosixStubWriter.UninitializeModuleName(self.module_name)) - - def testStubFunctionPointer(self): - self.assertEqual( - 'static int (*foo_ptr)(int a) = NULL;', - gs.PosixStubWriter.StubFunctionPointer(SIMPLE_SIGNATURES[0][1])) - - def testStubFunction(self): - # Test for a signature with a return value and a parameter. - self.assertEqual("""extern int foo(int a) __attribute__((weak)); -int foo(int a) { - return foo_ptr(a); -}""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[0][1])) - - # Test for a signature with a void return value and no parameters. - self.assertEqual("""extern void waldo(void) __attribute__((weak)); -void waldo(void) { - waldo_ptr(); -}""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[4][1])) - - def testWriteImplemenationContents(self): - outfile = StringIO.StringIO() - self.writer.WriteImplementationContents('my_namespace', outfile) - contents = outfile.getvalue() - - # Verify namespace exists somewhere. - self.assertTrue(contents.find('namespace my_namespace {') != -1) - - # Verify that each signature has an _ptr and a function call in the file. - # Check that the signatures were exported. - for sig in self.signatures: - decl = gs.PosixStubWriter.StubFunctionPointer(sig) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - - # Verify that each signature has an stub function generated for it. - for sig in self.signatures: - decl = gs.PosixStubWriter.StubFunction(sig) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - - # Find module initializer functions. Make sure all 3 exist. - decl = gs.PosixStubWriter.InitializeModuleName(self.module_name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.UninitializeModuleName(self.module_name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.IsInitializedName(self.module_name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - - def testWriteHeaderContents(self): - # Data for header generation. - module_names = ['oneModule', 'twoModule'] - - # Make the header. - outfile = StringIO.StringIO() - self.writer.WriteHeaderContents(module_names, 'my_namespace', 'GUARD_', - outfile) - contents = outfile.getvalue() - - # Check for namespace and header guard. - self.assertTrue(contents.find('namespace my_namespace {') != -1) - self.assertTrue(contents.find('#ifndef GUARD_') != -1) - - # Check for umbrella initializer. - self.assertTrue(contents.find('InitializeStubs(') != -1) - - # Check per-module declarations. - for name in module_names: - # Check for enums. - decl = gs.PosixStubWriter.EnumName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - - # Check for module initializer functions. - decl = gs.PosixStubWriter.IsInitializedName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.InitializeModuleName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.UninitializeModuleName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - - def testWriteUmbrellaInitializer(self): - # Data for header generation. - module_names = ['oneModule', 'twoModule'] - - # Make the header. - outfile = StringIO.StringIO() - self.writer.WriteUmbrellaInitializer(module_names, 'my_namespace', outfile) - contents = outfile.getvalue() - - # Check for umbrella initializer declaration. - self.assertTrue(contents.find('bool InitializeStubs(') != -1) - - # If the umbrella initializer is correctly written, each module will have - # its initializer called, checked, and uninitialized on failure. Sanity - # check that here. - for name in module_names: - # Check for module initializer functions. - decl = gs.PosixStubWriter.IsInitializedName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.InitializeModuleName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - decl = gs.PosixStubWriter.UninitializeModuleName(name) - self.assertTrue(contents.find(decl) != -1, - msg='Expected "%s" in %s' % (decl, contents)) - -if __name__ == '__main__': - unittest.main() diff --git a/third_party/openmax/il.sigs b/third_party/openmax/il.sigs new file mode 100644 index 0000000..20d6b98 --- /dev/null +++ b/third_party/openmax/il.sigs @@ -0,0 +1,11 @@ +# Copyright (c) 2010 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. +# +# Functions from OpenMAX IL used in Chromium code. + +OMX_ERRORTYPE OMX_Init(void); +OMX_ERRORTYPE OMX_Deinit(void); +OMX_ERRORTYPE OMX_GetHandle(OMX_HANDLETYPE* pHandle, OMX_STRING cComponentName, OMX_PTR pAppData, OMX_CALLBACKTYPE* pCallBacks); +OMX_ERRORTYPE OMX_FreeHandle(OMX_HANDLETYPE hComponent); +OMX_ERRORTYPE OMX_GetComponentsOfRole (OMX_STRING role, OMX_U32* pNumComps, OMX_U8** compNames); diff --git a/third_party/openmax/il_stub_headers.fragment b/third_party/openmax/il_stub_headers.fragment new file mode 100644 index 0000000..222f4dc --- /dev/null +++ b/third_party/openmax/il_stub_headers.fragment @@ -0,0 +1,8 @@ +// These are some extra includes needed in the generated stub file for defining +// various OpenMAX types. + +extern "C" { + +#include "third_party/openmax/il/OMX_Core.h" + +} diff --git a/third_party/openmax/openmax.gyp b/third_party/openmax/openmax.gyp index ef14e41..16293e4 100644 --- a/third_party/openmax/openmax.gyp +++ b/third_party/openmax/openmax.gyp @@ -1,4 +1,4 @@ -# Copyright (c) 2009 The Chromium Authors. All rights reserved. +# Copyright (c) 2010 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. @@ -26,9 +26,12 @@ 'include_dirs': [ 'il', ], + 'defines': [ + '__OMX_EXPORTS', + ], }, 'conditions': [ - ['openmax_type=="stub"', { + ['OS!="linux"', { 'type': '<(library)', 'dependencies': [ '../../base/base.gyp:base', @@ -42,31 +45,64 @@ 'defines': [ '__OMX_EXPORTS', ], + }], + ['OS=="linux"', { + 'variables': { + 'generate_stubs_script': '../../tools/generate_stubs/generate_stubs.py', + 'sig_files': [ + 'il.sigs', + ], + 'extra_header': 'il_stub_headers.fragment', + 'outfile_type': 'posix_stubs', + 'stubs_filename_root': 'il_stubs', + 'project_path': 'third_party/openmax', + 'intermediate_dir': '<(INTERMEDIATE_DIR)', + 'output_root': '<(SHARED_INTERMEDIATE_DIR)/openmax', + }, + 'type': '<(library)', + 'dependencies': [ + '../../base/base.gyp:base', + ], + 'defines': [ + '__OMX_EXPORTS', + ], + 'include_dirs': [ + 'il', + '<(output_root)', + '../..', # The chromium 'src' directory. + ], 'direct_dependent_settings': { - 'defines': [ - '__OMX_EXPORTS', + 'include_dirs': [ + '<(output_root)', + '../..', # The chromium 'src' directory. ], }, - }], - ['openmax_type=="bellagio"', { - 'type': 'none', - 'direct_dependent_settings': { - 'link_settings': { - 'libraries': [ - '-lomxil-bellagio', + 'actions': [ + { + 'action_name': 'generate_stubs', + 'inputs': [ + '<(generate_stubs_script)', + '<(extra_header)', + '<@(sig_files)', ], - }, - }, - }], - ['openmax_type=="omxcore"', { - 'type': 'none', - 'direct_dependent_settings': { - 'link_settings': { - 'libraries': [ - '-lOmxCore', + 'outputs': [ + '<(intermediate_dir)/<(stubs_filename_root).cc', + '<(output_root)/<(project_path)/<(stubs_filename_root).h', + ], + 'action': ['python', + '<(generate_stubs_script)', + '-i', '<(intermediate_dir)', + '-o', '<(output_root)/<(project_path)', + '-t', '<(outfile_type)', + '-e', '<(extra_header)', + '-s', '<(stubs_filename_root)', + '-p', '<(project_path)', + '<@(_inputs)', ], + 'process_outputs_as_sources': 1, + 'message': 'Generating OpenMAX IL stubs for dynamic loading.', }, - }, + ], }], ], }, diff --git a/tools/generate_stubs/generate_stubs.py b/tools/generate_stubs/generate_stubs.py new file mode 100755 index 0000000..e1ba671 --- /dev/null +++ b/tools/generate_stubs/generate_stubs.py @@ -0,0 +1,968 @@ +#!/usr/bin/python +# +# Copyright (c) 2009 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 +system, a set of stub functions need to be generated that dispatch to functions +found via dlsym. + +This script takes a set of files, where each file is a list of C-style +signatures (one signature per line). The output is either a windows def file, +or a header + implementation file of stubs suitable for use in a posix system. +""" + +__author__ = 'ajwong@chromium.org (Albert J. Wong)' + +import optparse +import os +import re +import string +import subprocess + + +class Error(Exception): + pass + + +class BadSignatureError(Error): + pass + + +class SubprocessError(Error): + def __init__(self, message, error_code): + Error.__init__(self) + self.message = message + self.error_code = error_code + + def __str__(self): + return 'Failed with code %s: %s' % (self.message, repr(self.error_code)) + + +# Regular expression used to parse signatures in the input files. The regex +# is built around identifying the "identifier" for the function name. We +# consider the identifier to be the string that follows these constraints: +# +# 1) Starts with [_a-ZA-Z] (C++ spec 2.10). +# 2) Continues with [_a-ZA-Z0-9] (C++ spec 2.10). +# 3) Preceeds an opening parenthesis by 0 or more whitespace chars. +# +# From that, all preceeding characters are considered the return value. +# Trailing characters should have a substring matching the form (.*). That +# is considered the arguments. +SIGNATURE_REGEX = re.compile('(?P.+?)' + '(?P[_a-zA-Z][_a-zA-Z0-9]+)\s*' + '\((?P.*?)\)') + +# 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_POSIX_STUB = 'posix_stubs' + +# 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. +# arg_list: The arguments used to call the stub function. +STUB_FUNCTION_DEFINITION = ( + """extern %(return_type)s %(name)s(%(params)s) __attribute__((weak)); +%(return_type)s %(name)s(%(params)s) { + %(return_prefix)s%(name)s_ptr(%(arg_list)s); +}""") + +# Template for the preamble for the stub header file with the header guards, +# standard set of includes, and namespace opener. This template takes the +# following named parameters: +# guard_name: The macro to use as the header guard. +# namespace: The namespace for the stub functions. +STUB_HEADER_PREAMBLE = """// This is generated file. Do not modify directly. + +#ifndef %(guard_name)s +#define %(guard_name)s + +#include +#include +#include + +namespace %(namespace)s { +""" + +# Template for the end of the stub header. This closes the namespace and the +# header guards. This template takes the following named parameters: +# guard_name: The macro to use as the header guard. +# namespace: The namespace for the stub functions. +STUB_HEADER_CLOSER = """} // namespace %(namespace)s + +#endif // %(guard_name)s +""" + +# The standard includes needed for the stub implementation file. Takes one +# string substition with the path to the associated stub header file. +IMPLEMENTATION_PREAMBLE = """// This is generated file. Do not modify directly. + +#include "%s" + +#include // For NULL. +#include // For dysym, dlopen. + +#include +#include +""" + +# The start and end templates for the enum definitions used by the Umbrella +# initializer. +UMBRELLA_ENUM_START = """// Enum and typedef for umbrella initializer. +enum StubModules { +""" +UMBRELLA_ENUM_END = """ kNumStubModules +}; + +""" + +# Start and end of the extern "C" section for the implementation contents. +IMPLEMENTATION_CONTENTS_C_START = """extern "C" { + +""" +IMPLEMENTATION_CONTENTS_C_END = """ +} // extern "C" + + +""" + +# Templates for the start and end of a namespace. Takes one parameter, the +# namespace name. +NAMESPACE_START = """namespace %s { + +""" +NAMESPACE_END = """} // namespace %s + +""" + +# Comment to include before the section declaring all the function pointers +# used by the stub functions. +FUNCTION_POINTER_SECTION_COMMENT = ( + """// Static pointers that will hold the location of the real function +// implementations after the module has been loaded. +""") + +# Template for the module initialization check function. This template +# takes two parameteres: the function name, and the conditional used to +# verify the module's initialization. +MODULE_INITIALIZATION_CHECK_FUNCTION = ( + """// Returns true if all stubs have been properly initialized. +bool %s() { + if (%s) { + return true; + } else { + return false; + } +} + +""") + +# Template for the line that initialize the stub pointer. This template takes +# the following named parameters: +# name: The name of the function. +# return_type: The return type. +# params: The parameters to the function. +STUB_POINTER_INITIALIZER = """ %(name)s_ptr = + reinterpret_cast<%(return_type)s (*)(%(parameters)s)>( + dlsym(module, "%(name)s")); +""" + +# Template for module initializer function start and end. This template takes +# one parameter which is the initializer function name. +MODULE_INITIALIZE_START = """// Initializes the module stubs. +void %s(void* module) { +""" +MODULE_INITIALIZE_END = """} + +""" + +# Template for module uninitializer function start and end. This template +# takes one parameter which is the initializer function name. +MODULE_UNINITIALIZE_START = ( + """// Uninitialize the module stubs. Reset pointers to NULL. +void %s() { +""") +MODULE_UNINITIALIZE_END = """} + +""" + + +# Open namespace and add typedef for internal data structures used by the +# umbrella initializer. +UMBRELLA_INITIALIZER_START = """namespace %s { +typedef std::map StubHandleMap; +""" + +# Function close DSOs on error and clean up dangling references. +UMBRELLA_INITIALIZER_CLEANUP_FUNCTION = ( + """static void CloseLibraries(StubHandleMap* stub_handles) { + for (StubHandleMap::const_iterator it = stub_handles->begin(); + it != stub_handles->end(); + ++it) { + dlclose(it->second); + } + + stub_handles->clear(); +} +""") + +# Function to initialize each DSO for the given paths. +UMBRELLA_INITIALIZER_INITIALIZE_FUNCTION_START = ( + """bool InitializeStubs(const StubPathMap& path_map) { + StubHandleMap opened_libraries; + for (int i = 0; i < kNumStubModules; ++i) { + StubModules cur_module = static_cast(i); + // If a module is missing, we fail. + StubPathMap::const_iterator it = path_map.find(cur_module); + if (it == path_map.end()) { + CloseLibraries(&opened_libraries); + return false; + } + + // Otherwise, attempt to dlopen the library. + const std::vector& paths = it->second; + bool module_opened = false; + for (std::vector::const_iterator dso_path = paths.begin(); + !module_opened && dso_path != paths.end(); + ++dso_path) { + void* handle = dlopen(dso_path->c_str(), RTLD_LAZY); + if (handle != NULL) { + module_opened = true; + opened_libraries[cur_module] = handle; + } + } + + if (!module_opened) { + CloseLibraries(&opened_libraries); + return false; + } + } +""") + +# Template to generate code to check if each module initializer correctly +# completed, and cleanup on failures. This template takes the following +# named parameters. +# conditional: The conditional expression for successful initialization. +# uninitializers: The statements needed to uninitialize the modules. +UMBRELLA_INITIALIZER_CHECK_AND_CLEANUP = ( + """ // Check that each module is initialized correctly. + // Close all previously opened libraries on failure. + if (%(conditional)s) { + %(uninitializers)s; + CloseLibraries(&opened_libraries); + return false; + } + + return true; +} +""") + +# Template for Initialize, Unininitialize, and IsInitialized functions for each +# module. This template takes the following named parameters: +# initialize: Name of the Initialize function. +# uninitialize: Name of the Uninitialize function. +# is_initialized: Name of the IsInitialized function. +MODULE_FUNCTION_PROTOTYPES = """bool %(is_initialized)s(); +void %(initialize)s(void* module); +void %(uninitialize)s(); + +""" + +# Template for umbrella initializer declaration and associated datatypes. +UMBRELLA_INITIALIZER_PROTOTYPE = ( + """typedef std::map > StubPathMap; + +// Umbrella initializer for all the modules in this stub file. +bool InitializeStubs(const StubPathMap& path_map); +""") + + +def ExtractModuleName(infile_path): + """Infers the module name from the input file path. + + The input filename is supposed to be in the form "ModuleName.sigs". + This function splits the filename from the extention on that basename of + the path and returns that as the module name. + + Args: + infile_path: String holding the path to the input file. + + Returns: + The module name as a string. + """ + basename = os.path.basename(infile_path) + return os.path.splitext(basename)[0] + + +def ParseSignatures(infile): + """Parses function signatures in the input file. + + This function parses a file of signatures into a list of dictionaries that + represent the function signatures in the input file. Each dictionary has + the following keys: + return_type: A string with the return type. + name: A string with the name of the function. + params: A list of each function parameter declaration (type + name) + + The format of the input file is one C-style function signature per line, no + trailing semicolon. Empty lines are allowed. An empty line is a line that + consists purely of whitespace. Lines that begin with a # are considered + comment lines and are ignored. + + We assume that "int foo(void)" is the same as "int foo()", which is not + true in C where "int foo()" is equivalent to "int foo(...)". Our generated + code is C++, and we do not handle varargs, so this is a case that can be + ignored for now. + + Args: + infile: File object holding a text file of function signatures. + + Returns: + A list of dictionaries, where each dictionary represents one function + signature. + + Raises: + BadSignatureError: A line could not be parsed as a signature. + """ + signatures = [] + for line in infile: + line = line.strip() + if line and line[0] != '#': + m = SIGNATURE_REGEX.match(line) + if m is None: + raise BadSignatureError('Unparsable line: %s' % line) + signatures.append( + {'return_type': m.group('return_type').strip(), + 'name': m.group('name').strip(), + 'params': [arg.strip() for arg in m.group('params').split(',')]}) + return signatures + + +def WriteWindowsDefFile(module_name, signatures, outfile): + """Writes a windows def file to the given output file object. + + The def file format is basically a list of function names. Generation is + simple. After outputting the LIBRARY and EXPORTS lines, print out each + function name, one to a line, preceeded by 2 spaces. + + 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. + outfile: File handle to populate with definitions. + """ + outfile.write('LIBRARY %s\n' % module_name) + outfile.write('EXPORTS\n') + + for sig in signatures: + outfile.write(' %s\n' % sig['name']) + + +def CreateWindowsLib(module_name, signatures, intermediate_dir, outdir_path): + """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. + + 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 = subprocess.call(['lib', '/nologo', '/machine:X86', + '/def:' + def_file_path, + '/out:' + lib_file_path]) + if ret != 0: + raise SubprocessError( + 'Failed creating %s for %s' % (lib_file_path, def_file_path), + ret) + + +class PosixStubWriter(object): + """Creates a file of stub functions for a library that is opened via dlopen. + + Windows provides a function in their compiler known as delay loading, which + effectively generates a set of stub functions for a dynamic library that + delays loading of the dynamic library/resolution of the symbols until one of + the needed functions are accessed. + + In posix, RTLD_LAZY does something similar with DSOs. This is the default + link mode for DSOs. However, even though the symbol is not resolved until + first usage, the DSO must be present at load time of the main binary. + + To simulate the windows delay load procedure, we need to create a set of + stub functions that allow for correct linkage of the main binary, but + dispatch to the dynamically resolved symbol when the module is initialized. + + This class takes a list of function signatures, and generates a set of stub + functions plus initialization code for them. + """ + + def __init__(self, module_name, signatures): + """Initializes PosixStubWriter for this set of signatures and module_name. + + 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. + """ + self.signatures = signatures + self.module_name = module_name + + @classmethod + def CStyleIdentifier(cls, identifier): + """Generates a C style identifier. + + The module_name has all invalid identifier characters removed (anything + that's not [_a-zA-Z0-9]) and is run through string.capwords to try + and approximate camel case. + + Args: + identifier: The string with the module name to turn to C-style. + + Returns: + A string that can be used as part of a C identifier. + """ + return string.capwords(re.sub(INVALID_C_IDENT_CHARS, '', identifier)) + + @classmethod + def EnumName(cls, module_name): + """Gets the enum name for the module. + + Takes the module name and creates a suitable enum name. The module_name + is munged to be a valid C identifier then prefixed with the string + "kModule" to generate a Google style enum name. + + Args: + module_name: The name of the module to generate an enum name for. + + Returns: + A string with the name of the enum value representing this module. + """ + return 'kModule%s' % PosixStubWriter.CStyleIdentifier(module_name) + + @classmethod + def IsInitializedName(cls, module_name): + """Gets the name of function that checks initialization of this module. + + The name is in the format IsModuleInitialized. Where "Module" is replaced + with the module name, munged to be a valid C identifier. + + Args: + module_name: The name of the module to generate the function name for. + + Returns: + A string with the name of the initialization check function. + """ + return 'Is%sInitialized' % PosixStubWriter.CStyleIdentifier(module_name) + + @classmethod + def InitializeModuleName(cls, module_name): + """Gets the name of the function that initializes this module. + + The name is in the format InitializeModule. Where "Module" is replaced + with the module name, munged to be a valid C identifier. + + Args: + module_name: The name of the module to generate the function name for. + + Returns: + A string with the name of the initialization function. + """ + return 'Initialize%s' % PosixStubWriter.CStyleIdentifier(module_name) + + @classmethod + def UninitializeModuleName(cls, module_name): + """Gets the name of the function that uninitializes this module. + + The name is in the format UninitializeModule. Where "Module" is replaced + with the module name, munged to be a valid C identifier. + + Args: + module_name: The name of the module to generate the function name for. + + Returns: + A string with the name of the uninitialization function. + """ + return 'Uninitialize%s' % PosixStubWriter.CStyleIdentifier(module_name) + + @classmethod + def StubFunctionPointer(cls, signature): + """Generates a function pointer declaration for the given signature. + + Args: + signature: A signature hash, as produced by ParseSignatures, + representating the function signature. + + Returns: + A string with the declaration of the function pointer for the signature. + """ + return 'static %s (*%s_ptr)(%s) = NULL;' % (signature['return_type'], + signature['name'], + ', '.join(signature['params'])) + + @classmethod + def StubFunction(cls, signature): + """Generates a stub function definition for the given signature. + + The function definitions are created with __attribute__((weak)) so that + they may be overridden by a real static link or mock versions to be used + when testing. + + Args: + signature: A signature hash, as produced by ParseSignatures, + representating the function signature. + + Returns: + A string with the stub function definition. + """ + return_prefix = '' + if signature['return_type'] != 'void': + return_prefix = 'return ' + + # Generate the argument list. + arguments = [re.split('[\*& ]', arg)[-1].strip() for arg in + signature['params']] + arg_list = ', '.join(arguments) + if arg_list == 'void': + arg_list = '' + + return STUB_FUNCTION_DEFINITION % { + 'return_type': signature['return_type'], + 'name': signature['name'], + 'params': ', '.join(signature['params']), + 'return_prefix': return_prefix, + 'arg_list': arg_list} + + @classmethod + def WriteImplementationPreamble(cls, header_path, outfile): + """Write the necessary includes for the implementation file. + + Args: + header_path: The path to the header file. + outfile: The file handle to populate. + """ + outfile.write(IMPLEMENTATION_PREAMBLE % header_path) + + @classmethod + def WriteUmbrellaInitializer(cls, module_names, namespace, outfile): + """Writes a single function that will open + initialize each module. + + This intializer will take in an stl map of that lists the correct + dlopen target for each module. The map type is + std::map> which matches one module + to a list of paths to try in dlopen. + + This function is an all-or-nothing function. If any module fails to load, + all other modules are dlclosed, and the function returns. Though it is + not enforced, this function should only be called once. + + Args: + module_names: A list with the names of the modules in this stub file. + namespace: The namespace these functions should be in. + outfile: The file handle to populate with pointer definitions. + """ + outfile.write(UMBRELLA_INITIALIZER_START % namespace) + outfile.write(UMBRELLA_INITIALIZER_CLEANUP_FUNCTION) + + # Create the initializaiton function that calls all module initializers, + # checks if they succeeded, and backs out module loads on an error. + outfile.write(UMBRELLA_INITIALIZER_INITIALIZE_FUNCTION_START) + outfile.write( + '\n // Initialize each module if we have not already failed.\n') + for module in module_names: + outfile.write(' %s(opened_libraries[%s]);\n' % + (PosixStubWriter.InitializeModuleName(module), + PosixStubWriter.EnumName(module))) + outfile.write('\n') + + # Output code to check the initialization status, clean up on error. + initializer_checks = ['!%s()' % PosixStubWriter.IsInitializedName(name) + for name in module_names] + uninitializers = ['%s()' % PosixStubWriter.UninitializeModuleName(name) + for name in module_names] + outfile.write(UMBRELLA_INITIALIZER_CHECK_AND_CLEANUP % { + 'conditional': ' ||\n '.join(initializer_checks), + 'uninitializers': ';\n '.join(uninitializers)}) + outfile.write('\n} // namespace %s\n' % namespace) + + @classmethod + def WriteHeaderContents(cls, module_names, namespace, header_guard, outfile): + """Writes a header file for the stub file generated for module_names. + + The header file exposes the following: + 1) An enum, StubModules, listing with an entry for each enum. + 2) A typedef for a StubPathMap allowing for specification of paths to + search for each module. + 3) The IsInitialized/Initialize/Uninitialize functions for each module. + 4) An umbrella initialize function for all modules. + + Args: + module_names: A list with the names of each module in this stub file. + namespace: The namespace these functions should be in. + header_guard: The macro to use as our header guard. + outfile: The output handle to populate. + """ + outfile.write(STUB_HEADER_PREAMBLE % + {'guard_name': header_guard, 'namespace': namespace}) + + # Generate the Initializer protoypes for each module. + outfile.write('// Individual module initializer functions.\n') + for name in module_names: + outfile.write(MODULE_FUNCTION_PROTOTYPES % { + 'is_initialized': PosixStubWriter.IsInitializedName(name), + 'initialize': PosixStubWriter.InitializeModuleName(name), + 'uninitialize': PosixStubWriter.UninitializeModuleName(name)}) + + # Generate the enum for umbrella initializer. + outfile.write(UMBRELLA_ENUM_START) + outfile.write(' %s = 0,\n' % PosixStubWriter.EnumName(module_names[0])) + for name in module_names[1:]: + outfile.write(' %s,\n' % PosixStubWriter.EnumName(name)) + outfile.write(UMBRELLA_ENUM_END) + + outfile.write(UMBRELLA_INITIALIZER_PROTOTYPE) + outfile.write(STUB_HEADER_CLOSER % { + 'namespace': namespace, 'guard_name': + header_guard}) + + def WriteImplementationContents(self, namespace, outfile): + """Given a file handle, write out the stub definitions for this module. + + Args: + namespace: The namespace these functions should be in. + outfile: The file handle to populate. + """ + outfile.write(IMPLEMENTATION_CONTENTS_C_START) + self.WriteFunctionPointers(outfile) + self.WriteStubFunctions(outfile) + outfile.write(IMPLEMENTATION_CONTENTS_C_END) + + outfile.write(NAMESPACE_START % namespace) + self.WriteModuleInitializeFunctions(outfile) + outfile.write(NAMESPACE_END % namespace) + + def WriteFunctionPointers(self, outfile): + """Write the function pointer declarations needed by the stubs. + + We need function pointers to hold the actual location of the function + implementation returned by dlsym. This function outputs a pointer + definition for each signature in the module. + + Pointers will be named with the following pattern "FuntionName_ptr". + + Args: + outfile: The file handle to populate with pointer definitions. + """ + outfile.write(FUNCTION_POINTER_SECTION_COMMENT) + + for sig in self.signatures: + outfile.write('%s\n' % PosixStubWriter.StubFunctionPointer(sig)) + outfile.write('\n') + + def WriteStubFunctions(self, outfile): + """Write the function stubs to handle dispatching to real implementations. + + Functions that have a return type other than void will look as follows: + + ReturnType FunctionName(A a) { + return FunctionName_ptr(a); + } + + Functions with a return type of void will look as follows: + + void FunctionName(A a) { + FunctionName_ptr(a); + } + + Args: + outfile: The file handle to populate. + """ + outfile.write('// Stubs that dispatch to the real implementations.\n') + for sig in self.signatures: + outfile.write('%s\n' % PosixStubWriter.StubFunction(sig)) + + def WriteModuleInitializeFunctions(self, outfile): + """Write functions to initialize/query initlialization of the module. + + This creates 2 functions IsModuleInitialized and InitializeModule where + "Module" is replaced with the module name, first letter capitalized. + + The InitializeModule function takes a handle that is retrieved from dlopen + and attempts to assign each function pointer above via dlsym. + + The IsModuleInitialized returns true if none of the required functions + pointers are NULL. + + Args: + outfile: The file handle to populate. + """ + ptr_names = ['%s_ptr' % sig['name'] for sig in self.signatures] + + # Construct the conditional expression to check the initialization of + # all the function pointers above. It should generate a conjuntion + # with each pointer on its own line, indented by six spaces to match + # the indentation level of MODULE_INITIALIZATION_CHECK_FUNCTION. + initialization_conditional = ' &&\n '.join(ptr_names) + + outfile.write(MODULE_INITIALIZATION_CHECK_FUNCTION % ( + PosixStubWriter.IsInitializedName(self.module_name), + initialization_conditional)) + + # Create function that initializes the module. + outfile.write(MODULE_INITIALIZE_START % + PosixStubWriter.InitializeModuleName(self.module_name)) + for sig in self.signatures: + outfile.write(STUB_POINTER_INITIALIZER % { + 'name': sig['name'], + 'return_type': sig['return_type'], + 'parameters': ', '.join(sig['params'])}) + outfile.write(MODULE_INITIALIZE_END) + + # Create function that uninitializes the module (sets all pointers to + # NULL). + outfile.write(MODULE_UNINITIALIZE_START % + PosixStubWriter.UninitializeModuleName(self.module_name)) + for sig in self.signatures: + outfile.write(' %s_ptr = NULL;\n' % sig['name']) + outfile.write(MODULE_UNINITIALIZE_END) + + +def CreateOptionParser(): + """Creates an OptionParser for the configuration options of script. + + Returns: + A OptionParser object. + """ + parser = optparse.OptionParser(usage='usage: %prog [options] input') + parser.add_option('-o', + '--output', + dest='out_dir', + default=None, + help='Output location.') + parser.add_option('-i', + '--intermediate_dir', + dest='intermediate_dir', + default=None, + help='Locaiton of intermediate files.') + parser.add_option('-t', + '--type', + dest='type', + default=None, + help=('Type of file. Either "%s" or "%s"' % + (FILE_TYPE_POSIX_STUB, FILE_TYPE_WIN))) + parser.add_option('-s', + '--stubfile_name', + dest='stubfile_name', + default=None, + help=('Name of posix_stubs output file. Ignored for ' + '%s type.' % FILE_TYPE_WIN)) + 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)) + 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)) + 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]: + parser.error('Invalid output file type') + + if options.type == FILE_TYPE_POSIX_STUB: + if options.stubfile_name is None: + parser.error('Output file name need 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) + + return options, args + + +def CreateOutputDirectories(options): + """Creates the intermediate and final output directories. + + Given the parsed options, create the intermediate and final output + directories if they do not exist. Returns the paths to both directories + as a pair. + + Args: + options: An OptionParser.OptionValues object with the parsed options. + + Returns: + The pair (out_dir, intermediate_dir), both of which are strings. + """ + out_dir = os.path.normpath(options.out_dir) + intermediate_dir = os.path.normpath(options.intermediate_dir) + if intermediate_dir is None: + intermediate_dir = out_dir + + if not os.path.exists(out_dir): + os.makedirs(out_dir) + if not os.path.exists(intermediate_dir): + os.makedirs(intermediate_dir) + + return out_dir, intermediate_dir + + +def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir): + """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. + """ + 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) + finally: + infile.close() + + +def CreatePosixStubsForSigFiles(sig_files, stub_name, out_dir, + intermediate_dir, path_from_source, + extra_stub_header): + """Create a posix stub library with a module for each signature file. + + Args: + sig_files: Array of Strings with the paths to each signature file. + stub_name: String with the basename of the generated stub file. + out_dir: String holding path to directory for the .h files. + intermediate_dir: String holding path to directory for the .cc files. + path_from_source: String with relative path of generated files from the + project root. + extra_stub_header: String with path to file of extra lines to insert + into the generated header for the stub library. + """ + header_base_name = stub_name + '.h' + header_path = os.path.join(out_dir, header_base_name) + impl_path = os.path.join(intermediate_dir, stub_name + '.cc') + + module_names = [ExtractModuleName(path) for path in sig_files] + namespace = path_from_source.replace('/', '_').lower() + header_guard = '%s_' % namespace.upper() + header_include_path = os.path.join(path_from_source, header_base_name) + + # First create the implementation file. + impl_file = open(impl_path, 'w') + try: + # Open the file, and create the preamble which consists of a file + # header plus any necessary includes. + PosixStubWriter.WriteImplementationPreamble(header_include_path, + impl_file) + if extra_stub_header is not None: + extra_header_file = open(extra_stub_header, 'r') + try: + impl_file.write('\n') + for line in extra_header_file: + impl_file.write(line) + impl_file.write('\n') + finally: + extra_header_file.close() + + # For each signature file, generate the stub population functions + # for that file. Each file represents one module. + for input_path in sig_files: + name = ExtractModuleName(input_path) + infile = open(input_path, 'r') + try: + signatures = ParseSignatures(infile) + finally: + infile.close() + writer = PosixStubWriter(name, signatures) + writer.WriteImplementationContents(namespace, impl_file) + + # Lastly, output the umbrella function for the file. + PosixStubWriter.WriteUmbrellaInitializer(module_names, namespace, + impl_file) + finally: + impl_file.close() + + # Then create the associated header file. + header_file = open(header_path, 'w') + try: + 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) + elif options.type == FILE_TYPE_POSIX_STUB: + CreatePosixStubsForSigFiles(args, options.stubfile_name, out_dir, + intermediate_dir, options.path_from_source, + options.extra_stub_header) + + +if __name__ == '__main__': + main() diff --git a/tools/generate_stubs/generate_stubs_unittest.py b/tools/generate_stubs/generate_stubs_unittest.py new file mode 100755 index 0000000..cfab996 --- /dev/null +++ b/tools/generate_stubs/generate_stubs_unittest.py @@ -0,0 +1,283 @@ +#!/usr/bin/python +# Copyright (c) 2009 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. + +"""Unittest for the generate_stubs.py. + +Since generate_stubs.py is a code generator, it is hard to do a very good +test. Instead of creating a golden-file test, which might be flakey, this +test elects instead to verify that various components "exist" within the +generated file as a sanity check. In particular, there is a simple hit +test to make sure that umbrella functions, etc., do try and include every +function they are responsible for invoking. Missing an invocation is quite +easily missed. + +There is no attempt to verify ordering of different components, or whether +or not those components are going to parse incorrectly because of prior +errors or positioning. Most of that should be caught really fast anyways +during any attempt to use a badly behaving script. +""" + +import re +import StringIO +import unittest +import generate_stubs as gs + + +def _MakeSignature(return_type, name, params): + return {'return_type': return_type, + 'name': name, + 'params': params} + + +SIMPLE_SIGNATURES = [ + ('int foo(int a)', _MakeSignature('int', 'foo', ['int a'])), + ('int bar(int a, double b)', _MakeSignature('int', 'bar', + ['int a', 'double b'])), + ('int baz(void)', _MakeSignature('int', 'baz', ['void'])), + ('void quux(void)', _MakeSignature('void', 'quux', ['void'])), + ('void waldo(void);', _MakeSignature('void', 'waldo', ['void'])), + ('int corge(void);', _MakeSignature('int', 'corge', ['void'])), + ] + +TRICKY_SIGNATURES = [ + ('const struct name *foo(int a, struct Test* b); ', + _MakeSignature('const struct name *', + 'foo', + ['int a', 'struct Test* b'])), + ('const struct name &foo(int a, struct Test* b);', + _MakeSignature('const struct name &', + 'foo', + ['int a', 'struct Test* b'])), + ('const struct name &_foo(int a, struct Test* b);', + _MakeSignature('const struct name &', + '_foo', + ['int a', 'struct Test* b'])), + ('struct name const * const _foo(int a, struct Test* b) ' + '__attribute__((inline));', + _MakeSignature('struct name const * const', + '_foo', + ['int a', 'struct Test* b'])) + ] + +INVALID_SIGNATURES = ['I am bad', 'Seriously bad(', ';;;'] + + +class GenerateStubModuleFunctionsUnittest(unittest.TestCase): + def testExtractModuleName(self): + self.assertEqual('somefile-2', gs.ExtractModuleName('somefile-2.ext')) + + def testParseSignatures_EmptyFile(self): + # Empty file just generates empty signatures. + infile = StringIO.StringIO() + signatures = gs.ParseSignatures(infile) + self.assertEqual(0, len(signatures)) + + def testParseSignatures_SimpleSignatures(self): + file_contents = '\n'.join([x[0] for x in SIMPLE_SIGNATURES]) + infile = StringIO.StringIO(file_contents) + signatures = gs.ParseSignatures(infile) + self.assertEqual(len(SIMPLE_SIGNATURES), len(signatures)) + + # We assume signatures are in order. + for i in xrange(len(SIMPLE_SIGNATURES)): + self.assertEqual(SIMPLE_SIGNATURES[i][1], signatures[i], + msg='Expected %s\nActual %s\nFor %s' % + (SIMPLE_SIGNATURES[i][1], + signatures[i], + SIMPLE_SIGNATURES[i][0])) + + def testParseSignatures_TrickySignatures(self): + file_contents = '\n'.join([x[0] for x in TRICKY_SIGNATURES]) + infile = StringIO.StringIO(file_contents) + signatures = gs.ParseSignatures(infile) + self.assertEqual(len(TRICKY_SIGNATURES), len(signatures)) + + # We assume signatures are in order. + for i in xrange(len(TRICKY_SIGNATURES)): + self.assertEqual(TRICKY_SIGNATURES[i][1], signatures[i], + msg='Expected %s\nActual %s\nFor %s' % + (TRICKY_SIGNATURES[i][1], + signatures[i], + TRICKY_SIGNATURES[i][0])) + + def testParseSignatures_InvalidSignatures(self): + for i in INVALID_SIGNATURES: + infile = StringIO.StringIO(i) + self.assertRaises(gs.BadSignatureError, gs.ParseSignatures, infile) + + def testParseSignatures_CommentsIgnored(self): + my_sigs = [] + my_sigs.append('# a comment') + my_sigs.append(SIMPLE_SIGNATURES[0][0]) + my_sigs.append('# another comment') + my_sigs.append(SIMPLE_SIGNATURES[0][0]) + my_sigs.append('# a third comment') + my_sigs.append(SIMPLE_SIGNATURES[0][0]) + + file_contents = '\n'.join(my_sigs) + infile = StringIO.StringIO(file_contents) + signatures = gs.ParseSignatures(infile) + self.assertEqual(3, len(signatures)) + + +class WindowsLibUnittest(unittest.TestCase): + def testWriteWindowsDefFile(self): + module_name = 'my_module-1' + signatures = [sig[1] for sig in SIMPLE_SIGNATURES] + outfile = StringIO.StringIO() + gs.WriteWindowsDefFile(module_name, signatures, outfile) + contents = outfile.getvalue() + + # Check that the file header is correct. + self.assertTrue(contents.startswith("""LIBRARY %s +EXPORTS +""" % module_name)) + + # Check that the signatures were exported. + for sig in signatures: + pattern = '\n %s\n' % sig['name'] + self.assertTrue(re.search(pattern, contents), + msg='Expected match of "%s" in %s' % (pattern, contents)) + + +class PosixStubWriterUnittest(unittest.TestCase): + def setUp(self): + self.module_name = 'my_module-1' + self.signatures = [sig[1] for sig in SIMPLE_SIGNATURES] + self.out_dir = 'out_dir' + self.writer = gs.PosixStubWriter(self.module_name, self.signatures) + + def testEnumName(self): + self.assertEqual('kModuleMy_module1', + gs.PosixStubWriter.EnumName(self.module_name)) + + def testIsInitializedName(self): + self.assertEqual('IsMy_module1Initialized', + gs.PosixStubWriter.IsInitializedName(self.module_name)) + + def testInitializeModuleName(self): + self.assertEqual( + 'InitializeMy_module1', + gs.PosixStubWriter.InitializeModuleName(self.module_name)) + + def testUninitializeModuleName(self): + self.assertEqual( + 'UninitializeMy_module1', + gs.PosixStubWriter.UninitializeModuleName(self.module_name)) + + def testStubFunctionPointer(self): + self.assertEqual( + 'static int (*foo_ptr)(int a) = NULL;', + gs.PosixStubWriter.StubFunctionPointer(SIMPLE_SIGNATURES[0][1])) + + def testStubFunction(self): + # Test for a signature with a return value and a parameter. + self.assertEqual("""extern int foo(int a) __attribute__((weak)); +int foo(int a) { + return foo_ptr(a); +}""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[0][1])) + + # Test for a signature with a void return value and no parameters. + self.assertEqual("""extern void waldo(void) __attribute__((weak)); +void waldo(void) { + waldo_ptr(); +}""", gs.PosixStubWriter.StubFunction(SIMPLE_SIGNATURES[4][1])) + + def testWriteImplemenationContents(self): + outfile = StringIO.StringIO() + self.writer.WriteImplementationContents('my_namespace', outfile) + contents = outfile.getvalue() + + # Verify namespace exists somewhere. + self.assertTrue(contents.find('namespace my_namespace {') != -1) + + # Verify that each signature has an _ptr and a function call in the file. + # Check that the signatures were exported. + for sig in self.signatures: + decl = gs.PosixStubWriter.StubFunctionPointer(sig) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + + # Verify that each signature has an stub function generated for it. + for sig in self.signatures: + decl = gs.PosixStubWriter.StubFunction(sig) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + + # Find module initializer functions. Make sure all 3 exist. + decl = gs.PosixStubWriter.InitializeModuleName(self.module_name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.UninitializeModuleName(self.module_name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.IsInitializedName(self.module_name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + + def testWriteHeaderContents(self): + # Data for header generation. + module_names = ['oneModule', 'twoModule'] + + # Make the header. + outfile = StringIO.StringIO() + self.writer.WriteHeaderContents(module_names, 'my_namespace', 'GUARD_', + outfile) + contents = outfile.getvalue() + + # Check for namespace and header guard. + self.assertTrue(contents.find('namespace my_namespace {') != -1) + self.assertTrue(contents.find('#ifndef GUARD_') != -1) + + # Check for umbrella initializer. + self.assertTrue(contents.find('InitializeStubs(') != -1) + + # Check per-module declarations. + for name in module_names: + # Check for enums. + decl = gs.PosixStubWriter.EnumName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + + # Check for module initializer functions. + decl = gs.PosixStubWriter.IsInitializedName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.InitializeModuleName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.UninitializeModuleName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + + def testWriteUmbrellaInitializer(self): + # Data for header generation. + module_names = ['oneModule', 'twoModule'] + + # Make the header. + outfile = StringIO.StringIO() + self.writer.WriteUmbrellaInitializer(module_names, 'my_namespace', outfile) + contents = outfile.getvalue() + + # Check for umbrella initializer declaration. + self.assertTrue(contents.find('bool InitializeStubs(') != -1) + + # If the umbrella initializer is correctly written, each module will have + # its initializer called, checked, and uninitialized on failure. Sanity + # check that here. + for name in module_names: + # Check for module initializer functions. + decl = gs.PosixStubWriter.IsInitializedName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.InitializeModuleName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + decl = gs.PosixStubWriter.UninitializeModuleName(name) + self.assertTrue(contents.find(decl) != -1, + msg='Expected "%s" in %s' % (decl, contents)) + +if __name__ == '__main__': + unittest.main() -- cgit v1.1