public static int GetMinimumApiLevelFor(AndroidTargetArch arch, string androidNdkPath)
{
var minValue = NdkUtil.IsNdk64BitArch(arch) ? 21 : arch == AndroidTargetArch.Arm ? 4 : 9;
var platforms = GetSupportedPlatforms(androidNdkPath).OrderBy(x => x).Where(x => x >= minValue);
return(platforms.First(x => Directory.Exists(Path.Combine(androidNdkPath, "platforms", $"android-{x}", $"arch-{archPathMap[arch]}"))));
}
static string GetNdkToolchainPrefix(AndroidTargetArch arch)
{
switch (arch)
{
case AndroidTargetArch.Arm:
return("arm-linux-androideabi-");
case AndroidTargetArch.Arm64:
return("aarch64-linux-android-");
case AndroidTargetArch.X86:
return("i686-linux-android-");
case AndroidTargetArch.X86_64:
return("x86_64-linux-android-");
case AndroidTargetArch.Mips:
return("mipsel-linux-android-");
default:
// return empty. Since this method returns the "prefix", the resulting
// tool path just becomes the tool name i.e. "gcc" becomes "gcc".
// This should work for any custom arbitrary platform.
return(String.Empty);
}
}
static string[] GetNdkToolchainDirectories(string toolchainsPath, AndroidTargetArch arch)
{
if (!Directory.Exists(toolchainsPath))
{
throw new Exception($"Missing Android NDK toolchains directory '{toolchainsPath}'. Please install the Android NDK.");
}
if (string.Compare(Path.GetFileName(toolchainsPath), "llvm", StringComparison.OrdinalIgnoreCase) == 0)
{
return(new[] { toolchainsPath });
}
switch (arch)
{
case AndroidTargetArch.Arm:
return(Directory.GetDirectories(toolchainsPath, "arm-linux-androideabi-*"));
case AndroidTargetArch.Arm64:
return(Directory.GetDirectories(toolchainsPath, "aarch64-linux-android-*"));
case AndroidTargetArch.X86:
return(Directory.GetDirectories(toolchainsPath, "x86-*"));
case AndroidTargetArch.X86_64:
return(Directory.GetDirectories(toolchainsPath, "x86_64-*"));
case AndroidTargetArch.Mips:
return(Directory.GetDirectories(toolchainsPath, "mipsel-linux-android-*"));
default: // match any directory that contains the arch name.
return(Directory.GetDirectories(toolchainsPath, "*" + arch + "*"));
}
}
public static string GetNdkPlatformLibPath(string androidNdkPath, AndroidTargetArch arch, int apiLevel)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkPlatformLibPath(androidNdkPath, arch, apiLevel));
}
var checkedPaths = new List <string> ();
string lib = arch == AndroidTargetArch.X86_64 ? "lib64" : "lib";
string path = Path.Combine(androidNdkPath, "platforms", $"android-{apiLevel}", $"arch-{GetPlatformArch (arch)}", "usr", lib);
if (!Directory.Exists(path))
{
checkedPaths.Add(path);
path = Path.Combine(GetNdk22OrNewerSysrootDir(androidNdkPath), GetArchDirName(arch), apiLevel.ToString());
}
if (!Directory.Exists(path))
{
checkedPaths.Add(path);
string paths = String.Join("; ", checkedPaths);
throw new InvalidOperationException($"Platform library directory for target {arch} and API Level {apiLevel} was not found. Checked paths: {paths}");
}
return(path);
}
public static string GetNdkTool(string androidNdkPath, AndroidTargetArch arch, string tool)
{
var toolchains = GetNdkToolchainPath(androidNdkPath, arch);
string extension = OS.IsWindows ? ".exe" : string.Empty;
List <string> toolPaths = null;
foreach (var platbase in toolchains)
{
string path = Path.Combine(platbase, "prebuilt", MonoAndroidHelper.AndroidSdk.AndroidNdkHostPlatform, "bin", GetNdkToolchainPrefix(arch) + tool + extension);
if (File.Exists(path))
{
return(path);
}
if (toolPaths == null)
{
toolPaths = new List <string>();
}
toolPaths.Add(path);
}
{
string path = Path.Combine(androidNdkPath, "prebuilt", MonoAndroidHelper.AndroidSdk.AndroidNdkHostPlatform, "bin", tool);
if (File.Exists(path))
{
return(path);
}
if (toolPaths == null)
{
toolPaths = new List <string>();
}
toolPaths.Add(path);
}
Diagnostic.Error(5101, Properties.Resources.XA5101_C_Compiler, arch, string.Join("; ", toolPaths));
return(null);
}
public static string GetNdkToolchainPrefix(AndroidTargetArch arch, bool forCompiler)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkToolchainPrefix(arch));
}
switch (arch)
{
case AndroidTargetArch.Arm:
return(forCompiler ? "armv7a-linux-androideabi" : "arm-linux-androideabi");
case AndroidTargetArch.Arm64:
return("aarch64-linux-android");
case AndroidTargetArch.X86:
return("i686-linux-android");
case AndroidTargetArch.X86_64:
return("x86_64-linux-android");
default:
// return empty. Since this method returns the "prefix", the resulting
// tool path just becomes the tool name i.e. "gcc" becomes "gcc".
// This should work for any custom arbitrary platform.
return(String.Empty);
}
}
public static string GetNdkPlatformLibPath(string androidNdkPath, AndroidTargetArch arch, int level)
{
string path = Path.Combine (androidNdkPath, "platforms", "android-" + level, "arch-" + GetPlatformArch (arch), "usr", "lib");
if (!Directory.Exists (path))
throw new InvalidOperationException (String.Format ("Platform library directory for target {0} and API Level {1} was not found. Expected path is \"{2}\"", arch, level, path));
return path;
}
static string[] GetNdkToolchainDirectories(string toolchainsPath, AndroidTargetArch arch)
{
if (!Directory.Exists(toolchainsPath))
{
Diagnostic.Error(5101,
"Missing Android NDK toolchains directory '{0}'. Please install the Android NDK.",
toolchainsPath);
}
switch (arch)
{
case AndroidTargetArch.Arm:
return(Directory.GetDirectories(toolchainsPath, "arm-linux-androideabi-*"));
case AndroidTargetArch.Arm64:
return(Directory.GetDirectories(toolchainsPath, "aarch64-linux-android-*"));
case AndroidTargetArch.X86:
return(Directory.GetDirectories(toolchainsPath, "x86-*"));
case AndroidTargetArch.X86_64:
return(Directory.GetDirectories(toolchainsPath, "x86_64-*"));
case AndroidTargetArch.Mips:
return(Directory.GetDirectories(toolchainsPath, "mipsel-linux-android-*"));
default: // match any directory that contains the arch name.
return(Directory.GetDirectories(toolchainsPath, "*" + arch + "*"));
}
}
public static string GetNdkToolPrefix(string androidNdkPath, AndroidTargetArch arch)
{
var path = GetNdkTool(androidNdkPath, arch, "as");
if (path != null)
{
path = path.Substring(0, path.LastIndexOf("-") + 1);
}
return(path);
}
static bool ValidateAotConfiguration(TaskLoggingHelper log, AndroidTargetArch arch, bool enableLLVM)
{
if (arch == AndroidTargetArch.X86_64)
{
log.LogCodedError("XA3004", "x86_64 architecture is not currently supported on AOT mode.");
return(false);
}
return(true);
}
public static string GetNdkPlatformIncludePath(string androidNdkPath, AndroidTargetArch arch, int level)
{
string path = Path.Combine(androidNdkPath, "platforms", "android-" + level, "arch-" + GetPlatformArch(arch), "usr", "include");
if (!Directory.Exists(path))
{
throw new InvalidOperationException(String.Format("Platform header files for target {0} and API Level {1} was not found. Expected path is \"{2}\"", arch, level, path));
}
return(path);
}
public static string GetNdkPlatformLibPath(string androidNdkPath, AndroidTargetArch arch, int level)
{
string lib = arch == AndroidTargetArch.X86_64 ? "lib64" : "lib";
string path = Path.Combine(androidNdkPath, "platforms", "android-" + level, "arch-" + GetPlatformArch(arch), "usr", lib);
if (!Directory.Exists(path))
{
throw new InvalidOperationException(String.Format("Platform library directory for target {0} and API Level {1} was not found. Expected path is \"{2}\"", arch, level, path));
}
return(path);
}
public static string GetAbiFromArch(AndroidTargetArch arch)
{
switch (arch) {
case AndroidTargetArch.Arm: return "android-arm";
case AndroidTargetArch.Arm64: return "android-arm64";
case AndroidTargetArch.Mips: return "android-mips";
case AndroidTargetArch.X86: return "android-x86";
case AndroidTargetArch.X86_64: return "android-x86_64";
}
return null;
}
public static string GetNdkAsmIncludePath(string androidNdkPath, AndroidTargetArch arch, int apiLevel)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkAsmIncludePath(androidNdkPath, arch, apiLevel));
}
string path = GetUnifiedHeadersPath(androidNdkPath);
string archDir = GetArchDirName(arch);
return(Path.Combine(path, archDir));
}
static int GetNdkApiLevel(string androidNdkPath, string androidApiLevel, AndroidTargetArch arch)
{
int level = int.Parse(androidApiLevel);
// Some Android API levels do not exist on the NDK level. Workaround this my mapping them to the
// most appropriate API level that does exist.
if (level == 6 || level == 7)
{
level = 5;
}
else if (level == 10)
{
level = 9;
}
else if (level == 11)
{
level = 12;
}
else if (level == 20)
{
level = 19;
}
else if (level == 22)
{
level = 21;
}
else if (level == 23)
{
level = 21;
}
// API levels below level 21 do not provide support for 64-bit architectures.
if (NdkUtil.IsNdk64BitArch(arch) && level < 21)
{
level = 21;
}
// We perform a downwards API level lookup search since we might not have hardcoded the correct API
// mapping above and we do not want to crash needlessly.
for (; level >= 5; level--)
{
try {
NdkUtil.GetNdkPlatformLibPath(androidNdkPath, arch, level);
break;
} catch (InvalidOperationException ex) {
// Path not found, continue searching...
continue;
}
}
return(level);
}
public static List<string> GetNdkToolchainPath(string androidNdkPath, AndroidTargetArch arch)
{
var toolchains = GetNdkToolchainDirectories (Path.Combine (androidNdkPath, "toolchains"), arch);
if (!toolchains.Any ())
Diagnostic.Error (5101,
"Toolchain directory for target {0} was not found.",
arch);
// Sort the toolchains paths in reverse so that we prefer the latest versions.
Array.Sort(toolchains);
Array.Reverse(toolchains);
return new List<string>(toolchains);
}
public static List <string> GetNdkToolchainPath(string androidNdkPath, AndroidTargetArch arch)
{
var toolchains = GetNdkToolchainDirectories(Path.Combine(androidNdkPath, "toolchains"), arch);
if (!toolchains.Any())
{
Diagnostic.Error(5101, Properties.Resources.XA5101_Toolchain, arch);
}
// Sort the toolchains paths in reverse so that we prefer the latest versions.
Array.Sort(toolchains);
Array.Reverse(toolchains);
return(new List <string>(toolchains));
}
public static string GetNdkClangBin(string toolchainsPath, AndroidTargetArch arch)
{
var toolChainDir = GetNdkToolchainDirectories(toolchainsPath, arch).First();
var machineDir = Directory.GetDirectories(Path.Combine(toolChainDir, "prebuilt")).First();
var gcc = Path.Combine(machineDir, "bin", GetNdkToolchainPrefix(arch) + "gcc");
if (File.Exists(gcc))
{
return(gcc);
}
throw new Exception($"Unable to find NDK toolchain for {arch}!");
}
public static List <string> GetNdkToolchainPath(string androidNdkPath, AndroidTargetArch arch)
{
var toolchains = GetNdkToolchainDirectories(Path.Combine(androidNdkPath, "toolchains"), arch);
if (!toolchains.Any())
{
throw new Exception($"Toolchain directory for target {arch} was not found.");
}
// Sort the toolchains paths in reverse so that we prefer the latest versions.
Array.Sort(toolchains);
Array.Reverse(toolchains);
return(new List <string>(toolchains));
}
static string GetMonoDroidArchName(AndroidTargetArch arch)
{
switch (arch)
{
case AndroidTargetArch.Arm:
return("armeabi");
case AndroidTargetArch.Mips:
return("mips");
case AndroidTargetArch.X86:
return("x86");
}
return(null);
}
public static string GetNdkToolPrefix(string androidNdkPath, AndroidTargetArch arch, int apiLevel)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkToolPrefix(androidNdkPath, arch));
}
var path = GetNdkTool(androidNdkPath, arch, "as", apiLevel);
if (path != null)
{
path = path.Substring(0, path.LastIndexOf("-") + 1);
}
return(path);
}
public static string GetNdkPlatformLibPath(string androidNdkPath, AndroidTargetArch arch, int apiLevel)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkPlatformLibPath(androidNdkPath, arch, apiLevel));
}
string lib = arch == AndroidTargetArch.X86_64 ? "lib64" : "lib";
string path = Path.Combine(androidNdkPath, "platforms", $"android-{apiLevel}", $"arch-{GetPlatformArch (arch)}", "usr", lib);
if (!Directory.Exists(path))
{
throw new InvalidOperationException($"Platform library directory for target {arch} and API Level {apiLevel} was not found. Expected path is \"{path}\"");
}
return(path);
}
public static string GetDebugServerPath(AndroidDebugServer server, AndroidTargetArch arch,
string AndroidNdkDirectory, string SdkBinDirectory)
{
switch (server)
{
case AndroidDebugServer.Gdb:
var abi = GetAbiFromArch (arch);
return Path.Combine (AndroidNdkDirectory, "prebuilt", abi, "gdbserver", "gdbserver");
case AndroidDebugServer.Ds2:
return Path.Combine (SdkBinDirectory, "ds2-" + arch.ToString ().ToLowerInvariant ());
case AndroidDebugServer.Llgs:
throw new NotImplementedException ();
}
return null;
}
public static string GetAbiFromArch(AndroidTargetArch arch)
{
switch (arch)
{
case AndroidTargetArch.Arm: return("android-arm");
case AndroidTargetArch.Arm64: return("android-arm64");
case AndroidTargetArch.Mips: return("android-mips");
case AndroidTargetArch.X86: return("android-x86");
case AndroidTargetArch.X86_64: return("android-x86_64");
}
return(null);
}
public static string GetNdkPlatformIncludePath(string androidNdkPath, AndroidTargetArch arch, int apiLevel)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetNdkPlatformIncludePath(androidNdkPath, arch, apiLevel));
}
string path = GetUnifiedHeadersPath(androidNdkPath);
if (Directory.Exists(path))
{
return(path);
}
throw new InvalidOperationException($"Android include path not found. Tried: {path}");
}
public static string GetNdkAsmIncludePath(string androidNdkPath, AndroidTargetArch arch, int level)
{
string path = GetPerPlatformHeadersPath(androidNdkPath, arch, level);
if (Directory.Exists(path))
{
return(null);
}
path = GetUnifiedHeadersPath(androidNdkPath);
if (!Directory.Exists(path))
{
return(null);
}
string archDir = null;
switch (arch)
{
case AndroidTargetArch.Arm:
archDir = "arm-linux-androideabi";
break;
case AndroidTargetArch.Arm64:
archDir = "aarch64-linux-android";
break;
case AndroidTargetArch.Mips:
archDir = "mipsel-linux-android";
break;
case AndroidTargetArch.X86:
archDir = "i686-linux-android";
break;
case AndroidTargetArch.X86_64:
archDir = "x86_64-linux-android";
break;
}
if (archDir == null)
{
return(null);
}
return(Path.Combine(path, archDir));
}
public static int GetMinimumApiLevelFor(AndroidTargetArch arch, string androidNdkPath)
{
if (!UsingClangNDK)
{
return(NdkUtilOld.GetMinimumApiLevelFor(arch, androidNdkPath));
}
int minValue = 0;
string archName = GetPlatformArch(arch);
if (!XABuildConfig.ArchAPILevels.TryGetValue(archName, out minValue))
{
throw new InvalidOperationException($"Unable to determine minimum API level for architecture {arch}");
}
return(minValue);
}
public static string GetDebugServerPath(AndroidDebugServer server, AndroidTargetArch arch,
string AndroidNdkDirectory, string SdkBinDirectory)
{
switch (server)
{
case AndroidDebugServer.Gdb:
var abi = GetAbiFromArch(arch);
return(Path.Combine(AndroidNdkDirectory, "prebuilt", abi, "gdbserver", "gdbserver"));
case AndroidDebugServer.Ds2:
return(Path.Combine(SdkBinDirectory, "ds2-" + arch.ToString().ToLowerInvariant()));
case AndroidDebugServer.Llgs:
throw new NotImplementedException();
}
return(null);
}
public static string GetNdkTool(string androidNdkPath, AndroidTargetArch arch, string tool)
{
var toolchains = GetNdkToolchainPath(androidNdkPath, arch);
string extension = OS.IsWindows ? ".exe" : string.Empty;
List<string> toolPaths = null;
foreach (var platbase in toolchains) {
string path = Path.Combine (platbase, "prebuilt", AndroidSdk.AndroidNdkHostPlatform, "bin", GetNdkToolchainPrefix (arch) + tool + extension);
if (File.Exists (path))
return path;
if (toolPaths == null)
toolPaths = new List<string>();
toolPaths.Add (path);
}
Diagnostic.Error (5101,
"C compiler for target {0} was not found. Tried paths: \"{1}\"",
arch, string.Join ("; ", toolPaths));
return null;
}
// See the "NDK r19 bug" comment in the "GetNdkTool" method below for explanation of the issue
// this method fixes.
public static string GetCompilerTargetParameters(string androidNdkPath, AndroidTargetArch arch, int apiLevel, bool forCPlusPlus = false)
{
if (!UsingClangNDK || !OS.IsWindows)
{
return(String.Empty);
}
string targetPrefix;
string otherParams = String.Empty;
switch (arch)
{
case AndroidTargetArch.Arm:
targetPrefix = "--target=armv7a-linux-androideabi";
break;
case AndroidTargetArch.Arm64:
targetPrefix = "--target=aarch64-linux-android";
break;
case AndroidTargetArch.X86:
targetPrefix = "--target=i686-linux-android";
otherParams = "-mstackrealign";
break;
case AndroidTargetArch.X86_64:
targetPrefix = "--target=x86_64-linux-android";
break;
default:
throw new InvalidOperationException($"Unsupported target architecture {arch}");
}
string stdlib = String.Empty;
if (forCPlusPlus)
{
stdlib = "-stdlib=libc++";
}
return($"{targetPrefix}{apiLevel} {otherParams} -fno-addrsig {stdlib}");
}
public static string GetNdkPlatformIncludePath(string androidNdkPath, AndroidTargetArch arch, int level)
{
// This is for NDK older than r16 which isn't configured to use unified headers. We
string path = GetPerPlatformHeadersPath(androidNdkPath, arch, level);
if (!Directory.Exists(path))
{
// This is for NDK r15 (if configured to use unified headers) or NDK r16+ (which doesn't have
// the per-platform includes anymore)
path = GetUnifiedHeadersPath(androidNdkPath);
if (Directory.Exists(path))
{
return(path);
}
throw new InvalidOperationException(String.Format("Platform header files for target {0} and API Level {1} was not found. Expected path is \"{2}\"", arch, level, path));
}
return(path);
}
public static string GetLlvmToolchainTarget(AndroidTargetArch arch, int apiLevel)
{
switch (arch)
{
case AndroidTargetArch.Arm:
return($"armv7a-linux-androideabi{apiLevel}");
case AndroidTargetArch.Arm64:
return($"aarch64-linux-android{apiLevel}");
case AndroidTargetArch.X86:
return($"i686-linux-android{apiLevel}");
case AndroidTargetArch.X86_64:
return($"x86_64-linux-android{apiLevel}");
default:
return(string.Empty);
}
}
public static string GetNdkPlatformIncludePath(string androidNdkPath, AndroidTargetArch arch, int level, bool isLLVM)
{
string path;
if (isLLVM)
{
var toolchainDir = Path.Combine(androidNdkPath, "toolchains", "llvm", "prebuilt");
var machineDir = Directory.GetDirectories(Path.Combine(toolchainDir)).First();
path = Path.Combine(machineDir, "sysroot");
}
else
{
path = Path.Combine(androidNdkPath, "platforms", "android-" + level, "arch-" + GetPlatformArch(arch));
}
if (!Directory.Exists(path))
{
throw new InvalidOperationException(String.Format("Platform header files for target {0} and API Level {1} was not found. Expected path is \"{2}\"", arch, level, path));
}
return(path);
}
public static string GetArchDirName(AndroidTargetArch arch)
{
switch (arch)
{
case AndroidTargetArch.Arm:
return("arm-linux-androideabi");
case AndroidTargetArch.Arm64:
return("aarch64-linux-android");
case AndroidTargetArch.X86:
return("i686-linux-android");
case AndroidTargetArch.X86_64:
return("x86_64-linux-android");
default:
throw new InvalidOperationException($"Unsupported architecture {arch}");
}
}
static string GetPlatformArch(AndroidTargetArch arch)
{
switch (arch)
{
case AndroidTargetArch.Arm:
return("arm");
case AndroidTargetArch.Arm64:
return("arm64");
case AndroidTargetArch.Mips:
return("mips");
case AndroidTargetArch.X86:
return("x86");
case AndroidTargetArch.X86_64:
return("x86_64");
}
return(null);
}
static int GetNdkApiLevel(string androidNdkPath, string androidApiLevel, AndroidTargetArch arch)
{
int level = int.Parse(androidApiLevel);
// Some Android API levels do not exist on the NDK level. Workaround this my mapping them to the
// most appropriate API level that does exist.
if (level == 6 || level == 7) level = 5;
else if (level == 10) level = 9;
else if (level == 11) level = 12;
else if (level == 20) level = 19;
else if (level == 22) level = 21;
else if (level == 23) level = 21;
// API levels below level 21 do not provide support for 64-bit architectures.
if (NdkUtil.IsNdk64BitArch(arch) && level < 21) {
level = 21;
}
// We perform a downwards API level lookup search since we might not have hardcoded the correct API
// mapping above and we do not want to crash needlessly.
for (; level >= 5; level--) {
try {
NdkUtil.GetNdkPlatformLibPath (androidNdkPath, arch, level);
break;
} catch (InvalidOperationException ex) {
// Path not found, continue searching...
continue;
}
}
return level;
}
static string GetMonoDroidArchName(AndroidTargetArch arch)
{
switch (arch) {
case AndroidTargetArch.Arm:
return "armeabi";
case AndroidTargetArch.Mips:
return "mips";
case AndroidTargetArch.X86:
return "x86";
}
return null;
}
public string GetPlatformNativeLibPath(AndroidTargetArch arch)
{
return FindPlatformNativeLibPath (SdkPath, GetMonoDroidArchName (arch));
}
public static bool ValidateNdkPlatform(TaskLoggingHelper log, string ndkPath, AndroidTargetArch arch, bool requireLibm)
{
// Check that we have a compatible NDK version for the targeted ABIs.
NdkUtil.NdkVersion ndkVersion;
bool hasNdkVersion = NdkUtil.GetNdkToolchainRelease (ndkPath, out ndkVersion);
if (NdkUtil.IsNdk64BitArch(arch) && hasNdkVersion && ndkVersion.Version < 10) {
log.LogMessage (MessageImportance.High,
"The detected Android NDK version is incompatible with the targeted 64-bit architecture, " +
"please upgrade to NDK r10 or newer.");
}
// NDK r10d is buggy and cannot link x86_64 ABI shared libraries because they are 32-bits.
// See https://code.google.com/p/android/issues/detail?id=161421
if (requireLibm && ndkVersion.Version == 10 && ndkVersion.Revision == "d" && arch == AndroidTargetArch.X86_64) {
log.LogCodedError ("XA3004", "Android NDK r10d is buggy and provides an incompatible x86_64 libm.so. " +
"See https://code.google.com/p/android/issues/detail?id=161422.");
return false;
}
return true;
}
static string[] GetNdkToolchainDirectories(string toolchainsPath, AndroidTargetArch arch)
{
if (!Directory.Exists (toolchainsPath))
Diagnostic.Error (5101,
"Missing Android NDK toolchains directory '{0}'. Please install the Android NDK.",
toolchainsPath);
switch (arch) {
case AndroidTargetArch.Arm:
return Directory.GetDirectories (toolchainsPath, "arm-linux-androideabi-*");
case AndroidTargetArch.Arm64:
return Directory.GetDirectories (toolchainsPath, "aarch64-linux-android-*");
case AndroidTargetArch.X86:
return Directory.GetDirectories (toolchainsPath, "x86-*");
case AndroidTargetArch.X86_64:
return Directory.GetDirectories (toolchainsPath, "x86_64-*");
case AndroidTargetArch.Mips:
return Directory.GetDirectories (toolchainsPath, "mipsel-linux-android-*");
default: // match any directory that contains the arch name.
return Directory.GetDirectories (toolchainsPath, "*" + arch + "*");
}
}
static string GetNdkToolchainPrefix(AndroidTargetArch arch)
{
switch (arch) {
case AndroidTargetArch.Arm:
return "arm-linux-androideabi-";
case AndroidTargetArch.Arm64:
return "aarch64-linux-android-";
case AndroidTargetArch.X86:
return "i686-linux-android-";
case AndroidTargetArch.X86_64:
return "x86_64-linux-android-";
case AndroidTargetArch.Mips:
return "mipsel-linux-android-";
default:
// return empty. Since this method returns the "prefix", the resulting
// tool path just becomes the tool name i.e. "gcc" becomes "gcc".
// This should work for any custom arbitrary platform.
return String.Empty;
}
}
static string GetPlatformArch(AndroidTargetArch arch)
{
switch (arch) {
case AndroidTargetArch.Arm:
return "arm";
case AndroidTargetArch.Arm64:
return "arm64";
case AndroidTargetArch.Mips:
return "mips";
case AndroidTargetArch.X86:
return "x86";
case AndroidTargetArch.X86_64:
return "x86_64";
}
return null;
}
public static string GetNdkToolPrefix(string androidNdkPath, AndroidTargetArch arch)
{
var path = GetNdkTool (androidNdkPath, arch, "as");
if (path != null)
path = path.Substring (0, path.LastIndexOf ("-") + 1);
return path;
}
public static bool IsNdk64BitArch(AndroidTargetArch arch)
{
return arch == AndroidTargetArch.Arm64 || arch == AndroidTargetArch.X86_64;
}
static bool ValidateAotConfiguration(TaskLoggingHelper log, AndroidTargetArch arch, bool enableLLVM)
{
if (arch == AndroidTargetArch.Arm64 && enableLLVM) {
log.LogCodedError ("XA3004", "arm64-v8a architecture is not currently supported on LLVM AOT mode.");
return false;
}
if (arch == AndroidTargetArch.X86_64) {
log.LogCodedError ("XA3004", "x86_64 architecture is not currently supported on AOT mode.");
return false;
}
return true;
}
