#!/usr/bin/env python
|
#
|
# Copyright (C) 2017 The Android Open Source Project
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
#
|
# pylint: disable=not-callable, relative-import
|
|
# Note that adding top-level imports is discouraged unless they're guaranteed to
|
# be used. Unnecessary imports eat a measurable number of cycles of this
|
# wrapper.
|
import os
|
import sys
|
|
BISECT_STAGE = os.environ.get('BISECT_STAGE')
|
# We do not need bisect functionality with Goma and clang.
|
# Goma server does not have bisect_driver, so we only import
|
# bisect_driver when needed. See http://b/34862041
|
# We should be careful when doing imports because of Goma.
|
if BISECT_STAGE:
|
import bisect_driver
|
|
DEFAULT_BISECT_DIR = os.path.expanduser('~/ANDROID_BISECT')
|
BISECT_DIR = os.environ.get('BISECT_DIR') or DEFAULT_BISECT_DIR
|
STDERR_REDIRECT_KEY = 'ANDROID_LLVM_STDERR_REDIRECT'
|
PREBUILT_COMPILER_PATH_KEY = 'ANDROID_LLVM_PREBUILT_COMPILER_PATH'
|
DISABLED_WARNINGS_KEY = 'ANDROID_LLVM_FALLBACK_DISABLED_WARNINGS'
|
|
|
def ProcessArgFile(arg_file):
|
import shlex
|
|
args = []
|
# Read in entire file at once and parse as if in shell
|
with open(arg_file, 'rb') as f:
|
args.extend(shlex.split(f.read()))
|
return args
|
|
|
def write_log(path, command, log):
|
import errno
|
import fcntl
|
import time
|
|
with open(path, 'a+') as f:
|
while True:
|
try:
|
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
break
|
except IOError as e:
|
if e.errno == errno.EAGAIN or e.errno == errno.EACCES:
|
time.sleep(0.5)
|
f.write('==================COMMAND:====================\n')
|
f.write(' '.join(command) + '\n\n')
|
f.write(log)
|
f.write('==============================================\n\n')
|
|
|
class CompilerWrapper(object):
|
|
def __init__(self, argv):
|
self.argv0_current = argv[0]
|
self.args = argv[1:]
|
self.execargs = []
|
self.real_compiler = None
|
self.argv0 = None
|
self.append_flags = []
|
self.prepend_flags = []
|
self.custom_flags = {'--gomacc-path': None}
|
|
def set_real_compiler(self):
|
"""Find the real compiler with the absolute path."""
|
compiler_path = os.path.dirname(self.argv0_current)
|
if os.path.islink(__file__):
|
compiler = os.path.basename(os.readlink(__file__))
|
else:
|
compiler = os.path.basename(os.path.abspath(__file__))
|
self.real_compiler = os.path.join(compiler_path, compiler + '.real')
|
self.argv0 = self.real_compiler
|
|
def process_gomacc_command(self):
|
"""Return the gomacc command if '--gomacc-path' is set."""
|
gomacc = self.custom_flags['--gomacc-path']
|
if gomacc and os.path.isfile(gomacc):
|
self.argv0 = gomacc
|
self.execargs += [gomacc]
|
|
def parse_custom_flags(self):
|
i = 0
|
args = []
|
while i < len(self.args):
|
if self.args[i] in self.custom_flags:
|
if i >= len(self.args) - 1:
|
sys.exit('The value of {} is not set.'.format(self.args[i]))
|
self.custom_flags[self.args[i]] = self.args[i + 1]
|
i = i + 2
|
else:
|
args.append(self.args[i])
|
i = i + 1
|
self.args = args
|
|
def add_flags(self):
|
self.args = self.prepend_flags + self.args + self.append_flags
|
|
def prepare_compiler_args(self, enable_fallback=False):
|
self.set_real_compiler()
|
self.parse_custom_flags()
|
# Goma should not be enabled for new prebuilt.
|
if not enable_fallback:
|
self.process_gomacc_command()
|
self.add_flags()
|
self.execargs += [self.real_compiler] + self.args
|
|
def exec_clang_with_fallback(self):
|
import subprocess
|
|
extra_args_begin = len(self.execargs)
|
|
# We only want to pass extra flags to clang and clang++.
|
if os.path.basename(__file__) in ['clang', 'clang++']:
|
# We may introduce some new warnings after rebasing and we need to
|
# disable them before we fix those warnings.
|
disabled_warnings_env = os.environ.get(DISABLED_WARNINGS_KEY, '')
|
disabled_warnings = disabled_warnings_env.split(' ')
|
self.execargs += ['-fno-color-diagnostics'] + disabled_warnings
|
|
p = subprocess.Popen(self.execargs, stderr=subprocess.PIPE)
|
(_, err) = p.communicate()
|
sys.stderr.write(err)
|
if p.returncode != 0:
|
redirect_path = os.environ[STDERR_REDIRECT_KEY]
|
write_log(redirect_path, self.execargs, err)
|
fallback_arg0 = os.path.join(os.environ[PREBUILT_COMPILER_PATH_KEY],
|
os.path.basename(__file__))
|
|
# Delete PREBUILT_COMPILER_PATH_KEY so the fallback doesn't keep
|
# calling itself in case of an error.
|
del os.environ[PREBUILT_COMPILER_PATH_KEY]
|
|
# Strip extra args added (from DISABLED_WARNINGS_KEY) for clang and
|
# clang++ above. They may not be recognized by the fallback clang.
|
self.execargs = self.execargs[:extra_args_begin]
|
|
os.execv(fallback_arg0, [fallback_arg0] + self.execargs[1:])
|
|
def invoke_compiler(self):
|
enable_fallback = PREBUILT_COMPILER_PATH_KEY in os.environ
|
self.prepare_compiler_args(enable_fallback)
|
if enable_fallback:
|
self.exec_clang_with_fallback()
|
else:
|
os.execv(self.argv0, self.execargs)
|
|
def bisect(self):
|
self.prepare_compiler_args()
|
# Handle @file argument syntax with compiler
|
idx = 0
|
# The length of self.execargs can be changed during the @file argument
|
# expansion, so we need to use while loop instead of for loop.
|
while idx < len(self.execargs):
|
if self.execargs[idx][0] == '@':
|
args_in_file = ProcessArgFile(self.execargs[idx][1:])
|
self.execargs = self.execargs[0:idx] + args_in_file +\
|
self.execargs[idx + 1:]
|
# Skip update of idx, since we want to recursively expand
|
# response files.
|
else:
|
idx = idx + 1
|
bisect_driver.bisect_driver(BISECT_STAGE, BISECT_DIR, self.execargs)
|
|
|
def main(argv):
|
cw = CompilerWrapper(argv)
|
if BISECT_STAGE and BISECT_STAGE in bisect_driver.VALID_MODES\
|
and '-o' in argv:
|
cw.bisect()
|
else:
|
cw.invoke_compiler()
|
|
|
if __name__ == '__main__':
|
main(sys.argv)
|
