waflib: xcompile: Android NDK r19c support

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')
+			if self.ndk_rev < 19:
-		else:
+				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'):
+			if self.is_x86():
-				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':
 				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.ndk_rev >= 19:
-		if self.is_arm():
+			return os.path.abspath(os.path.join(self.ndk_home, 'sysroot'))
-			arch = 'arm'
+		else:
-		elif self.is_arm64():
+			arch = self.arch
-			arch = 'arm64'
+			if self.is_arm():
-		path = 'platforms/android-{0}/arch-{1}'.format(self.api, arch)
+				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('... C/C++ flags', ' '.join(android.cflags()).replace(android.ndk_home, '$NDK'))
-		conf.msg('... linker flags', ' '.join(android.ldflags()).replace(android_ndk_path, '$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)