| #!/usr/bin/env python |
| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Compiler version checking tool for gcc |
| |
| Print gcc version as XY if you are running gcc X.Y.*. |
| This is used to tweak build flags for gcc 4.4. |
| """ |
| |
| import os |
| import re |
| import subprocess |
| import sys |
| |
| |
| compiler_version_cache = {} # Map from (compiler, tool) -> version. |
| |
| |
| def Usage(program_name): |
| print '%s MODE TOOL' % os.path.basename(program_name) |
| print 'MODE: host or target.' |
| print 'TOOL: assembler or compiler or linker.' |
| return 1 |
| |
| |
| def ParseArgs(args): |
| if len(args) != 2: |
| raise Exception('Invalid number of arguments') |
| mode = args[0] |
| tool = args[1] |
| if mode not in ('host', 'target'): |
| raise Exception('Invalid mode: %s' % mode) |
| if tool not in ('assembler',): |
| raise Exception('Invalid tool: %s' % tool) |
| return mode, tool |
| |
| |
| def GetEnvironFallback(var_list, default): |
| """Look up an environment variable from a possible list of variable names.""" |
| for var in var_list: |
| if var in os.environ: |
| return os.environ[var] |
| return default |
| |
| |
| def GetVersion(compiler, tool): |
| tool_output = tool_error = None |
| cache_key = (compiler, tool) |
| cached_version = compiler_version_cache.get(cache_key) |
| if cached_version: |
| return cached_version |
| try: |
| # Note that compiler could be something tricky like "distcc g++". |
| if tool == "assembler": |
| compiler = compiler + " -Xassembler --version -x assembler -c /dev/null" |
| # Unmodified: GNU assembler (GNU Binutils) 2.24 |
| # Ubuntu: GNU assembler (GNU Binutils for Ubuntu) 2.22 |
| # Fedora: GNU assembler version 2.23.2 |
| version_re = re.compile(r"^GNU [^ ]+ .* (\d+).(\d+).*?$", re.M) |
| else: |
| raise Exception("Unknown tool %s" % tool) |
| |
| # Force the locale to C otherwise the version string could be localized |
| # making regex matching fail. |
| env = os.environ.copy() |
| env["LC_ALL"] = "C" |
| pipe = subprocess.Popen(compiler, shell=True, env=env, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
| tool_output, tool_error = pipe.communicate() |
| if pipe.returncode: |
| raise subprocess.CalledProcessError(pipe.returncode, compiler) |
| |
| parsed_output = version_re.match(tool_output) |
| result = parsed_output.group(1) + parsed_output.group(2) |
| compiler_version_cache[cache_key] = result |
| return result |
| except Exception, e: |
| if tool_error: |
| sys.stderr.write(tool_error) |
| print >> sys.stderr, "compiler_version.py failed to execute:", compiler |
| print >> sys.stderr, e |
| return "" |
| |
| |
| def main(args): |
| try: |
| (mode, tool) = ParseArgs(args[1:]) |
| except Exception, e: |
| sys.stderr.write(e.message + '\n\n') |
| return Usage(args[0]) |
| |
| ret_code, result = ExtractVersion(mode, tool) |
| if ret_code == 0: |
| print result |
| return ret_code |
| |
| |
| def DoMain(args): |
| """Hook to be called from gyp without starting a separate python |
| interpreter.""" |
| (mode, tool) = ParseArgs(args) |
| ret_code, result = ExtractVersion(mode, tool) |
| if ret_code == 0: |
| return result |
| raise Exception("Failed to extract compiler version for args: %s" % args) |
| |
| |
| def ExtractVersion(mode, tool): |
| # Check if various CXX environment variables exist and use them if they |
| # exist. The preferences and fallback order is a close approximation of |
| # GenerateOutputForConfig() in GYP's ninja generator. |
| # The main difference being not supporting GYP's make_global_settings. |
| environments = ['CXX_target', 'CXX'] |
| if mode == 'host': |
| environments = ['CXX_host'] + environments; |
| compiler = GetEnvironFallback(environments, 'c++') |
| |
| if compiler: |
| compiler_version = GetVersion(compiler, tool) |
| if compiler_version != "": |
| return (0, compiler_version) |
| return (1, None) |
| |
| |
| if __name__ == "__main__": |
| sys.exit(main(sys.argv)) |