Home | History | Annotate | Download | only in build 
      1 #!/usr/bin/env python
      2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
      3 # Use of this source code is governed by a BSD-style license that can be
      4 # found in the LICENSE file.
      5 
      6 """Compiler version checking tool for gcc
      7 
      8 Print gcc version as XY if you are running gcc X.Y.*.
      9 This is used to tweak build flags for gcc 4.4.
     10 """
     11 
     12 import os
     13 import re
     14 import subprocess
     15 import sys
     16 
     17 
     18 compiler_version_cache = {}  # Map from (compiler, tool) -> version.
     19 
     20 
     21 def Usage(program_name):
     22   print '%s MODE TOOL' % os.path.basename(program_name)
     23   print 'MODE: host or target.'
     24   print 'TOOL: assembler or compiler or linker.'
     25   return 1
     26 
     27 
     28 def ParseArgs(args):
     29   if len(args) != 2:
     30     raise Exception('Invalid number of arguments')
     31   mode = args[0]
     32   tool = args[1]
     33   if mode not in ('host', 'target'):
     34     raise Exception('Invalid mode: %s' % mode)
     35   if tool not in ('assembler', 'compiler', 'linker'):
     36     raise Exception('Invalid tool: %s' % tool)
     37   return mode, tool
     38 
     39 
     40 def GetEnvironFallback(var_list, default):
     41   """Look up an environment variable from a possible list of variable names."""
     42   for var in var_list:
     43     if var in os.environ:
     44       return os.environ[var]
     45   return default
     46 
     47 
     48 def GetVersion(compiler, tool):
     49   tool_output = tool_error = None
     50   cache_key = (compiler, tool)
     51   cached_version = compiler_version_cache.get(cache_key)
     52   if cached_version:
     53     return cached_version
     54   try:
     55     # Note that compiler could be something tricky like "distcc g++".
     56     if tool == "compiler":
     57       compiler = compiler + " -dumpversion"
     58       # 4.6
     59       version_re = re.compile(r"(\d+)\.(\d+)")
     60     elif tool == "assembler":
     61       compiler = compiler + " -Xassembler --version -x assembler -c /dev/null"
     62       # Unmodified: GNU assembler (GNU Binutils) 2.24
     63       # Ubuntu: GNU assembler (GNU Binutils for Ubuntu) 2.22
     64       # Fedora: GNU assembler version 2.23.2
     65       version_re = re.compile(r"^GNU [^ ]+ .* (\d+).(\d+).*?$", re.M)
     66     elif tool == "linker":
     67       compiler = compiler + " -Xlinker --version"
     68       # Using BFD linker
     69       # Unmodified: GNU ld (GNU Binutils) 2.24
     70       # Ubuntu: GNU ld (GNU Binutils for Ubuntu) 2.22
     71       # Fedora: GNU ld version 2.23.2
     72       # Using Gold linker
     73       # Unmodified: GNU gold (GNU Binutils 2.24) 1.11
     74       # Ubuntu: GNU gold (GNU Binutils for Ubuntu 2.22) 1.11
     75       # Fedora: GNU gold (version 2.23.2) 1.11
     76       version_re = re.compile(r"^GNU [^ ]+ .* (\d+).(\d+).*?$", re.M)
     77     else:
     78       raise Exception("Unknown tool %s" % tool)
     79 
     80     # Force the locale to C otherwise the version string could be localized
     81     # making regex matching fail.
     82     env = os.environ.copy()
     83     env["LC_ALL"] = "C"
     84     pipe = subprocess.Popen(compiler, shell=True, env=env,
     85                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     86     tool_output, tool_error = pipe.communicate()
     87     if pipe.returncode:
     88       raise subprocess.CalledProcessError(pipe.returncode, compiler)
     89 
     90     parsed_output = version_re.match(tool_output)
     91     result = parsed_output.group(1) + parsed_output.group(2)
     92     compiler_version_cache[cache_key] = result
     93     return result
     94   except Exception, e:
     95     if tool_error:
     96       sys.stderr.write(tool_error)
     97     print >> sys.stderr, "compiler_version.py failed to execute:", compiler
     98     print >> sys.stderr, e
     99     return ""
    100 
    101 
    102 def main(args):
    103   try:
    104     (mode, tool) = ParseArgs(args[1:])
    105   except Exception, e:
    106     sys.stderr.write(e.message + '\n\n')
    107     return Usage(args[0])
    108 
    109   ret_code, result = ExtractVersion(mode, tool)
    110   if ret_code == 0:
    111     print result
    112   return ret_code
    113 
    114 
    115 def DoMain(args):
    116   """Hook to be called from gyp without starting a separate python
    117   interpreter."""
    118   (mode, tool) = ParseArgs(args)
    119   ret_code, result = ExtractVersion(mode, tool)
    120   if ret_code == 0:
    121     return result
    122   raise Exception("Failed to extract compiler version for args: %s" % args)
    123 
    124 
    125 def ExtractVersion(mode, tool):
    126   # Check if various CXX environment variables exist and use them if they
    127   # exist. The preferences and fallback order is a close approximation of
    128   # GenerateOutputForConfig() in GYP's ninja generator.
    129   # The main difference being not supporting GYP's make_global_settings.
    130   environments = ['CXX_target', 'CXX']
    131   if mode == 'host':
    132     environments = ['CXX_host'] + environments;
    133   compiler = GetEnvironFallback(environments, 'c++')
    134 
    135   if compiler:
    136     compiler_version = GetVersion(compiler, tool)
    137     if compiler_version != "":
    138       return (0, compiler_version)
    139   return (1, None)
    140 
    141 
    142 if __name__ == "__main__":
    143   sys.exit(main(sys.argv))
    144