X-Git-Url: https://git.openssl.org/?a=blobdiff_plain;f=Configurations%2F15-android.conf;h=69c3693d955fb96b636dc787bef9606d8b7aae53;hb=ef071222020be2096fb9f3aaef8bfe18ae9a40c9;hp=36daf3179b15f2ff7b2048f6dece023142994216;hpb=87ba25ee3fd152d807496609e821a9f5fc950d02;p=openssl.git diff --git a/Configurations/15-android.conf b/Configurations/15-android.conf index 36daf3179b..69c3693d95 100644 --- a/Configurations/15-android.conf +++ b/Configurations/15-android.conf @@ -1,29 +1,11 @@ #### Android... # -# It takes *one* prior-set environment variable to make it work: -# -# ANDROID_NDK=/some/where/android-ndk- -# -# As well as PATH *adjusted* to cover ${CROSS_COMPILE}gcc and company. -# -# Note that it's different from original instructions that required to -# set CROSS_SYSROOT [to $ANDROID_NDK/platforms/android-/arch-] -# and CROSS_COMPILE. CROSS_SYSROOT is still recognized [and even required -# for some legacy targets], but if not set, it's detected and set to the -# latest Android platform available with appointed NDK automatically. If -# you need to target older platform, pass additional -D__ANDROID_API__=N -# to Configure. For example, to compile for ICS on ARM with NDK 10d: -# -# ANDROID_NDK=/some/where/android-ndk-10d -# PATH=$ANDROID_NDK/toolchains/arm-linux-androideabi-4.8/prebuild/linux-x86_64/bin:$PATH -# [..]./Configure android-arm -D__ANDROID_API__=14 -# -# One can engage clang by passing CC=clang to Configure. In such case -# PATH needs even more adjustments to cover NDK's clang itself, as well -# as unprefixed, yet target-specific ar and ranlib [or not, if you use -# binutils-multiarch]. +# See NOTES.ANDROID for details, and don't miss platform-specific +# comments below... { + use File::Spec::Functions; + my $android_ndk = {}; my %triplet = ( arm => "arm-linux-androideabi", @@ -36,55 +18,111 @@ sub android_ndk { unless (%$android_ndk) { - my $ndk = $ENV{ANDROID_NDK}; - die "\$ANDROID_NDK is not defined" if (!$ndk); - die "\$ANDROID_NDK=$ndk is invalid" if (!-d "$ndk/platforms"); + if ($now_printing =~ m|^android|) { + return $android_ndk = { bn_ops => "BN_AUTO" }; + } + + my $ndk_var; + my $ndk; + foreach (qw(ANDROID_NDK_HOME ANDROID_NDK)) { + $ndk_var = $_; + $ndk = $ENV{$ndk_var}; + last if defined $ndk; + } + die "\$ANDROID_NDK_HOME is not defined" if (!$ndk); + if (!-d "$ndk/platforms" && !-f "$ndk/AndroidVersion.txt") { + # $ndk/platforms is traditional "all-inclusive" NDK, while + # $ndk/AndroidVersion.txt is so-called standalone toolchain + # tailored for specific target down to API level. + die "\$ANDROID_NDK_HOME=$ndk is invalid"; + } + $ndk = canonpath($ndk); + + my $ndkver = undef; + + if (open my $fh, "<$ndk/source.properties") { + local $_; + while(<$fh>) { + if (m|Pkg\.Revision\s*=\s*([0-9]+)|) { + $ndkver = $1; + last; + } + } + close $fh; + } + + my ($sysroot, $api, $arch); - my $sysroot; + $config{target} =~ m|[^-]+-([^-]+)$|; # split on dash + $arch = $1; - if (!($sysroot = $ENV{CROSS_SYSROOT})) { - my $api = "*"; + if ($sysroot = $ENV{CROSS_SYSROOT}) { + $sysroot =~ m|/android-([0-9]+)/arch-(\w+)/?$|; + ($api, $arch) = ($1, $2); + } elsif (-f "$ndk/AndroidVersion.txt") { + $sysroot = "$ndk/sysroot"; + } else { + $api = "*"; # see if user passed -D__ANDROID_API__=N - foreach (@{$useradd{CPPDEFINES}}) { + foreach (@{$useradd{CPPDEFINES}}, @{$user{CPPFLAGS}}) { if (m|__ANDROID_API__=([0-9]+)|) { $api = $1; last; } } - # list available platforms [numerically] + # list available platforms (numerically) my @platforms = sort { $a =~ m/-([0-9]+)$/; my $aa = $1; $b =~ m/-([0-9]+)$/; $aa <=> $1; } glob("$ndk/platforms/android-$api"); die "no $ndk/platforms/android-$api" if ($#platforms < 0); - $config{target} =~ m|[^-]+-([^-]+)$|; # split on dash - $sysroot = "@platforms[$#platforms]/arch-$1"; + $sysroot = "@platforms[$#platforms]/arch-$arch"; + $sysroot =~ m|/android-([0-9]+)/arch-$arch|; + $api = $1; } die "no sysroot=$sysroot" if (!-d $sysroot); - $sysroot =~ m|/android-([0-9]+)/arch-(\w+)/?$|; - my ($api, $arch) = ($1, $2); - my $triarch = $triplet{$arch}; - my $cflags = "-Wa,--noexecstack"; + my $cflags; my $cppflags; - # see if user passed CC=clang - if ($user{CC} eq "clang") { - if (which("clang") !~ m|^$ndk/.*/prebuilt/([^/]+)/|) { - die "no NDK clang on \$PATH"; - } + # see if there is NDK clang on $PATH, "universal" or "standalone" + if (which("clang") =~ m|^$ndk/.*/prebuilt/([^/]+)/|) { my $host=$1; # harmonize with gcc default - (my $tridefault = $triarch) =~ s/^arm-/armv5te-/; + my $arm = $ndkver > 16 ? "armv7a" : "armv5te"; + (my $tridefault = $triarch) =~ s/^arm-/$arm-/; (my $tritools = $triarch) =~ s/(?:x|i6)86(_64)?-.*/x86$1/; $cflags .= " -target $tridefault " - . "-gcc-toolchain \$(ANDROID_NDK)/toolchains" + . "-gcc-toolchain \$($ndk_var)/toolchains" . "/$tritools-4.9/prebuilt/$host"; + $user{CC} = "clang" if ($user{CC} !~ m|clang|); $user{CROSS_COMPILE} = undef; + if (which("llvm-ar") =~ m|^$ndk/.*/prebuilt/([^/]+)/|) { + $user{AR} = "llvm-ar"; + $user{ARFLAGS} = [ "rs" ]; + $user{RANLIB} = ":"; + } + } elsif (-f "$ndk/AndroidVersion.txt") { #"standalone toolchain" + my $cc = $user{CC} // "clang"; + # One can probably argue that both clang and gcc should be + # probed, but support for "standalone toolchain" was added + # *after* announcement that gcc is being phased out, so + # favouring clang is considered adequate. Those who insist + # have option to enforce test for gcc with CC=gcc. + if (which("$triarch-$cc") !~ m|^$ndk|) { + die "no NDK $triarch-$cc on \$PATH"; + } + $user{CC} = $cc; + $user{CROSS_COMPILE} = "$triarch-"; + } elsif ($user{CC} eq "clang") { + die "no NDK clang on \$PATH"; } else { + if (which("$triarch-gcc") !~ m|^$ndk/.*/prebuilt/([^/]+)/|) { + die "no NDK $triarch-gcc on \$PATH"; + } $cflags .= " -mandroid"; $user{CROSS_COMPILE} = "$triarch-"; } @@ -95,13 +133,13 @@ die "no $incroot/$triarch" if (!-d "$incroot/$triarch"); $incroot =~ s|^$ndk/||; $cppflags = "-D__ANDROID_API__=$api"; - $cppflags .= " -isystem \$(ANDROID_NDK)/$incroot/$triarch"; - $cppflags .= " -isystem \$(ANDROID_NDK)/$incroot"; + $cppflags .= " -isystem \$($ndk_var)/$incroot/$triarch"; + $cppflags .= " -isystem \$($ndk_var)/$incroot"; } $sysroot =~ s|^$ndk/||; $android_ndk = { - cflags => "$cflags --sysroot=\$(ANDROID_NDK)/$sysroot", + cflags => "$cflags --sysroot=\$($ndk_var)/$sysroot", cppflags => $cppflags, bn_ops => $arch =~ m/64$/ ? "SIXTY_FOUR_BIT_LONG" : "BN_LLONG", @@ -131,6 +169,7 @@ my %targets = ( cxxflags => add(sub { android_ndk()->{cflags} }), bn_ops => sub { android_ndk()->{bn_ops} }, bin_cflags => "-pie", + enable => [ ], }, "android-arm" => { ################################################################ @@ -141,7 +180,7 @@ my %targets = ( # ability to engage NEON is not constrained by ABI choice, nor # is your ability to call OpenSSL from your application code # compiled with floating-point ABI other than default 'soft'. - # [Latter thanks to __attribute__((pcs("aapcs"))) declaration.] + # (Latter thanks to __attribute__((pcs("aapcs"))) declaration.) # This means that choice of ARM libraries you provide in .apk # is driven by application needs. For example if application # itself benefits from NEON or is floating-point intensive, then @@ -154,23 +193,28 @@ my %targets = ( # in order to build "universal" binary and allow OpenSSL take # advantage of NEON when it's available. # - # Keep in mind that [just like with linux-armv4] we rely on + # Keep in mind that (just like with linux-armv4) we rely on # compiler defaults, which is not necessarily what you had # in mind, in which case you would have to pass additional # -march and/or -mfloat-abi flags. NDK defaults to armv5te. + # Newer NDK versions reportedly require additional -latomic. # - inherit_from => [ "android", asm("armv4_asm") ], + inherit_from => [ "android" ], bn_ops => add("RC4_CHAR"), + asm_arch => 'armv4', + perlasm_scheme => "void", }, "android-arm64" => { - inherit_from => [ "android", asm("aarch64_asm") ], + inherit_from => [ "android" ], bn_ops => add("RC4_CHAR"), + asm_arch => 'aarch64', perlasm_scheme => "linux64", }, "android-mips" => { - inherit_from => [ "android", asm("mips32_asm") ], + inherit_from => [ "android" ], bn_ops => add("RC4_CHAR"), + asm_arch => 'mips32', perlasm_scheme => "o32", }, "android-mips64" => { @@ -183,25 +227,28 @@ my %targets = ( # with previous MIPS ISA versions, in sense that unlike # prior versions original MIPS binary code will fail. # - inherit_from => [ "android", asm("mips64_asm") ], + inherit_from => [ "android" ], bn_ops => add("RC4_CHAR"), + asm_arch => 'mips64', perlasm_scheme => "64", }, "android-x86" => { - inherit_from => [ "android", asm("x86_asm") ], + inherit_from => [ "android" ], CFLAGS => add(picker(release => "-fomit-frame-pointer")), bn_ops => add("RC4_INT"), + asm_arch => 'x86', perlasm_scheme => "android", }, "android-x86_64" => { - inherit_from => [ "android", asm("x86_64_asm") ], + inherit_from => [ "android" ], bn_ops => add("RC4_INT"), + asm_arch => 'x86_64', perlasm_scheme => "elf", }, #################################################################### - # Backward compatible targets, [might] requre $CROSS_SYSROOT + # Backward compatible targets, (might) requre $CROSS_SYSROOT # "android-armeabi" => { inherit_from => [ "android-arm" ],