## -*- mode: perl; -*-

## Standard openssl configuration targets.

# Helper functions for the Windows configs

my $vc_win64a_info = {};

sub vc_win64a_info {

unless (%$vc_win64a_info) {

# Minimum NASM version is 2.09 otherwise SHA3 might be miscompiled

if (`nasm -v 2>NUL` =~ /NASM version ([0-9]+)\.([0-9]+)/ && ($1 > 2 || ($1 == 2 && $2 >= 9))) {

$vc_win64a_info = { AS => "nasm",

ASFLAGS => "-g",

asflags => "-Ox -f win64 -DNEAR",

asoutflag => "-o ",

perlasm_scheme => "nasm" };

} elsif ($disabled{asm}) {

# assembler is still used to compile uplink shim

$vc_win64a_info = { AS => "ml64",

ASFLAGS => "/nologo /Zi",

asflags => "/c /Cp /Cx",

asoutflag => "/Fo",

perlasm_scheme => "masm" };

} else {

$die->("NASM not found - make sure it's installed and available on %PATH%\n");

$vc_win64a_info = { AS => "{unknown}",

ASFLAGS => "",

asflags => "",

asoutflag => "",

perlasm_scheme => "auto" };

}

}

return $vc_win64a_info;

}

my $vc_win32_info = {};

sub vc_win32_info {

unless (%$vc_win32_info) {

my $ver=`nasm -v 2>NUL`;

my $vew=`nasmw -v 2>NUL`;

if ($ver ne "" || $vew ne "") {

$vc_win32_info = { AS => $ver ge $vew ? "nasm" : "nasmw",

ASFLAGS => "",

asflags => "-f win32",

asoutflag => "-o ",

perlasm_scheme => "win32n" };

} elsif ($disabled{asm}) {

# not actually used, uplink shim is inlined into C code

$vc_win32_info = { AS => "ml",

ASFLAGS => "/nologo /Zi",

asflags => "/Cp /coff /c /Cx",

asoutflag => "/Fo",

perlasm_scheme => "win32" };

} else {

$die->("NASM not found - make sure it's installed and available on %PATH%\n");

$vc_win32_info = { AS => "{unknown}",

ASFLAGS => "",

asflags => "",

asoutflag => "",

perlasm_scheme => "win32" };

}

}

return $vc_win32_info;

}

my $vc_wince_info = {};

sub vc_wince_info {

unless (%$vc_wince_info) {

# sanity check

$die->('%OSVERSION% is not defined') if (!defined(env('OSVERSION')));

$die->('%PLATFORM% is not defined') if (!defined(env('PLATFORM')));

$die->('%TARGETCPU% is not defined') if (!defined(env('TARGETCPU')));

#

# Idea behind this is to mimic flags set by eVC++ IDE...

#

my $wcevers = env('OSVERSION'); # WCENNN

my $wcevernum;

my $wceverdotnum;

if ($wcevers =~ /^WCE([1-9])([0-9]{2})$/) {

$wcevernum = "$1$2";

$wceverdotnum = "$1.$2";

} else {

$die->('%OSVERSION% value is insane');

$wcevernum = "{unknown}";

$wceverdotnum = "{unknown}";

}

my $wcecdefs = "-D_WIN32_WCE=$wcevernum -DUNDER_CE=$wcevernum"; # -D_WIN32_WCE=NNN

my $wcelflag = "/subsystem:windowsce,$wceverdotnum"; # ...,N.NN

my $wceplatf = env('PLATFORM');

$wceplatf =~ tr/a-z0-9 /A-Z0-9_/;

$wcecdefs .= " -DWCE_PLATFORM_$wceplatf";

my $wcetgt = env('TARGETCPU'); # just shorter name...

SWITCH: for($wcetgt) {

/^X86/ && do { $wcecdefs.=" -Dx86 -D_X86_ -D_i386_ -Di_386_";

$wcelflag.=" /machine:X86"; last; };

/^ARMV4[IT]/ && do { $wcecdefs.=" -DARM -D_ARM_ -D$wcetgt";

$wcecdefs.=" -DTHUMB -D_THUMB_" if($wcetgt=~/T$/);

$wcecdefs.=" -QRarch4T -QRinterwork-return";

$wcelflag.=" /machine:THUMB"; last; };

/^ARM/ && do { $wcecdefs.=" -DARM -D_ARM_ -D$wcetgt";

$wcelflag.=" /machine:ARM"; last; };

/^MIPSIV/ && do { $wcecdefs.=" -DMIPS -D_MIPS_ -DR4000 -D$wcetgt";

$wcecdefs.=" -D_MIPS64 -QMmips4 -QMn32";

$wcelflag.=" /machine:MIPSFPU"; last; };

/^MIPS16/ && do { $wcecdefs.=" -DMIPS -D_MIPS_ -DR4000 -D$wcetgt";

$wcecdefs.=" -DMIPSII -QMmips16";

$wcelflag.=" /machine:MIPS16"; last; };

/^MIPSII/ && do { $wcecdefs.=" -DMIPS -D_MIPS_ -DR4000 -D$wcetgt";

$wcecdefs.=" -QMmips2";

$wcelflag.=" /machine:MIPS"; last; };

/^R4[0-9]{3}/ && do { $wcecdefs.=" -DMIPS -D_MIPS_ -DR4000";

$wcelflag.=" /machine:MIPS"; last; };

/^SH[0-9]/ && do { $wcecdefs.=" -D$wcetgt -D_${wcetgt}_ -DSHx";

$wcecdefs.=" -Qsh4" if ($wcetgt =~ /^SH4/);

$wcelflag.=" /machine:$wcetgt"; last; };

{ $wcecdefs.=" -D$wcetgt -D_${wcetgt}_";

$wcelflag.=" /machine:$wcetgt"; last; };

}

$vc_wince_info = { cppflags => $wcecdefs,

lflags => $wcelflag };

}

return $vc_wince_info;

}

# Helper functions for the VMS configs

my $vms_info = {};

sub vms_info {

my $pointer_size_str = $config{target} =~ m|-p(\d+)$| ? $1 : "";

# For the case where Configure iterate through all config targets, such

# as when listing them and their details, we reset info if the pointer

# size changes.

if (%$vms_info && $vms_info->{pointer_size} ne $pointer_size_str) {

$vms_info = {};

}

unless (%$vms_info) {

$vms_info->{disable_warns} = [

"CXXPRAGMANA", # Shut up about unknown / unsupported pragmas

];

$vms_info->{pointer_size} = $pointer_size_str;

if ($pointer_size_str eq "64") {

`PIPE CC /NOCROSS_REFERENCE /NOLIST /NOOBJECT /WARNINGS = DISABLE = ( MAYLOSEDATA3, EMPTYFILE ) NL: 2> NL:`;

if ($? == 0) {

push @{$vms_info->{disable_warns}}, "MAYLOSEDATA3";

}

}

unless ($disabled{zlib}) {

my $default_zlib = 'GNV$LIBZSHR' . $pointer_size_str;

if (defined($disabled{"zlib-dynamic"})) {

$vms_info->{zlib} = $withargs{zlib_lib} || "$default_zlib/SHARE";

} else {

$vms_info->{def_zlib} = $withargs{zlib_lib} || $default_zlib;

# In case the --with-zlib-lib value contains something like

# /SHARE or /LIB or so at the end, remove it.

$vms_info->{def_zlib} =~ s|/.*$||g;

}

}

if ($config{target} =~ /-ia64/) {

`PIPE ias -H 2> NL:`;

if ($? == 0) {

$vms_info->{AS} = "ias";

$vms_info->{ASFLAGS} = '-d debug';

$vms_info->{asflags} = '"-N" vms_upcase';

$vms_info->{asoutflag} = "-o ";

$vms_info->{perlasm_scheme} = "ias";

}

}

}

return $vms_info;

}

my %targets = (

#### Basic configs that should work on any 32-bit box

"gcc" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CFLAGS => picker(debug => "-O0 -g",

release => "-O3"),

thread_scheme => "(unknown)",

bn_ops => "BN_LLONG",

},

"cc" => {

inherit_from => [ "BASE_unix" ],

CC => "cc",

CFLAGS => "-O",

thread_scheme => "(unknown)",

},

#### VOS Configurations

"vos-gcc" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CFLAGS => picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3"),

cppflags => "-D_POSIX_C_SOURCE=200112L -D_BSD -D_VOS_EXTENDED_NAMES",

lib_cppflags => "-DB_ENDIAN",

thread_scheme => "(unknown)",

sys_id => "VOS",

lflags => add("-Wl,-map"),

bn_ops => "BN_LLONG",

shared_extension => ".so",

},

#### Solaris configurations

"solaris-common" => {

inherit_from => [ "BASE_unix" ],

template => 1,

lib_cppflags => "-DFILIO_H",

ex_libs => add("-lsocket -lnsl -ldl"),

dso_scheme => "dlfcn",

thread_scheme => "pthreads",

},

#### Solaris common with Sun C setups

"solaris-common-cc" => {

inherit_from => [ "solaris-common" ],

template => 1,

shared_target => "solaris",

shared_ldflag => "-Wl,-Bsymbolic",

shared_defflag => "-Wl,-M,",

shared_sonameflag=> "-Wl,-h,",

},

#### Solaris common with GNU C setups

"solaris-common-gcc" => {

inherit_from => [ "solaris-common" ],

template => 1,

shared_target => "solaris-gcc-shared", # The rest is on shared_info.pl

},

#### Solaris x86 with GNU C setups

"solaris-x86-gcc" => {

# NB. GNU C has to be configured to use GNU assembler, and not

# /usr/ccs/bin/as. Failure to comply will result in compile

# failures [at least] in 32-bit build.

inherit_from => [ "solaris-common-gcc" ],

CC => "gcc",

CFLAGS => add_before(picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3 -fomit-frame-pointer")),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "BN_LLONG",

shared_cflag => "-fPIC",

shared_ldflag => add_before("-shared -static-libgcc"),

asm_arch => 'x86',

perlasm_scheme => 'elf',

},

"solaris64-x86_64-gcc" => {

# -shared -static-libgcc might appear controversial, but modules

# taken from static libgcc do not have relocations and linking

# them into our shared objects doesn't have any negative side

# effects. On the contrary, doing so makes it possible to use

# gcc shared build with Sun C. Given that gcc generates faster

# code [thanks to inline assembler], I would actually recommend

# to consider using gcc shared build even with vendor compiler:-)

# -- <[email protected]>

inherit_from => [ "solaris-common-gcc" ],

CC => "gcc",

CFLAGS => add_before(picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3")),

cflags => add("-m64"),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'x86_64',

perlasm_scheme => "elf",

shared_cflag => "-fPIC",

shared_ldflag => add_before("-shared -static-libgcc"),

multilib => "/64",

},

#### Solaris x86 with Sun C setups

# There used to be solaris-x86-cc target, but it was removed,

# primarily because vendor assembler can't assemble our modules

# with -KPIC flag. As result it, assembly support, was not even

# available as option. But its lack means lack of side-channel

# resistant code, which is incompatible with security by today's

# standards. Fortunately gcc is readily available prepackaged

# option, which we can firmly point at...

#

# On related note, solaris64-x86_64-cc target won't compile code

# paths utilizing AVX and post-Haswell instruction extensions.

# Consider switching to solaris64-x86_64-gcc even here...

#

"solaris64-x86_64-cc" => {

inherit_from => [ "solaris-common-cc" ],

CC => "cc",

CFLAGS => add_before(picker(debug => "-g",

release => "-xO5 -xdepend -xbuiltin")),

cflags => add_before("-xarch=generic64 -xstrconst -Xa"),

cppflags => add(threads("-D_REENTRANT")),

lib_cppflags => add("-DL_ENDIAN"),

thread_scheme => "pthreads",

lflags => add(threads("-mt")),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'x86_64',

perlasm_scheme => "elf",

shared_cflag => "-KPIC",

shared_ldflag => add_before("-G -dy -z text"),

multilib => "/64",

},

#### SPARC Solaris with GNU C setups

"solaris-sparcv7-gcc" => {

inherit_from => [ "solaris-common-gcc" ],

CC => "gcc",

CFLAGS => add_before(picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3")),

lib_cppflags => add("-DB_ENDIAN -DBN_DIV2W"),

bn_ops => "BN_LLONG RC4_CHAR",

shared_cflag => "-fPIC",

shared_ldflag => add_before("-shared -static-libgcc"),

},

"solaris-sparcv8-gcc" => {

inherit_from => [ "solaris-sparcv7-gcc" ],

cflags => add_before("-mcpu=v8"),

asm_arch => 'sparcv8',

perlasm_scheme => 'void',

},

"solaris-sparcv9-gcc" => {

# -m32 should be safe to add as long as driver recognizes

# -mcpu=ultrasparc

inherit_from => [ "solaris-sparcv7-gcc" ],

cflags => add_before("-m32 -mcpu=ultrasparc"),

asm_arch => 'sparcv9',

perlasm_scheme => 'void',

},

"solaris64-sparcv9-gcc" => {

inherit_from => [ "solaris-sparcv9-gcc" ],

cflags => sub { my $f=join(" ",@_); $f =~ s/\-m32/-m64/; $f; },

bn_ops => "BN_LLONG RC4_CHAR",

multilib => "/64",

},

#### SPARC Solaris with Sun C setups

# SC4.0 doesn't pass 'make test', upgrade to SC5.0 or SC4.2.

# SC4.2 is ok, better than gcc even on bn as long as you tell it -xarch=v8

# SC5.0 note: Compiler common patch 107357-01 or later is required!

"solaris-sparcv7-cc" => {

inherit_from => [ "solaris-common-cc" ],

CC => "cc",

CFLAGS => add_before(picker(debug => "-g",

release => "-xO5 -xdepend")),

cflags => add_before("-xstrconst -Xa"),

cppflags => add(threads("-D_REENTRANT")),

lib_cppflags => add("-DB_ENDIAN -DBN_DIV2W"),

lflags => add(threads("-mt")),

bn_ops => "BN_LLONG RC4_CHAR",

shared_cflag => "-KPIC",

shared_ldflag => add_before("-G -dy -z text"),

},

####

"solaris-sparcv8-cc" => {

inherit_from => [ "solaris-sparcv7-cc" ],

cflags => add_before("-xarch=v8"),

asm_arch => 'sparcv8',

perlasm_scheme => 'void',

},

"solaris-sparcv9-cc" => {

inherit_from => [ "solaris-sparcv7-cc" ],

cflags => add_before("-xarch=v8plus"),

asm_arch => 'sparcv9',

perlasm_scheme => 'void',

},

"solaris64-sparcv9-cc" => {

inherit_from => [ "solaris-sparcv7-cc" ],

cflags => add_before("-m64 -xarch=sparc"),

bn_ops => "BN_LLONG RC4_CHAR",

asm_arch => 'sparcv9',

perlasm_scheme => 'void',

multilib => "/64",

},

#### IRIX 6.x configs

# Only N32 and N64 ABIs are supported.

"irix-common" => {

inherit_from => [ "BASE_unix" ],

template => 1,

cppflags => threads("-D_SGI_MP_SOURCE"),

lib_cppflags => "-DB_ENDIAN",

ex_libs => add(threads("-lpthread")),

thread_scheme => "pthreads",

dso_scheme => "dlfcn",

shared_target => "self",

shared_ldflag => "-shared -Wl,-Bsymbolic",

shared_sonameflag=> "-Wl,-soname,",

},

"irix-mips3-gcc" => {

inherit_from => [ "irix-common" ],

CC => "gcc",

CFLAGS => picker(debug => "-g -O0",

release => "-O3"),

LDFLAGS => "-static-libgcc",

cflags => "-mabi=n32",

bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",

asm_arch => 'mips64',

perlasm_scheme => "n32",

multilib => "32",

},

"irix-mips3-cc" => {

inherit_from => [ "irix-common" ],

CC => "cc",

CFLAGS => picker(debug => "-g -O0",

release => "-O2"),

cflags => "-n32 -mips3 -use_readonly_const -G0 -rdata_shared",

bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",

asm_arch => 'mips64',

perlasm_scheme => "n32",

multilib => "32",

},

# N64 ABI builds.

"irix64-mips4-gcc" => {

inherit_from => [ "irix-common" ],

CC => "gcc",

CFLAGS => picker(debug => "-g -O0",

release => "-O3"),

LDFLAGS => "-static-libgcc",

cflags => "-mabi=64 -mips4",

bn_ops => "RC4_CHAR SIXTY_FOUR_BIT_LONG",

asm_arch => 'mips64',

perlasm_scheme => "64",

multilib => "64",

},

"irix64-mips4-cc" => {

inherit_from => [ "irix-common" ],

CC => "cc",

CFLAGS => picker(debug => "-g -O0",

release => "-O2"),

cflags => "-64 -mips4 -use_readonly_const -G0 -rdata_shared",

bn_ops => "RC4_CHAR SIXTY_FOUR_BIT_LONG",

asm_arch => 'mips64',

perlasm_scheme => "64",

multilib => "64",

},

#### Unified HP-UX ANSI C configs.

# Special notes:

# - Originally we were optimizing at +O4 level. It should be noted

# that the only difference between +O3 and +O4 is global inter-

# procedural analysis. As it has to be performed during the link

# stage the compiler leaves behind certain pseudo-code in lib*.a

# which might be release or even patch level specific. Generating

# the machine code for and analyzing the *whole* program appears

# to be *extremely* memory demanding while the performance gain is

# actually questionable. The situation is intensified by the default

# HP-UX data set size limit (infamous 'maxdsiz' tunable) of 64MB

# which is way too low for +O4. In other words, doesn't +O3 make

# more sense?

# - Keep in mind that the HP compiler by default generates code

# suitable for execution on the host you're currently compiling at.

# If the toolkit is meant to be used on various PA-RISC processors

# consider './Configure hpux-parisc-[g]cc +DAportable'.

# - -DMD32_XARRAY triggers workaround for compiler bug we ran into in

# 32-bit message digests. (For the moment of this writing) HP C

# doesn't seem to "digest" too many local variables (they make "him"

# chew forever:-). For more details look-up MD32_XARRAY comment in

# crypto/sha/sha_local.h.

# - originally there were 32-bit hpux-parisc2-* targets. They were

# scrapped, because a) they were not interchangeable with other 32-bit

# targets; b) performance-critical 32-bit assembly modules implement

# even PA-RISC 2.0-specific code paths, which are chosen at run-time,

# thus adequate performance is provided even with PA-RISC 1.1 build.

"hpux-common" => {

inherit_from => [ "BASE_unix" ],

template => 1,

defines => add("_XOPEN_SOURCE", "_XOPEN_SOURCE_EXTENDED",

"_HPUX_ALT_XOPEN_SOCKET_API"),

lib_cppflags => "-DB_ENDIAN",

thread_scheme => "pthreads",

dso_scheme => "dlfcn", # overridden in 32-bit PA-RISC builds

shared_target => "self",

bin_lflags => "-Wl,+s,+cdp,../:,+cdp,./:",

shared_ldflag => "-Wl,-B,symbolic,+vnocompatwarnings,-z,+s,+cdp,../:,+cdp,./:",

shared_sonameflag=> "-Wl,+h,",

},

"hpux-parisc-gcc" => {

inherit_from => [ "hpux-common" ],

CC => "gcc",

CFLAGS => picker(debug => "-O0 -g",

release => "-O3"),

cflags => add(threads("-pthread")),

lib_cppflags => add("-DBN_DIV2W"),

ex_libs => add("-ldld", threads("-pthread")),

bn_ops => "BN_LLONG RC4_CHAR",

dso_scheme => "dl",

shared_cflag => "-fPIC",

shared_ldflag => add_before("-shared"),

shared_extension => ".sl.\$(SHLIB_VERSION_NUMBER)",

},

"hpux-parisc1_1-gcc" => {

inherit_from => [ "hpux-parisc-gcc" ],

asm_arch => 'parisc11',

perlasm_scheme => "32",

multilib => "/pa1.1",

},

"hpux64-parisc2-gcc" => {

inherit_from => [ "hpux-common" ],

CC => "gcc",

CFLAGS => combine(picker(debug => "-O0 -g",

release => "-O3")),

cflags => add(threads("-pthread")),

ex_libs => add("-ldl", threads("-pthread")),

bn_ops => "SIXTY_FOUR_BIT_LONG RC4_CHAR",

asm_arch => 'parisc20_64',

perlasm_scheme => "64",

shared_cflag => "-fpic",

shared_ldflag => add_before("-shared"),

shared_extension => ".sl.\$(SHLIB_VERSION_NUMBER)",

multilib => "/pa20_64",

},

# More attempts at unified 10.X and 11.X targets for HP C compiler.

"hpux-parisc-cc" => {

inherit_from => [ "hpux-common" ],

CC => "cc",

CFLAGS => picker(debug => "+O0 +d -g",

release => "+O3"),

cflags => "+Optrs_strongly_typed -Ae +ESlit",

cppflags => threads("-D_REENTRANT"),

lib_cppflags => add("-DBN_DIV2W -DMD32_XARRAY"),

ex_libs => add("-ldld", threads("-lpthread")),

bn_ops => "RC4_CHAR",

dso_scheme => "dl",

shared_cflag => "+Z",

shared_ldflag => add_before("-b"),

shared_extension => ".sl.\$(SHLIB_VERSION_NUMBER)",

},

"hpux-parisc1_1-cc" => {

inherit_from => [ "hpux-parisc-cc" ],

cflags => add_before("+DA1.1"),

asm_arch => 'parisc11',

perlasm_scheme => "32",

multilib => "/pa1.1",

},

"hpux64-parisc2-cc" => {

inherit_from => [ "hpux-common" ],

CC => "cc",

CFLAGS => picker(debug => "+O0 +d -g",

release => "+O3") ,

cflags => "+DD64 +Optrs_strongly_typed -Ae +ESlit",

cppflags => threads("-D_REENTRANT") ,

lib_cppflags => add("-DMD32_XARRAY"),

ex_libs => add("-ldl", threads("-lpthread")),

bn_ops => "SIXTY_FOUR_BIT_LONG RC4_CHAR",

asm_arch => 'parisc20_64',

perlasm_scheme => "64",

shared_cflag => "+Z",

shared_ldflag => add_before("-b"),

shared_extension => ".sl.\$(SHLIB_VERSION_NUMBER)",

multilib => "/pa20_64",

},

# HP/UX IA-64 targets

"hpux-ia64-cc" => {

inherit_from => [ "hpux-common" ],

CC => "cc",

CFLAGS => picker(debug => "+O0 +d -g",

release => "+O2"),

cflags => "-Ae +DD32 +Olit=all -z",

cppflags => add(threads("-D_REENTRANT")),

ex_libs => add("-ldl", threads("-lpthread")),

bn_ops => "SIXTY_FOUR_BIT",

asm_arch => 'ia64',

perlasm_scheme => 'void',

shared_cflag => "+Z",

shared_ldflag => add_before("-b"),

multilib => "/hpux32",

},

"hpux64-ia64-cc" => {

inherit_from => [ "hpux-common" ],

CC => "cc",

CFLAGS => picker(debug => "+O0 +d -g",

release => "+O3"),

cflags => "-Ae +DD64 +Olit=all -z",

cppflags => threads("-D_REENTRANT"),

ex_libs => add("-ldl", threads("-lpthread")),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'ia64',

perlasm_scheme => 'void',

shared_cflag => "+Z",

shared_ldflag => add_before("-b"),

multilib => "/hpux64",

},

# GCC builds...

"hpux-ia64-gcc" => {

inherit_from => [ "hpux-common" ],

CC => "gcc",

CFLAGS => picker(debug => "-O0 -g",

release => "-O3"),

cflags => add(threads("-pthread")),

ex_libs => add("-ldl", threads("-pthread")),

bn_ops => "SIXTY_FOUR_BIT",

asm_arch => 'ia64',

perlasm_scheme => 'void',

shared_cflag => "-fpic",

shared_ldflag => add_before("-shared"),

multilib => "/hpux32",

},

"hpux64-ia64-gcc" => {

inherit_from => [ "hpux-common" ],

CC => "gcc",

CFLAGS => picker(debug => "-O0 -g",

release => "-O3"),

cflags => combine("-mlp64", threads("-pthread")),

ex_libs => add("-ldl", threads("-pthread")),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'ia64',

perlasm_scheme => 'void',

shared_cflag => "-fpic",

shared_ldflag => add_before("-shared"),

multilib => "/hpux64",

},

#### HP MPE/iX http://jazz.external.hp.com/src/openssl/

"MPE/iX-gcc" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CFLAGS => "-O3",

cppflags => "-D_POSIX_SOURCE -D_SOCKET_SOURCE",

includes => [ "/SYSLOG/PUB" ],

lib_cppflags => "-DBN_DIV2W",

sys_id => "MPE",

lflags => add("-L/SYSLOG/PUB"),

ex_libs => add("-lsyslog -lsocket -lcurses"),

thread_scheme => "(unknown)",

bn_ops => "BN_LLONG",

},

#### DEC Alpha Tru64 targets. Tru64 is marketing name for OSF/1 version 4

#### and forward. In reality 'uname -s' still returns "OSF1". Originally

#### there were even osf1-* configs targeting prior versions provided,

#### but not anymore...

"tru64-alpha-gcc" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CFLAGS => "-O3",

cflags => add("-std=c9x", threads("-pthread")),

cppflags => "-D_XOPEN_SOURCE=500 -D_OSF_SOURCE",

ex_libs => add("-lrt", threads("-pthread")), # for mlock(2)

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'alpha',

perlasm_scheme => "void",

thread_scheme => "pthreads",

dso_scheme => "dlfcn",

shared_target => "alpha-osf1-shared",

shared_extension => ".so",

},

"tru64-alpha-cc" => {

inherit_from => [ "BASE_unix" ],

CC => "cc",

CFLAGS => "-tune host -fast",

cflags => add("-std1 -readonly_strings",

threads("-pthread")),

cppflags => "-D_XOPEN_SOURCE=500 -D_OSF_SOURCE",

ex_libs => add("-lrt", threads("-pthread")), # for mlock(2)

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'alpha',

perlasm_scheme => "void",

thread_scheme => "pthreads",

dso_scheme => "dlfcn",

shared_target => "alpha-osf1-shared",

shared_ldflag => "-msym",

shared_extension => ".so",

},

####

#### Variety of LINUX:-)

####

# *-generic* is endian-neutral target, but ./config is free to

# throw in -D[BL]_ENDIAN, whichever appropriate...

"linux-generic32" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CXX => "g++",

CFLAGS => picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3"),

CXXFLAGS => picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3"),

cflags => threads("-pthread"),

cxxflags => combine("-std=c++11", threads("-pthread")),

lib_cppflags => "-DOPENSSL_USE_NODELETE",

ex_libs => add("-ldl", threads("-pthread")),

bn_ops => "BN_LLONG RC4_CHAR",

thread_scheme => "pthreads",

dso_scheme => "dlfcn",

shared_target => "linux-shared",

shared_cflag => "-fPIC",

shared_ldflag => sub { $disabled{pinshared} ? () : "-Wl,-znodelete" },

enable => [ "afalgeng" ],

},

"linux-latomic" => {

inherit_from => [ "linux-generic32" ],

ex_libs => add(threads("-latomic")),

},

"linux-generic64" => {

inherit_from => [ "linux-generic32" ],

bn_ops => "SIXTY_FOUR_BIT_LONG RC4_CHAR",

},

"linux-ppc" => {

inherit_from => [ "linux-latomic" ],

asm_arch => 'ppc32',

perlasm_scheme => "linux32",

lib_cppflags => add("-DB_ENDIAN"),

},

"linux-ppc64" => {

inherit_from => [ "linux-generic64" ],

cflags => add("-m64"),

cxxflags => add("-m64"),

lib_cppflags => add("-DB_ENDIAN"),

asm_arch => 'ppc64',

perlasm_scheme => "linux64",

multilib => "64",

},

"linux-ppc64le" => {

inherit_from => [ "linux-generic64" ],

cflags => add("-m64"),

cxxflags => add("-m64"),

lib_cppflags => add("-DL_ENDIAN"),

asm_arch => 'ppc64',

perlasm_scheme => "linux64le",

},

"linux-armv4" => {

################################################################

# Note that -march is not among compiler options in linux-armv4

# target description. Not specifying one is intentional to give

# you choice to:

#

# a) rely on your compiler default by not specifying one;

# b) specify your target platform explicitly for optimal

# performance, e.g. -march=armv6 or -march=armv7-a;

# c) build "universal" binary that targets *range* of platforms

# by specifying minimum and maximum supported architecture;

#

# As for c) option. It actually makes no sense to specify

# maximum to be less than ARMv7, because it's the least

# requirement for run-time switch between platform-specific

# code paths. And without run-time switch performance would be

# equivalent to one for minimum. Secondly, there are some

# natural limitations that you'd have to accept and respect.

# Most notably you can *not* build "universal" binary for

# big-endian platform. This is because ARMv7 processor always

# picks instructions in little-endian order. Another similar

# limitation is that -mthumb can't "cross" -march=armv6t2

# boundary, because that's where it became Thumb-2. Well, this

# limitation is a bit artificial, because it's not really

# impossible, but it's deemed too tricky to support. And of

# course you have to be sure that your binutils are actually

# up to the task of handling maximum target platform. With all

# this in mind here is an example of how to configure

# "universal" build:

#

# ./Configure linux-armv4 -march=armv6 -D__ARM_MAX_ARCH__=8

#

inherit_from => [ "linux-latomic" ],

asm_arch => 'armv4',

perlasm_scheme => "linux32",

},

"linux-aarch64" => {

inherit_from => [ "linux-generic64" ],

asm_arch => 'aarch64',

perlasm_scheme => "linux64",

},

"linux-arm64ilp32" => { # https://wiki.linaro.org/Platform/arm64-ilp32

inherit_from => [ "linux-generic32" ],

cflags => add("-mabi=ilp32"),

cxxflags => add("-mabi=ilp32"),

bn_ops => "SIXTY_FOUR_BIT RC4_CHAR",

asm_arch => 'aarch64',

perlasm_scheme => "linux64",

},

"linux-arm64ilp32-clang" => { # clang config abi by --target

inherit_from => [ "linux-generic32" ],

CC => "clang",

CXX => "clang++",

bn_ops => "SIXTY_FOUR_BIT RC4_CHAR",

asm_arch => 'aarch64',

perlasm_scheme => "linux64",

},

"linux-mips32" => {

# Configure script adds minimally required -march for assembly

# support, if no -march was specified at command line.

inherit_from => [ "linux-latomic" ],

cflags => add("-mabi=32"),

cxxflags => add("-mabi=32"),

asm_arch => 'mips32',

perlasm_scheme => "o32",

},

# mips32 and mips64 below refer to contemporary MIPS Architecture

# specifications, MIPS32 and MIPS64, rather than to kernel bitness.

"linux-mips64" => {

inherit_from => [ "linux-latomic" ],

cflags => add("-mabi=n32"),

cxxflags => add("-mabi=n32"),

bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",

asm_arch => 'mips64',

perlasm_scheme => "n32",

multilib => "32",

},

"linux64-mips64" => {

inherit_from => [ "linux-generic64" ],

cflags => add("-mabi=64"),

cxxflags => add("-mabi=64"),

asm_arch => 'mips64',

perlasm_scheme => "64",

multilib => "64",

},

# riscv below refers to contemporary RISCV Architecture

# specifications,

"linux64-riscv64" => {

inherit_from => [ "linux-generic64"],

perlasm_scheme => "linux64",

asm_arch => 'riscv64',

},

"linux32-riscv32" => {

inherit_from => [ "linux-latomic" ],

perlasm_scheme => "linux32",

asm_arch => 'riscv32',

},

# loongarch64 below refers to contemporary LoongArch Architecture

# specifications,

"linux64-loongarch64" => {

inherit_from => [ "linux-generic64"],

perlasm_scheme => "linux64",

asm_arch => 'loongarch64',

lib_cppflags => add("-DL_ENDIAN"),

},

#### IA-32 targets...

#### These two targets are a bit aged and are to be used on older Linux

#### machines where gcc doesn't understand -m32 and -m64

"linux-elf" => {

inherit_from => [ "linux-generic32" ],

CFLAGS => add(picker(release => "-fomit-frame-pointer")),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "BN_LLONG",

asm_arch => 'x86',

perlasm_scheme => "elf",

},

"linux-aout" => {

inherit_from => [ "BASE_unix" ],

CC => "gcc",

CFLAGS => add(picker(default => "-Wall",

debug => "-O0 -g",

release => "-O3 -fomit-frame-pointer")),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "BN_LLONG",

thread_scheme => "(unknown)",

asm_arch => 'x86',

perlasm_scheme => "a.out",

},

#### X86 / X86_64 targets

"linux-x86" => {

inherit_from => [ "linux-generic32" ],

CFLAGS => add(picker(release => "-fomit-frame-pointer")),

cflags => add("-m32"),

cxxflags => add("-m32"),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "BN_LLONG",

asm_arch => 'x86',

perlasm_scheme => "elf",

},

"linux-x86-latomic" => {

inherit_from => [ "linux-x86" ],

ex_libs => add(threads("-latomic")),

},

"linux-x86-clang" => {

inherit_from => [ "linux-x86" ],

CC => "clang",

CXX => "clang++",

ex_libs => add(threads("-latomic")),

},

"linux-x86_64" => {

inherit_from => [ "linux-generic64" ],

cflags => add("-m64"),

cxxflags => add("-m64"),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'x86_64',

perlasm_scheme => "elf",

multilib => "64",

},

"linux-x86_64-clang" => {

inherit_from => [ "linux-x86_64" ],

CC => "clang",

CXX => "clang++",

},

"linux-x32" => {

inherit_from => [ "linux-generic32" ],

cflags => add("-mx32"),

cxxflags => add("-mx32"),

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "SIXTY_FOUR_BIT",

asm_arch => 'x86_64',

perlasm_scheme => "elf32",

multilib => "x32",

},

"linux-ia64" => {

inherit_from => [ "linux-generic64" ],

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'ia64',

perlasm_scheme => 'void',

},

"linux64-s390x" => {

inherit_from => [ "linux-generic64" ],

cflags => add("-m64"),

cxxflags => add("-m64"),

lib_cppflags => add("-DB_ENDIAN"),

asm_arch => 's390x',

perlasm_scheme => "64",

multilib => "64",

},

"linux32-s390x" => {

#### So called "highgprs" target for z/Architecture CPUs

# "Highgprs" is kernel feature first implemented in Linux

# 2.6.32, see /proc/cpuinfo. The idea is to preserve most

# significant bits of general purpose registers not only

# upon 32-bit process context switch, but even on

# asynchronous signal delivery to such process. This makes

# it possible to deploy 64-bit instructions even in legacy

# application context and achieve better [or should we say

# adequate] performance. The build is binary compatible with

# linux-generic32, and the idea is to be able to install the

# resulting libcrypto.so alongside generic one, e.g. as

# /lib/highgprs/libcrypto.so.x.y, for ldconfig and run-time

# linker to autodiscover. Unfortunately it doesn't work just

# yet, because of couple of bugs in glibc

# sysdeps/s390/dl-procinfo.c affecting ldconfig and ld.so.1...

#

inherit_from => [ "linux-generic32" ],

cflags => add("-m31 -Wa,-mzarch"),

cxxflags => add("-m31 -Wa,-mzarch"),

lib_cppflags => add("-DB_ENDIAN"),

asm_arch => 's390x',

perlasm_scheme => "31",

multilib => "/highgprs",

},

#### SPARC Linux setups

"linux-sparcv8" => {

inherit_from => [ "linux-latomic" ],

cflags => add("-mcpu=v8"),

cxxflags => add("-mcpu=v8"),

lib_cppflags => add("-DB_ENDIAN -DBN_DIV2W"),

asm_arch => 'sparcv8',

perlasm_scheme => 'void',

},

"linux-sparcv9" => {

# it's a real mess with -mcpu=ultrasparc option under Linux,

# but -Wa,-Av8plus should do the trick no matter what.

inherit_from => [ "linux-latomic" ],

cflags => add("-m32 -mcpu=ultrasparc -Wa,-Av8plus"),

cxxflags => add("-m32 -mcpu=ultrasparc -Wa,-Av8plus"),

lib_cppflags => add("-DB_ENDIAN -DBN_DIV2W"),

asm_arch => 'sparcv9',

perlasm_scheme => 'void',

},

"linux64-sparcv9" => {

# GCC 3.1 is a requirement

inherit_from => [ "linux-generic64" ],

cflags => add("-m64 -mcpu=ultrasparc"),

cxxflags => add("-m64 -mcpu=ultrasparc"),

lib_cppflags => add("-DB_ENDIAN"),

ex_libs => add(threads("-latomic")),

bn_ops => "BN_LLONG RC4_CHAR",

asm_arch => 'sparcv9',

perlasm_scheme => 'void',

multilib => "64",

},

"linux-alpha-gcc" => {

inherit_from => [ "linux-generic64" ],

lib_cppflags => add("-DL_ENDIAN"),

bn_ops => "SIXTY_FOUR_BIT_LONG",

asm_arch => 'alpha',

perlasm_scheme => "void",

},

"linux-c64xplus" => {

inherit_from => [ "BASE_unix" ],

# TI_CGT_C6000_7.3.x is a requirement

CC => "cl6x",

CFLAGS => "-o2 -ox -ms",

cflags => "--linux -ea=.s -eo=.o -mv6400+ -pden",

cxxflags => "--linux -ea=.s -eo=.o -mv6400+ -pden",

cppflags => combine("-DOPENSSL_SMALL_FOOTPRINT",