From 4a1f44115183667a37ecacfccb2b39fe47a1fbd8 Mon Sep 17 00:00:00 2001 From: Alibek Omarov Date: Tue, 28 May 2019 04:13:19 +0300 Subject: [PATCH] waflib: xcompile: Android NDK r19c support --- scripts/waflib/xcompile.py | 200 ++++++++++++++++++++++++++----------- 1 file changed, 143 insertions(+), 57 deletions(-) diff --git a/scripts/waflib/xcompile.py b/scripts/waflib/xcompile.py index 7445025f..c30ec2bf 100644 --- a/scripts/waflib/xcompile.py +++ b/scripts/waflib/xcompile.py @@ -12,6 +12,7 @@ # GNU General Public License for more details. from fwgslib import get_flags_by_compiler +from waflib import Logs import os import sys @@ -25,15 +26,68 @@ import sys # DEST_OS2 DEST_OS # 'android' 'linux' +# This class does support ONLY r10e and r19c NDK class Android: + ctx = None # waf context arch = None toolchain = None api = None toolchain_path = None ndk_home = None + ndk_rev = 0 is_hardfloat = False + clang = False + + def __init__(self, ctx, arch, toolchain, api): + self.ctx = ctx + for i in ['ANDROID_NDK_HOME', 'ANDROID_NDK']: + self.ndk_home = os.getenv(i) + if self.ndk_home != None: + break + + if not self.ndk_home: + conf.fatal('Set ANDROID_NDK_HOME environment variable pointing to the root of Android NDK!') + + # TODO: this were added at some point of NDK development + # but I don't know at which version + # r10e don't have it + source_prop = os.path.join(self.ndk_home, 'source.properties') + if os.path.exists(source_prop): + with open(source_prop) as ndk_props_file: + for line in ndk_props_file.readlines(): + tokens = line.split('=') + trimed_tokens = [token.strip() for token in tokens] + + if 'Pkg.Revision' in trimed_tokens: + self.ndk_rev = int(trimed_tokens[1].split('.')[0]) + else: + self.ndk_rev = 10 + + if self.ndk_rev not in [10, 19]: + ctx.fatal('Unknown NDK revision: {}'.format(self.ndk_rev)) + + self.arch = arch + if self.arch == 'armeabi-v7a-hard': + if self.ndk_rev <= 10: + self.arch = 'armeabi-v7a' # Only armeabi-v7a have hard float ABI + self.is_hardfloat = True + else: + raise Exception('NDK does not support hardfloat ABI') + + self.toolchain = toolchain + + if self.ndk_rev >= 19 or 'clang' in self.toolchain: + self.clang = True + + if self.is_arm64() or self.is_amd64() and self.api < 21: + Logs.warn('API level for 64-bit target automatically was set to 21') + self.api = 21 + elif self.ndk_rev >= 19 and self.api < 16: + Logs.warn('API level automatically was set to 16 due to NDK support') + self.api = 16 + else: self.api = api + self.toolchain_path = self.gen_toolchain_path() - # TODO: New Android NDK support? # TODO: Crystax support? # TODO: Support for everything else than linux-x86_64? # TODO: Determine if I actually need to implement listed above @@ -48,7 +102,13 @@ class Android: ''' Checks if selected architecture is **32-bit** or **64-bit** x86 ''' - return self.arch.startswith('x86') + return self.arch == 'x86' + + def is_amd64(self): + ''' + Checks if selected architecture is **64-bit** x86 + ''' + return self.arch == 'x86_64' def is_arm64(self): ''' @@ -60,66 +120,80 @@ class Android: ''' Checks if selected toolchain is Clang (TODO) ''' - return self.toolchain.startswith('clang') + return self.clang def is_hardfp(self): return self.is_hardfloat def gen_toolchain_path(self): path = 'toolchains' + + if sys.platform.startswith('linux'): + toolchain_host = 'linux' + elif sys.platform.startswith('darwin'): + toolchain_host = 'darwin' + elif sys.platform.startswith('win32') or sys.platform.startswith('cygwin'): + toolchain_host = 'windows' + else: raise Exception('Unsupported by NDK host platform') + + toolchain_host += '-' + + # Assuming we are building on x86 + if sys.maxsize > 2**32: + toolchain_host += 'x86_64' + else: toolchain_host += 'x86' + if self.is_clang(): - raise Exception('Clang is not supported yet') - else: + if self.ndk_rev < 19: + raise Exception('Clang is not supported for this NDK') + + toolchain_folder = 'llvm' + if self.is_x86(): + triplet = 'i686-linux-android{}-'.format(self.api) + elif self.is_arm(): + triplet = 'armv7a-linux-androideabi{}-'.format(self.api) + else: + triplet = self.arch + '-linux-android{}-'.format(self.api) + else: + if self.is_x86() or self.is_amd64(): toolchain_folder = self.arch + '-' + self.toolchain elif self.is_arm(): toolchain_folder = 'arm-linux-androideabi-' + self.toolchain else: toolchain_folder = self.arch + '-linux-android-' + self.toolchain - if sys.platform.startswith('linux'): - toolchain_host = 'linux' - elif sys.platform.startswith('darwin'): - toolchain_host = 'darwin' - elif sys.platform.startswith('win32') or sys.platform.startswith('cygwin'): - toolchain_host = 'windows' - else: raise Exception('Unsupported by NDK host platform') - - toolchain_host += '-' - - # Assuming we are building on x86 - if sys.maxsize > 2**32: - toolchain_host += 'x86_64' - else: toolchain_host += 'x86' - - if self.arch == 'x86': + if self.is_x86(): triplet = 'i686-linux-android-' elif self.is_arm(): triplet = 'arm-linux-androideabi-' else: triplet = self.arch + '-linux-android-' - return os.path.join(path, toolchain_folder, 'prebuilt', toolchain_host, 'bin', triplet) + return os.path.join(path, toolchain_folder, 'prebuilt', toolchain_host, 'bin', triplet) def cc(self): - return os.path.abspath(os.path.join(self.ndk_home, self.toolchain_path + 'gcc')) + return os.path.abspath(os.path.join(self.ndk_home, self.toolchain_path + ('clang' if self.is_clang() else 'gcc'))) def cxx(self): - return os.path.abspath(os.path.join(self.ndk_home, self.toolchain_path + 'g++')) + return os.path.abspath(os.path.join(self.ndk_home, self.toolchain_path + ('clang++' if self.is_clang() else 'g++'))) def system_stl(self): # TODO: proper STL support return os.path.abspath(os.path.join(self.ndk_home, 'sources', 'cxx-stl', 'system', 'include')) def sysroot(self): - arch = self.arch - if self.is_arm(): - arch = 'arm' - elif self.is_arm64(): - arch = 'arm64' - path = 'platforms/android-{0}/arch-{1}'.format(self.api, arch) + if self.ndk_rev >= 19: + return os.path.abspath(os.path.join(self.ndk_home, 'sysroot')) + else: + arch = self.arch + if self.is_arm(): + arch = 'arm' + elif self.is_arm64(): + arch = 'arm64' + path = 'platforms/android-{}/arch-{}'.format(self.api, arch) - return os.path.abspath(os.path.join(self.ndk_home, path)) + return os.path.abspath(os.path.join(self.ndk_home, path)) def cflags(self): cflags = ['--sysroot={0}'.format(self.sysroot()), '-DANDROID', '-D__ANDROID__'] @@ -127,7 +201,9 @@ class Android: if self.is_arm(): if self.arch == 'armeabi-v7a': # ARMv7 support - cflags += ['-mthumb', '-mfpu=neon', '-mcpu=cortex-a9', '-mvectorize-with-neon-quad', '-DHAVE_EFFICIENT_UNALIGNED_ACCESS', '-DVECTORIZE_SINCOS'] + cflags += ['-mthumb', '-mfpu=neon', '-mcpu=cortex-a9', '-DHAVE_EFFICIENT_UNALIGNED_ACCESS', '-DVECTORIZE_SINCOS'] + if not self.is_clang(): + cflags += [ '-mvectorize-with-neon-quad' ] if self.is_hardfloat: cflags += ['-D_NDK_MATH_NO_SOFTFP=1', '-mhard-float', '-mfloat-abi=hard', '-DLOAD_HARDFP', '-DSOFTFP_LINK'] else: @@ -155,16 +231,6 @@ class Android: ldflags += ['-march=armv5te'] return ldflags - def __init__(self, ndk_home, arch, toolchain, api): - self.ndk_home = ndk_home - self.arch = arch - if self.arch == 'armeabi-v7a-hard': - self.arch = 'armeabi-v7a' # Only armeabi-v7a have hard float ABI - self.is_hardfloat = True - self.toolchain = toolchain - self.api = api - self.toolchain_path = self.gen_toolchain_path() - def options(opt): android = opt.add_option_group('Android options') android.add_option('--android', action='store', dest='ANDROID_OPTS', default=None, @@ -172,14 +238,6 @@ def options(opt): def configure(conf): if conf.options.ANDROID_OPTS: - for i in ['ANDROID_NDK_HOME', 'ANDROID_NDK']: - android_ndk_path = os.getenv(i) - if android_ndk_path != None: - break - - if not android_ndk_path: - conf.fatal('Set ANDROID_NDK_HOME environment variable pointing to the root of Android NDK!') - values = conf.options.ANDROID_OPTS.split(',') if len(values) != 3: conf.fatal('Invalid --android paramater value!') @@ -187,9 +245,10 @@ def configure(conf): valid_archs = ['x86', 'x86_64', 'armeabi', 'armeabi-v7a', 'armeabi-v7a-hard', 'aarch64', 'mipsel', 'mips64el'] if values[0] not in valid_archs: - conf.fatal('Unknown arch: {0}. Supported: {1}'.format(values[0], ', '.join(valid_archs))) + conf.fatal('Unknown arch: {}. Supported: {}'.format(values[0], ', '.join(valid_archs))) - android = Android(android_ndk_path, values[0], values[1], values[2]) + android = Android(conf, values[0], values[1], int(values[2])) + setattr(conf, 'android', android) conf.environ['CC'] = android.cc() conf.environ['CXX'] = android.cxx() conf.env.CFLAGS += android.cflags() @@ -199,17 +258,44 @@ def configure(conf): conf.env.HAVE_M = True if android.is_hardfp(): - conf.env.LIB_M = [] # HACKHACK: libm_hard will be linked anyway, but it should go last + conf.env.LIB_M = ['m_hard'] else: conf.env.LIB_M = ['m'] - conf.env.PREFIX = '/lib/{0}'.format(android.arch) + conf.env.PREFIX = '/lib/{}'.format(android.arch) - conf.msg('Selected Android NDK', android_ndk_path) + conf.msg('Selected Android NDK', '{}, version: {}'.format(android.ndk_home, android.ndk_rev)) # no need to print C/C++ compiler, as it would be printed by compiler_c/cxx - conf.msg('... C/C++ flags', ' '.join(android.cflags()).replace(android_ndk_path, '$NDK')) - conf.msg('... linker flags', ' '.join(android.ldflags()).replace(android_ndk_path, '$NDK')) + conf.msg('... C/C++ flags', ' '.join(android.cflags()).replace(android.ndk_home, '$NDK')) + conf.msg('... link flags', ' '.join(android.linkflags()).replace(android.ndk_home, '$NDK')) + conf.msg('... ld flags', ' '.join(android.ldflags()).replace(android.ndk_home, '$NDK')) # conf.env.ANDROID_OPTS = android conf.env.DEST_OS2 = 'android' # else: # conf.load('compiler_c compiler_cxx') # Use host compiler :) + +def post_compiler_cxx_configure(conf): + if conf.options.ANDROID_OPTS: + if conf.android.ndk_rev >= 19: + conf.env.CXXFLAGS_cxxshlib += ['-static-libstdc++'] + conf.env.LDFLAGS_cxxshlib += ['-static-libstdc++'] + return + +def post_compiler_c_configure(conf): + return + +from waflib.Tools import compiler_cxx, compiler_c + +compiler_cxx_configure = getattr(compiler_cxx, 'configure') +compiler_c_configure = getattr(compiler_c, 'configure') + +def patch_compiler_cxx_configure(conf): + compiler_cxx_configure(conf) + post_compiler_cxx_configure(conf) + +def patch_compiler_c_configure(conf): + compiler_c_configure(conf) + post_compiler_c_configure(conf) + +setattr(compiler_cxx, 'configure', patch_compiler_cxx_configure) +setattr(compiler_c, 'configure', patch_compiler_c_configure)