diff options
Diffstat (limited to 'third_party/gpus/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc')
-rwxr-xr-x | third_party/gpus/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc | 316 |
1 files changed, 316 insertions, 0 deletions
diff --git a/third_party/gpus/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc b/third_party/gpus/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc new file mode 100755 index 0000000000..0f419a8b61 --- /dev/null +++ b/third_party/gpus/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc @@ -0,0 +1,316 @@ +#!/usr/bin/env python2 + +"""Crosstool wrapper for compiling CUDA programs. + +SYNOPSIS: + crosstool_wrapper_is_not_gcc [options passed in by cc_library() + or cc_binary() rule] + +DESCRIPTION: + This script is expected to be called by the cc_library() or cc_binary() bazel + rules. When the option "-x cuda" is present in the list of arguments passed + to this script, it invokes the nvcc CUDA compiler. Most arguments are passed + as is as a string to --compiler-options of nvcc. When "-x cuda" is not + present, this wrapper invokes hybrid_driver_is_not_gcc with the input + arguments as is. + +NOTES: + Changes to the contents of this file must be propagated from + //third_party/gpus/crosstool/crosstool_wrapper_is_not_gcc to + //third_party/gpus/crosstool/v*/*/clang/bin/crosstool_wrapper_is_not_gcc +""" + +__author__ = 'keveman@google.com (Manjunath Kudlur)' + +from argparse import ArgumentParser +import os +import subprocess +import re +import sys +import pipes + +CURRENT_DIR = os.path.dirname(sys.argv[0]) +CPU_COMPILER = ('/usr/bin/gcc') +NVCC_PATH = CURRENT_DIR + '/../../../cuda/bin/nvcc' +GCC_HOST_COMPILER_PATH = ('/usr/bin/gcc') +LLVM_HOST_COMPILER_PATH = ('/usr/bin/gcc') +PREFIX_DIR = os.path.dirname(GCC_HOST_COMPILER_PATH) + + +def Log(s): + print 'gpus/crosstool: {0}'.format(s) + + +def GetOptionValue(argv, option): + """Extract the list of values for option from the argv list. + + Args: + argv: A list of strings, possibly the argv passed to main(). + option: The option whose value to extract, without the leading '-'. + + Returns: + A list of values, either directly following the option, + (eg., -opt val1 val2) or values collected from multiple occurrences of + the option (eg., -opt val1 -opt val2). + """ + + parser = ArgumentParser() + parser.add_argument('-' + option, nargs='*', action='append') + args, _ = parser.parse_known_args(argv) + if not args or not vars(args)[option]: + return [] + else: + return sum(vars(args)[option], []) + + +def GetHostCompilerOptions(argv): + """Collect the -isystem, -iquote, and --sysroot option values from argv. + + Args: + argv: A list of strings, possibly the argv passed to main(). + + Returns: + The string that can be used as the --compiler-options to nvcc. + """ + + parser = ArgumentParser() + parser.add_argument('-isystem', nargs='*', action='append') + parser.add_argument('-iquote', nargs='*', action='append') + parser.add_argument('--sysroot', nargs=1) + parser.add_argument('-g', nargs='*', action='append') + + args, _ = parser.parse_known_args(argv) + + opts = '' + # This is a temporary workaround for b/12960069. + # NVIDIA is going to fix this in CUDA 6.5, but until then this workaround + # will let us compile Thrust with the cuda crosstool. + # bazel passes all include directories as '-isystem dir' to the crosstool. + # This causes nvcc to think that there are kernel launches from system + # directories (which apparently is not supported by the compiler). This + # workaround changes '-isystem third_party/gpus/cuda/include' to + # '-iquote third_party/gpus/cuda/include'. + isystem_args = [x for x in args.isystem + if 'third_party/gpus/cuda/include' not in x] + iquote_args = (args.iquote + + [x for x in args.isystem + if 'third_party/gpus/cuda/include' in x]) + # This hack is needed so that we can compile eigen3. We need to include + # third_party/eigen3 with -I. Some eigen file include using the + # include <Eigen/Core> syntax, and -iquote doesn't work for that. + has_eigen = ['third_party/eigen3'] in isystem_args + if has_eigen: + isystem_args.remove(['third_party/eigen3']) + + if isystem_args: + opts += '-isystem ' + ' -isystem '.join(sum(isystem_args, [])) + if iquote_args: + opts += ' -iquote ' + ' -iquote '.join(sum(iquote_args, [])) + if args.g: + opts += ' -g' + ' -g'.join(sum(args.g, [])) + if args.sysroot: + opts += ' --sysroot ' + args.sysroot[0] + if has_eigen: + opts += ' -I third_party/eigen3' + + return opts + +def GetNvccOptions(argv): + """Collect the -nvcc_options values from argv. + + Args: + argv: A list of strings, possibly the argv passed to main(). + + Returns: + The string that can be passed directly to nvcc. + """ + + parser = ArgumentParser() + parser.add_argument('-nvcc_options', nargs='*', action='append') + + args, _ = parser.parse_known_args(argv) + + if args.nvcc_options: + return ' '.join(['--'+a for a in sum(args.nvcc_options, [])]) + return '' + + +def StripAndTransformNvccOptions(argv): + """Strips the -nvcc_options values from argv and transforms define-macros. + + Args: + argv: A list of strings, possibly the argv passed to main(). + + Returns: + A list of strings that can be passed directly to gcudacc. + """ + parser = ArgumentParser() + parser.add_argument('-nvcc_options', nargs='*', action='store') + args, leftover = parser.parse_known_args(argv) + if args.nvcc_options: + for option in args.nvcc_options: + (flag, _, value) = option.partition('=') + if 'define-macro' in flag: + leftover.append('-D' + value) + return leftover + + +def InvokeGcudacc(argv, gcudacc_version, gcudacc_flags, log=False): + """Call gcudacc with arguments assembled from argv. + + Args: + argv: A list of strings, possibly the argv passed to main(). + gcudacc_version: The version of gcudacc; this is a subdirectory name under + the gcudacc bin/ directory. + gcudacc_flags: A list of extra arguments passed just for gcudacc. + log: True if logging is requested. + + Returns: + The return value of calling os.system('gcudacc ' + args) + """ + + gcudacc_cmd = os.path.join(GCUDACC_PATH_BASE, gcudacc_version, 'gcudacc.par') + gcudacc_cmd = ( + gcudacc_cmd + + ' --google_host_compiler={0} '.format(LLVM_HOST_COMPILER_PATH) + + ' '.join(sum(gcudacc_flags, [])) + + ' -- ' + + ' '.join(StripAndTransformNvccOptions(argv))) + if log: Log(gcudacc_cmd) + return os.system(gcudacc_cmd) + + +def InvokeNvcc(argv, log=False): + """Call nvcc with arguments assembled from argv. + + Args: + argv: A list of strings, possibly the argv passed to main(). + log: True if logging is requested. + + Returns: + The return value of calling os.system('nvcc ' + args) + """ + + host_compiler_options = GetHostCompilerOptions(argv) + nvcc_compiler_options = GetNvccOptions(argv) + opt_option = GetOptionValue(argv, 'O') + m_options = GetOptionValue(argv, 'm') + m_options = ''.join([' -m' + m for m in m_options if m in ['32', '64']]) + include_options = GetOptionValue(argv, 'I') + out_file = GetOptionValue(argv, 'o') + depfiles = GetOptionValue(argv, 'MF') + defines = GetOptionValue(argv, 'D') + defines = ''.join([' -D' + define for define in defines]) + undefines = GetOptionValue(argv, 'U') + undefines = ''.join([' -U' + define for define in undefines]) + std_options = GetOptionValue(argv, 'std') + # currently only c++11 is supported by Cuda 7.0 std argument + nvcc_allowed_std_options = ["c++11"] + std_options = ''.join([' -std=' + define + for define in std_options if define in nvcc_allowed_std_options]) + + # The list of source files get passed after the -c option. I don't know of + # any other reliable way to just get the list of source files to be compiled. + src_files = GetOptionValue(argv, 'c') + + if len(src_files) == 0: + return 1 + if len(out_file) != 1: + return 1 + + opt = (' -O2' if (len(opt_option) > 0 and int(opt_option[0]) > 0) + else ' -g -G') + + includes = (' -I ' + ' -I '.join(include_options) + if len(include_options) > 0 + else '') + + # Unfortunately, there are other options that have -c prefix too. + # So allowing only those look like C/C++ files. + src_files = [f for f in src_files if + re.search('\.cpp$|\.cc$|\.c$|\.cxx$|\.C$', f)] + srcs = ' '.join(src_files) + out = ' -o ' + out_file[0] + + nvccopts = ' '.join([ + r'-gencode=arch=compute_35,\"code=sm_35,compute_35\"', + r'-gencode=arch=compute_52,\"code=sm_52,compute_52\"',]) + nvccopts += ' ' + nvcc_compiler_options + nvccopts += undefines + nvccopts += defines + nvccopts += std_options + nvccopts += m_options + + if depfiles: + # Generate the dependency file + depfile = depfiles[0] + cmd = (NVCC_PATH + ' ' + nvccopts + + ' --compiler-options "' + host_compiler_options + '"' + + ' --compiler-bindir=' + GCC_HOST_COMPILER_PATH + + ' -I .' + + ' -x cu ' + includes + ' ' + srcs + ' -M -o ' + depfile) + if log: Log(cmd) + exit_status = os.system(cmd) + if exit_status != 0: + return exit_status + + cmd = (NVCC_PATH + ' ' + nvccopts + + ' --compiler-options "' + host_compiler_options + ' -fPIC"' + + ' --compiler-bindir=' + GCC_HOST_COMPILER_PATH + + ' -I .' + + ' -x cu ' + opt + includes + ' -c ' + srcs + out) + + # TODO(zhengxq): for some reason, 'gcc' needs this help to find 'as'. + # Need to investigate and fix. + cmd = 'PATH=' + PREFIX_DIR + ' ' + cmd + if log: Log(cmd) + return os.system(cmd) + + +def main(): + parser = ArgumentParser() + parser.add_argument('-x', nargs=1) + parser.add_argument('--cuda_log', action='store_true') + parser.add_argument('--use_gcudacc', action='store_true') + parser.add_argument('--gcudacc_version', action='store', default='v8') + parser.add_argument('--gcudacc_flag', nargs='*', action='append', default=[]) + args, leftover = parser.parse_known_args(sys.argv[1:]) + + if args.x and args.x[0] == 'cuda': + if args.cuda_log: Log('-x cuda') + leftover = [pipes.quote(s) for s in leftover] + if args.use_gcudacc: + if args.cuda_log: Log('using gcudacc') + return InvokeGcudacc(argv=leftover, + gcudacc_version=args.gcudacc_version, + gcudacc_flags=args.gcudacc_flag, + log=args.cuda_log) + if args.cuda_log: Log('using nvcc') + return InvokeNvcc(leftover, log=args.cuda_log) + + # Strip our flags before passing through to the CPU compiler for files which + # are not -x cuda. We can't just pass 'leftover' because it also strips -x. + # We not only want to pass -x to the CPU compiler, but also keep it in its + # relative location in the argv list (the compiler is actually sensitive to + # this). + cpu_compiler_flags = [flag for flag in sys.argv[1:] + if not flag.startswith(('--cuda_log', + '--use_gcudacc', + '--gcudacc_version', + '--gcudacc_flag'))] + if args.use_gcudacc: + # This macro is defined for TUs that are not marked with "-x cuda" but are + # built as part of a -config=cuda --use_gcudacc compilation. They are + # compiled with the default CPU compiler. Since the objects built from + # these TUs are later linked with objects that come from gcudacc, some + # parts of the code need to be marked for these special cases. For example, + # some types have to be defined similarly for gcudacc-compiled TUs and + # default CPU compiler-compiled TUs linked with them, but differently when + # nvcc is used. + # TODO(eliben): rename to a more descriptive name. + cpu_compiler_flags.append('-D__GCUDACC_HOST__') + + return subprocess.call([CPU_COMPILER] + cpu_compiler_flags) + +if __name__ == '__main__': + sys.exit(main()) |