add waf buildsystem

scripts/continious_upload.sh

@@ -0,0 +1,15 @@
+##################################
+#
+#        GitHub Releases
+#
+##################################
+
+set +x
+
+# Disabled until GitHub sends prereleases to email
+
+wget -O upload.sh "https://raw.githubusercontent.com/FWGS/uploadtool/master/upload.sh"
+chmod +x upload.sh
+
+export GITHUB_TOKEN=$GH_TOKEN
+./upload.sh $*

scripts/waifulib/compiler_optimizations.py

@@ -0,0 +1,164 @@
+# encoding: utf-8
+# compiler_optimizations.py -- main entry point for configuring C/C++ compilers
+# Copyright (C) 2021 a1batross
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+try: from fwgslib import get_flags_by_type, get_flags_by_compiler
+except: from waflib.extras.fwgslib import get_flags_by_type, get_flags_by_compiler
+from waflib.Configure import conf
+from waflib import Logs
+
+'''
+Flags can be overriden and new types can be added
+by importing this as normal Python module
+
+Example:
+#!/usr/bin/env python
+from waflib.extras import compiler_optimizations
+
+compiler_optimizations.VALID_BUILD_TYPES += 'gottagofast'
+compiler_optimizations.CFLAGS['gottagofast'] = {
+	'gcc': ['-Ogentoo']
+}
+'''
+
+VALID_BUILD_TYPES = ['fastnative', 'fast', 'release', 'debug', 'nooptimize', 'sanitize', 'none']
+
+LINKFLAGS = {
+	'common': {
+		'msvc':  ['/DEBUG'], # always create PDB, doesn't affect result binaries
+		'gcc':   ['-Wl,--no-undefined'],
+		'owcc':  ['-Wl,option stack=512k']
+	},
+	'sanitize': {
+		'clang': ['-fsanitize=undefined', '-fsanitize=address'],
+		'gcc':   ['-fsanitize=undefined', '-fsanitize=address'],
+	}
+}
+
+CFLAGS = {
+	'common': {
+		# disable thread-safe local static initialization for C++11 code, as it cause crashes on Windows XP
+		'msvc':    ['/D_USING_V110_SDK71_', '/Zi', '/FS', '/Zc:threadSafeInit-', '/MT'],
+		'clang':   ['-g', '-gdwarf-2', '-fvisibility=hidden'],
+		'gcc':     ['-fvisibility=hidden'],
+		'owcc':	   ['-fno-short-enum', '-ffloat-store', '-g3']
+	},
+	'fast': {
+		'msvc':    ['/O2', '/Oy'],
+		'gcc': {
+			'3':       ['-O3', '-fomit-frame-pointer'],
+			'default': ['-Ofast', '-funsafe-math-optimizations', '-funsafe-loop-optimizations', '-fomit-frame-pointer']
+		},
+		'clang':   ['-Ofast'],
+		'default': ['-O3']
+	},
+	'fastnative': {
+		'msvc':    ['/O2', '/Oy'],
+		'gcc':     ['-Ofast', '-march=native', '-funsafe-math-optimizations', '-funsafe-loop-optimizations', '-fomit-frame-pointer'],
+		'clang':   ['-Ofast', '-march=native'],
+		'default': ['-O3']
+	},
+	'release': {
+		'msvc':    ['/O2'],
+		'owcc':    ['-O3', '-foptimize-sibling-calls', '-fomit-leaf-frame-pointer', '-fomit-frame-pointer', '-fschedule-insns', '-funsafe-math-optimizations', '-funroll-loops', '-frerun-optimizer', '-finline-functions', '-finline-limit=512', '-fguess-branch-probability', '-fno-strict-aliasing', '-floop-optimize'],
+		'default': ['-O0']
+	},
+	'debug': {
+		'msvc':    ['/Od'],
+		'owcc':    ['-O0', '-fno-omit-frame-pointer', '-funwind-tables', '-fno-omit-leaf-frame-pointer'],
+		'default': ['-O0']
+	},
+	'sanitize': {
+		'msvc':    ['/Od', '/RTC1'],
+		'gcc':     ['-Og', '-fsanitize=undefined', '-fsanitize=address'],
+		'clang':   ['-O0', '-fsanitize=undefined', '-fsanitize=address'],
+		'default': ['-O0']
+	},
+	'nooptimize': {
+		'msvc':    ['/Od'],
+		'default': ['-O0']
+	}
+}
+
+LTO_CFLAGS = {
+	'msvc':  ['/GL'],
+	'gcc':   ['-flto'],
+	'clang': ['-flto']
+}
+
+LTO_LINKFLAGS = {
+	'msvc':  ['/LTCG'],
+	'gcc':   ['-flto'],
+	'clang': ['-flto']
+}
+
+POLLY_CFLAGS = {
+	'gcc':   ['-fgraphite-identity'],
+	'clang': ['-mllvm', '-polly']
+	# msvc sosat :(
+}
+
+def options(opt):
+	grp = opt.add_option_group('Compiler optimization options')
+
+	grp.add_option('-T', '--build-type', action='store', dest='BUILD_TYPE', default=None,
+		help = 'build type: debug, release or none(custom flags)')
+
+	grp.add_option('--enable-lto', action = 'store_true', dest = 'LTO', default = False,
+		help = 'enable Link Time Optimization if possible [default: %default]')
+
+	grp.add_option('--enable-poly-opt', action = 'store_true', dest = 'POLLY', default = False,
+		help = 'enable polyhedral optimization if possible [default: %default]')
+
+def configure(conf):
+	conf.start_msg('Build type')
+	if conf.options.BUILD_TYPE == None:
+		conf.end_msg('not set', color='RED')
+		conf.fatal('Set a build type, for example "-T release"')
+	elif not conf.options.BUILD_TYPE in VALID_BUILD_TYPES:
+		conf.end_msg(conf.options.BUILD_TYPE, color='RED')
+		conf.fatal('Invalid build type. Valid are: %s' % ', '.join(VALID_BUILD_TYPES))
+	conf.end_msg(conf.options.BUILD_TYPE)
+
+	conf.msg('LTO build', 'yes' if conf.options.LTO else 'no')
+	conf.msg('PolyOpt build', 'yes' if conf.options.POLLY else 'no')
+
+	# -march=native should not be used
+	if conf.options.BUILD_TYPE.startswith('fast'):
+		Logs.warn('WARNING: \'%s\' build type should not be used in release builds', conf.options.BUILD_TYPE)
+
+	try:
+		conf.env.CC_VERSION[0]
+	except IndexError:
+		conf.env.CC_VERSION = (0,)
+
+@conf
+def get_optimization_flags(conf):
+	'''Returns a list of compile flags,
+	depending on build type and options set by user
+
+	NOTE: it doesn't filter out unsupported flags
+
+	:returns: tuple of cflags and linkflags
+	'''
+	linkflags = conf.get_flags_by_type(LINKFLAGS, conf.options.BUILD_TYPE, conf.env.COMPILER_CC, conf.env.CC_VERSION[0])
+
+	cflags = conf.get_flags_by_type(CFLAGS, conf.options.BUILD_TYPE, conf.env.COMPILER_CC, conf.env.CC_VERSION[0])
+
+	if conf.options.LTO:
+		linkflags+= conf.get_flags_by_compiler(LTO_LINKFLAGS, conf.env.COMPILER_CC)
+		cflags   += conf.get_flags_by_compiler(LTO_CFLAGS, conf.env.COMPILER_CC)
+
+	if conf.options.POLLY:
+		cflags   += conf.get_flags_by_compiler(POLLY_CFLAGS, conf.env.COMPILER_CC)
+
+	return cflags, linkflags

scripts/waifulib/owcc.py

@@ -0,0 +1,124 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+"""
+Compiler definition for OpenWatcom's owcc
+"""
+
+from waflib import Errors, Utils
+from waflib.Tools import ccroot, ar
+from waflib.Configure import conf
+
+@conf
+def find_owcc(conf):
+	v = conf.env
+	cc = None
+	if v.CC:
+		cc = v.CC
+	else:
+		cc = conf.find_program('cc', var='CC')
+	if not cc:
+		conf.fatal('owcc was not found')
+
+	try:
+		out = conf.cmd_and_log(cc + ['-v'])
+	except Errors.WafError:
+		conf.fatal('%r -v could not be executed' % cc)
+	if not 'Open Watcom' in out:
+		conf.fatal('failed to detect owcc')
+
+	v.CC = cc
+	v.CC_NAME = 'owcc'
+	v.CXX = v.CC
+	v.CXX_NAME = v.cc_NAME
+	if not v.AR:
+		conf.find_program('wlib', var='AR')
+	conf.add_os_flags('ARFLAGS')
+	if not v.ARFLAGS:
+		v.ARFLAGS = ['-fo']
+
+@conf
+def owcc_common_flags(conf):
+	v = conf.env
+
+	v.CC_SRC_F            = ''
+	v.CXX_SRC_F            = ''
+	v.CC_TGT_F            = ['-c', '-o']
+	v.CXX_TGT_F            = ['-c', '-o']
+	v.CPPPATH_ST          = '-I%s'
+	v.DEFINES_ST          = '-D%s'
+
+	if not v.LINK_CC:
+		v.LINK_CC = v.CC
+	if not v.LINK_CXX:
+		v.LINK_CXX = v.CXX
+
+	v.CCLNK_SRC_F         = ''
+	v.CCLNK_TGT_F         = ['-o']
+	v.CXXLNK_SRC_F         = ''
+	v.CXXLNK_TGT_F         = ['-o']
+
+	v.LIB_ST              = '-l%s' # template for adding libs
+	v.LIBPATH_ST          = '-L%s' # template for adding libpaths
+	v.STLIB_ST            = '-l%s'
+	v.STLIBPATH_ST        = '-L%s'
+
+	v.cprogram_PATTERN    = '%s.exe'
+	v.cxxprogram_PATTERN    = '%s.exe'
+	v.cshlib_PATTERN      = 'lib%s.so'
+	v.cxxshlib_PATTERN      = 'lib%s.so'
+	v.cstlib_PATTERN      = '%s.a'
+	v.cxxstlib_PATTERN      = '%s.a'
+
+def find_target(flags):
+	if '-b' in flags:
+		return flags[flags.index('-b')+1]
+
+@conf
+def owcc_detect_platform(conf):
+	v = conf.env
+	target = find_target(v.LINKFLAGS)
+	if not target:
+		target = find_target(v.CC)
+	if not target:
+		target = find_target(v.CFLAGS)
+	if not target:
+		target = Utils.unversioned_sys_platform()
+	if target in ['dos4g', 'dos4gnz', 'dos32a', 'stub32a', 'stub32ac']:
+		v.DEST_BINFMT = 'le'
+		v.DEST_OS = 'dos'
+	elif target in ['dos32x', 'stub32x', 'stub32xc']:
+		v.DEST_BINFMT = 'lx'
+		v.DEST_OS = 'dos'
+	elif target.startswith('win') or target.startswith('nt'):
+		v.DEST_BINFMT = 'pe'
+		v.DEST_OS = 'win32'
+	elif target == 'qnx386':
+		v.DEST_OS = 'qnx'
+		v.DEST_BINFMT = 'qnx'
+	elif target in ['linux', '386']:
+		v.DEST_OS = 'linux'
+		v.DEST_BINFMT = 'elf'
+	else:
+		v.DEST_OS = target
+		v.DEST_BINFMT = None
+
+	v.DEST_CPU = 'i386'
+
+	for f in v.LINKFLAGS + v.CC + v.CFLAGS:
+		if f.startswith('-march'):
+			v.DEST_CPU=f.split('=')[1]
+			break
+
+
+def configure(conf):
+	conf.find_owcc()
+	conf.owcc_common_flags()
+	conf.cc_load_tools()
+	conf.cc_add_flags()
+	conf.env.append_unique('CFLAGS','-Wc,-xx')
+	conf.cxx_load_tools()
+	conf.cxx_add_flags()
+	conf.env.append_unique('CXXFLAGS','-Wc,-xx')
+	conf.link_add_flags()
+	conf.owcc_detect_platform()

scripts/waifulib/xcompile.py

@@ -0,0 +1,433 @@
+# encoding: utf-8
+# xcompile.py -- crosscompiling utils
+# Copyright (C) 2018 a1batross
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+try: from fwgslib import get_flags_by_compiler
+except: from waflib.extras.fwgslib import get_flags_by_compiler
+from waflib import Logs, TaskGen
+from waflib.Tools import c_config
+from collections import OrderedDict
+import os
+import sys
+
+ANDROID_NDK_ENVVARS = ['ANDROID_NDK_HOME', 'ANDROID_NDK']
+ANDROID_NDK_SUPPORTED = [10, 19, 20]
+ANDROID_NDK_HARDFP_MAX = 11 # latest version that supports hardfp
+ANDROID_NDK_GCC_MAX = 17 # latest NDK that ships with GCC
+ANDROID_NDK_UNIFIED_SYSROOT_MIN = 15
+ANDROID_NDK_SYSROOT_FLAG_MAX = 19 # latest NDK that need --sysroot flag
+ANDROID_NDK_API_MIN = { 10: 3, 19: 16, 20: 16 } # minimal API level ndk revision supports
+ANDROID_64BIT_API_MIN = 21 # minimal API level that supports 64-bit targets
+
+# This class does support ONLY r10e and r19c/r20 NDK
+class Android:
+	ctx            = None # waf context
+	arch           = None
+	toolchain      = None
+	api            = None
+	ndk_home       = None
+	ndk_rev        = 0
+	is_hardfloat   = False
+	clang          = False
+
+	def __init__(self, ctx, arch, toolchain, api):
+		self.ctx = ctx
+		self.api = api
+		self.toolchain = toolchain
+		self.arch = arch
+
+		for i in ANDROID_NDK_ENVVARS:
+			self.ndk_home = os.getenv(i)
+			if self.ndk_home != None:
+				break
+		else:
+			ctx.fatal('Set %s environment variable pointing to the root of Android NDK!' %
+				' or '.join(ANDROID_NDK_ENVVARS))
+
+		# 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])
+
+			if self.ndk_rev not in ANDROID_NDK_SUPPORTED:
+				ctx.fatal('Unknown NDK revision: %d' % (self.ndk_rev))
+		else:
+			self.ndk_rev = ANDROID_NDK_SUPPORTED[0]
+
+		if 'clang' in self.toolchain or self.ndk_rev > ANDROID_NDK_GCC_MAX:
+			self.clang = True
+
+		if self.arch == 'armeabi-v7a-hard':
+			if self.ndk_rev <= ANDROID_NDK_HARDFP_MAX:
+				self.arch = 'armeabi-v7a' # Only armeabi-v7a have hard float ABI
+				self.is_hardfloat = True
+			else:
+				ctx.fatal('NDK does not support hardfloat ABI')
+
+		if self.api < ANDROID_NDK_API_MIN[self.ndk_rev]:
+			self.api = ANDROID_NDK_API_MIN[self.ndk_rev]
+			Logs.warn('API level automatically was set to %d due to NDK support' % self.api)
+
+		if self.is_arm64() or self.is_amd64() and self.api < ANDROID_64BIT_API_MIN:
+			self.api = ANDROID_64BIT_API_MIN
+			Logs.warn('API level for 64-bit target automatically was set to %d' % self.api)
+
+	def is_host(self):
+		'''
+		Checks if we using host compiler(implies clang)
+		'''
+		return self.toolchain == 'host'
+
+	def is_arm(self):
+		'''
+		Checks if selected architecture is **32-bit** ARM
+		'''
+		return self.arch.startswith('armeabi')
+
+	def is_x86(self):
+		'''
+		Checks if selected architecture is **32-bit** or **64-bit** 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):
+		'''
+		Checks if selected architecture is AArch64
+		'''
+		return self.arch == 'aarch64'
+
+	def is_clang(self):
+		'''
+		Checks if selected toolchain is Clang (TODO)
+		'''
+		return self.clang
+
+	def is_hardfp(self):
+		return self.is_hardfloat
+
+	def ndk_triplet(self, llvm_toolchain = False, toolchain_folder = False):
+		if self.is_x86():
+			if toolchain_folder:
+				return 'x86'
+			else:
+				return 'i686-linux-android'
+		elif self.is_arm():
+			if llvm_toolchain:
+				return 'armv7a-linux-androideabi'
+			else:
+				return 'arm-linux-androideabi'
+		elif self.is_amd64() and toolchain_folder:
+			return 'x86_64'
+		else:
+			return self.arch + '-linux-android'
+
+	def apk_arch(self):
+		if self.is_arm64():
+			return 'arm64-v8a'
+		return self.arch
+
+	def gen_host_toolchain(self):
+		# With host toolchain we don't care about OS
+		# so just download NDK for Linux x86_64
+		if 'HOST_TOOLCHAIN' in self.ctx.environ:
+			return self.ctx.environ['HOST_TOOLCHAIN']
+		if self.is_host():
+			return 'linux-x86_64'
+
+		if sys.platform.startswith('win32') or sys.platform.startswith('cygwin'):
+			osname = 'windows'
+		elif sys.platform.startswith('darwin'):
+			osname = 'darwin'
+		elif sys.platform.startswith('linux'):
+			osname = 'linux'
+		else:
+			self.ctx.fatal('Unsupported by NDK host platform')
+
+		if sys.maxsize > 2**32:
+			arch = 'x86_64'
+		else: arch = 'x86'
+
+		return '%s-%s' % (osname, arch)
+
+	def gen_gcc_toolchain_path(self):
+		path = 'toolchains'
+		toolchain_host = self.gen_host_toolchain()
+
+		if self.is_clang():
+			toolchain_folder = 'llvm'
+		else:
+			if self.is_host():
+				toolchain = '4.9'
+			else:
+				toolchain = self.toolchain
+
+			toolchain_folder = '%s-%s' % (self.ndk_triplet(toolchain_folder = True), toolchain)
+
+		return os.path.abspath(os.path.join(self.ndk_home, path, toolchain_folder, 'prebuilt', toolchain_host))
+
+	def gen_toolchain_path(self):
+		if self.is_clang():
+			triplet = '%s%d-' % (self.ndk_triplet(llvm_toolchain = True), self.api)
+		else:
+			triplet = self.ndk_triplet() + '-'
+		return os.path.join(self.gen_gcc_toolchain_path(), 'bin', triplet)
+
+	def gen_binutils_path(self):
+		return os.path.join(self.gen_gcc_toolchain_path(), self.ndk_triplet(), 'bin')
+
+	def cc(self):
+		if self.is_host():
+			return 'clang --target=%s%d' % (self.ndk_triplet(), self.api)
+		return self.gen_toolchain_path() + ('clang' if self.is_clang() else 'gcc')
+
+	def cxx(self):
+		if self.is_host():
+			return 'clang++ --target=%s%d' % (self.ndk_triplet(), self.api)
+		return self.gen_toolchain_path() + ('clang++' if self.is_clang() else 'g++')
+
+	def strip(self):
+		if self.is_host():
+			return 'llvm-strip'
+		return os.path.join(self.gen_binutils_path(), 'strip')
+
+	def system_stl(self):
+		# TODO: proper STL support
+		return os.path.abspath(os.path.join(self.ndk_home, 'sources', 'cxx-stl', 'system', 'include'))
+
+	def libsysroot(self):
+		arch = self.arch
+		if self.is_arm():
+			arch = 'arm'
+		elif self.is_arm64():
+			arch = 'arm64'
+		path = 'platforms/android-%s/arch-%s' % (self.api, arch)
+
+		return os.path.abspath(os.path.join(self.ndk_home, path))
+
+	def sysroot(self):
+		if self.ndk_rev >= ANDROID_NDK_UNIFIED_SYSROOT_MIN:
+			return os.path.abspath(os.path.join(self.ndk_home, 'sysroot'))
+		else:
+			return self.libsysroot()
+
+	def cflags(self, cxx = False):
+		cflags = []
+
+		if self.ndk_rev <= ANDROID_NDK_SYSROOT_FLAG_MAX:
+			cflags += ['--sysroot=%s' % (self.sysroot())]
+		else:
+			if self.is_host():
+				cflags += [
+					'--sysroot=%s/sysroot' % (self.gen_gcc_toolchain_path()),
+					'-isystem', '%s/usr/include/' % (self.sysroot())
+				]
+
+		cflags += ['-I%s' % (self.system_stl()), '-DANDROID', '-D__ANDROID__']
+
+		if cxx and not self.is_clang() and self.toolchain not in ['4.8','4.9']:
+			cflags += ['-fno-sized-deallocation']
+
+		def fixup_host_clang_with_old_ndk():
+			cflags = []
+			# Clang builtin redefine w/ different calling convention bug
+			# NOTE: I did not added complex.h functions here, despite
+			# that NDK devs forgot to put __NDK_FPABI_MATH__ for complex
+			# math functions
+			# I personally don't need complex numbers support, but if you want it
+			# just run sed to patch header
+			for f in ['strtod', 'strtof', 'strtold']:
+				cflags += ['-fno-builtin-%s' % f]
+			return cflags
+
+
+		if self.is_arm():
+			if self.arch == 'armeabi-v7a':
+				# ARMv7 support
+				cflags += ['-mthumb', '-mfpu=neon', '-mcpu=cortex-a9', '-DHAVE_EFFICIENT_UNALIGNED_ACCESS', '-DVECTORIZE_SINCOS']
+
+				if not self.is_clang() and not self.is_host():
+					cflags += [ '-mvectorize-with-neon-quad' ]
+
+				if self.is_host() and self.ndk_rev <= ANDROID_NDK_HARDFP_MAX:
+					cflags += fixup_host_clang_with_old_ndk()
+
+				if self.is_hardfp():
+					cflags += ['-D_NDK_MATH_NO_SOFTFP=1', '-mfloat-abi=hard', '-DLOAD_HARDFP', '-DSOFTFP_LINK']
+				else:
+					cflags += ['-mfloat-abi=softfp']
+			else:
+				if self.is_host() and self.ndk_rev <= ANDROID_NDK_HARDFP_MAX:
+					cflags += fixup_host_clang_with_old_ndk()
+
+				# ARMv5 support
+				cflags += ['-march=armv5te', '-msoft-float']
+		elif self.is_x86():
+			cflags += ['-mtune=atom', '-march=atom', '-mssse3', '-mfpmath=sse', '-DVECTORIZE_SINCOS', '-DHAVE_EFFICIENT_UNALIGNED_ACCESS']
+		return cflags
+
+	# they go before object list
+	def linkflags(self):
+		linkflags = []
+		if self.is_host():
+			linkflags += ['--gcc-toolchain=%s' % self.gen_gcc_toolchain_path()]
+
+		if self.ndk_rev <= ANDROID_NDK_SYSROOT_FLAG_MAX:
+			linkflags += ['--sysroot=%s' % (self.sysroot())]
+		elif self.is_host():
+			linkflags += ['--sysroot=%s/sysroot' % (self.gen_gcc_toolchain_path())]
+
+		if self.is_clang() or self.is_host():
+			linkflags += ['-fuse-ld=lld']
+
+		linkflags += ['-Wl,--hash-style=sysv', '-Wl,--no-undefined', '-no-canonical-prefixes']
+		return linkflags
+
+	def ldflags(self):
+		ldflags = ['-lgcc', '-no-canonical-prefixes']
+		if self.is_clang() or self.is_host():
+			ldflags += ['-stdlib=libstdc++']
+		if self.is_arm():
+			if self.arch == 'armeabi-v7a':
+				ldflags += ['-march=armv7-a', '-mthumb']
+
+				if not self.is_clang() and not self.is_host(): # lld only
+					ldflags += ['-Wl,--fix-cortex-a8']
+
+				if self.is_hardfp():
+					ldflags += ['-Wl,--no-warn-mismatch', '-lm_hard']
+			else:
+				ldflags += ['-march=armv5te']
+		return ldflags
+
+def options(opt):
+	android = opt.add_option_group('Android options')
+	android.add_option('--android', action='store', dest='ANDROID_OPTS', default=None,
+		help='enable building for android, format: --android=<arch>,<toolchain>,<api>, example: --android=armeabi-v7a-hard,4.9,9')
+
+	magx = opt.add_option_group('MotoMAGX options')
+	magx.add_option('--enable-magx', action = 'store_true', dest = 'MAGX', default = False,
+		help = 'enable targetting for MotoMAGX phones [default: %default]')
+
+def configure(conf):
+	if conf.options.ANDROID_OPTS:
+		values = conf.options.ANDROID_OPTS.split(',')
+		if len(values) != 3:
+			conf.fatal('Invalid --android paramater value!')
+
+		valid_archs = ['x86', 'x86_64', 'armeabi', 'armeabi-v7a', 'armeabi-v7a-hard', 'aarch64']
+
+		if values[0] not in valid_archs:
+			conf.fatal('Unknown arch: %s. Supported: %r' % (values[0], ', '.join(valid_archs)))
+
+		conf.android = android = Android(conf, values[0], values[1], int(values[2]))
+		conf.environ['CC'] = android.cc()
+		conf.environ['CXX'] = android.cxx()
+		conf.environ['STRIP'] = android.strip()
+		conf.env.CFLAGS += android.cflags()
+		conf.env.CXXFLAGS += android.cflags(True)
+		conf.env.LINKFLAGS += android.linkflags()
+		conf.env.LDFLAGS += android.ldflags()
+
+		conf.env.HAVE_M = True
+		if android.is_hardfp():
+			conf.env.LIB_M = ['m_hard']
+		else: conf.env.LIB_M = ['m']
+
+		conf.env.PREFIX = '/lib/%s' % android.apk_arch()
+
+		conf.msg('Selected Android NDK', '%s, version: %d' % (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_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'
+	elif conf.options.MAGX:
+		# useless to change toolchain path, as toolchain meant to be placed in this path
+		toolchain_path = '/opt/toolchains/motomagx/arm-eabi2/lib/'
+		conf.env.INCLUDES_MAGX = [toolchain_path + i for i in ['ezx-z6/include', 'qt-2.3.8/include']]
+		conf.env.LIBPATH_MAGX  = [toolchain_path + i for i in ['ezx-z6/lib', 'qt-2.3.8/lib']]
+		conf.env.LINKFLAGS_MAGX = ['-Wl,-rpath-link=' + i for i in conf.env.LIBPATH_MAGX]
+		for lib in ['qte-mt', 'ezxappbase', 'ezxpm', 'log_util']:
+			conf.check_cc(lib=lib, use='MAGX', uselib_store='MAGX')
+
+	conf.env.MAGX = conf.options.MAGX
+	MACRO_TO_DESTOS = OrderedDict({ '__ANDROID__' : 'android' })
+	for k in c_config.MACRO_TO_DESTOS:
+		MACRO_TO_DESTOS[k] = c_config.MACRO_TO_DESTOS[k] # ordering is important
+	c_config.MACRO_TO_DESTOS  = MACRO_TO_DESTOS
+
+def post_compiler_cxx_configure(conf):
+	conf.msg('Target OS', conf.env.DEST_OS)
+	conf.msg('Target CPU', conf.env.DEST_CPU)
+	conf.msg('Target binfmt', conf.env.DEST_BINFMT)
+
+	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):
+	conf.msg('Target OS', conf.env.DEST_OS)
+	conf.msg('Target CPU', conf.env.DEST_CPU)
+	conf.msg('Target binfmt', conf.env.DEST_BINFMT)
+
+	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)
+
+@TaskGen.feature('cshlib', 'cxxshlib', 'dshlib', 'fcshlib', 'vnum')
+@TaskGen.after_method('apply_link', 'propagate_uselib_vars')
+@TaskGen.before_method('apply_vnum')
+def apply_android_soname(self):
+	"""
+	Enforce SONAME on Android
+	"""
+	if self.env.DEST_OS != 'android':
+		return
+
+	setattr(self, 'vnum', None) # remove vnum, so SONAME would not be overwritten
+	link = self.link_task
+	node = link.outputs[0]
+	libname = node.name
+	v = self.env.SONAME_ST % libname
+	self.env.append_value('LINKFLAGS', v.split())

scripts/waifulib/xshlib.py

@@ -0,0 +1,115 @@
+# encoding: utf-8
+# xshlib.py -- advanced linking utils
+# Copyright (C) 2019 mittorn
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+from waflib import Logs, Utils, TaskGen, Task
+from waflib.Tools import ccroot, c, cxx
+
+MAIN_BINARY = 'xash'
+
+def options(opt):
+	opt.add_option('--static-linking', action='store', dest='STATIC_LINKING', default=None)
+
+def configure(conf):
+	if conf.options.STATIC_LINKING:
+		conf.find_program('ld')
+		conf.find_program('objcopy')
+		conf.env.STATIC_LINKING = conf.options.STATIC_LINKING
+		conf.add_os_flags('LD_RELOCATABLE_FLAGS')
+
+def build(bld):
+	if bld.env.STATIC_LINKING:
+		apply_static(MAIN_BINARY,*bld.env.STATIC_LINKING.split(','))
+
+class objcopy_relocatable_lib(Task.Task):
+	"remove all exports except of lib_${NAME}_exports"
+	no_errcheck_out = True
+	run_str = '${OBJCOPY} -G lib_${NAME}_exports ${SRC[0].abspath()} ${TGT[0].abspath()}'
+	def keyword(self):
+		return 'ObjCopy'
+
+class xshlib(ccroot.link_task):
+	"make relocatable library"
+	no_errcheck_out = True
+	run_str = '${LD} -r -o ${TGT[0].abspath()} ${LD_RELOCATABLE_FLAGS} ${CCLNK_SRC_F}${SRC}'
+
+	def add_target(self, target):
+		"create objcopy task for target"
+		if not self.env.LD_RELOCATABLE_FLAGS:
+			self.env.LD_RELOCATABLE_FLAGS = []
+			if '-m32' in self.env.LINKFLAGS:
+				self.env.LD_RELOCATABLE_FLAGS.append('-melf_i386')
+
+		base = self.generator.path
+		target_unstripped = base.find_or_declare('%s.unstripped.o'% target)
+		target_stripped = base.find_or_declare('%s.o'% target)
+
+		self.set_outputs(target_unstripped)
+		self.generator.objcopy_task= self.generator.create_task('objcopy_relocatable_lib', target_unstripped, target_stripped)
+		self.generator.objcopy_task.env['NAME'] = target
+
+class cprogram_static(c.cprogram):
+	"build static c program"
+	run_str = '${LINK_CC} -static ${LINKFLAGS} ${CCLNK_SRC_F}${SRC} ${CCLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${STLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB} ${LDFLAGS}'
+
+class cxxprogram_static(cxx.cxxprogram):
+	"build static cxx program"
+	run_str = '${LINK_CXX} -static ${LINKFLAGS} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${STLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB} ${LDFLAGS}'
+
+# usevars are same
+ccroot.USELIB_VARS['cprogram_static'] = ccroot.USELIB_VARS['cxxprogram_static'] = ccroot.USELIB_VARS['cxxprogram']
+
+def apply_static(main, *reloc):
+	"apply xshlib tasks and generate files"
+
+	def write_libraries_list(out_node):
+		"generate library list"
+
+		libraries = reloc
+		externs = '\n'.join(['extern table_t lib_%s_exports[];' % e for e in libraries])
+		table = '\n'.join(['{ "%s", &lib_%s_exports },' % (e, e) for e in libraries])
+		out_node.write('%s\nstruct {const char *name;void *func;} libs[] = {\n%s\n{0,0}\n};\n' % (externs, table ))
+
+
+	def write_export_list(name, in_node, out_node):
+		"generate exports list for library"
+
+		exports = in_node.read().splitlines()
+		externs = '\n'.join(['extern void %s(void);' % e for e in exports])
+		table = '\n'.join(['{ "%s", &%s },' % (e, e) for e in exports])
+		out_node.write('%s\nstruct {const char *name;void *func;} lib_%s_exports[] = {\n%s\n{0,0}\n};\n' % (externs, name, table ))
+
+	@TaskGen.feature('cshlib', 'cxxshlib')
+	@TaskGen.before('process_source', 'propogate_uselib_vars')
+	def apply_xshlib(self):
+		"apply xshlib feature and inject link_helper.c to sources"
+		if self.name in reloc:
+			for k in ('cshlib', 'cxxshlib'):
+				if k in self.features:
+					self.features.remove(k)
+			self.features.append('xshlib')
+			in_node = self.path.get_src().make_node('exports.txt')
+			bldnode = self.path.get_bld()
+			bldnode.mkdir()
+			out_node = bldnode.make_node('link_helper.c')
+			write_export_list(self.name,in_node, out_node)
+			self.source = Utils.to_list(self.source) + [out_node]
+
+	@TaskGen.feature('cshlib', 'cxxshlib', 'cprogram', 'cxxprogram', 'cprogram_static', 'cxxprogram_static')
+	@TaskGen.before('process_source')
+	def add_deps(self):
+		"add all relocatable objects to main binary source list"
+		if self.name == main:
+			write_libraries_list(self.path.get_bld().make_node('generated_library_tables.h'))
+
+			for t in reloc:
+				self.source += [self.bld.get_tgen_by_name(t).objcopy_task.outputs[0]]