10-main.conf

## -*- mode: perl; -*-
## Standard openssl configuration targets.
##
## If you edit this file, run this command before committing
##	make -f Makefile.org TABLE
## This file is interpolated by the Configure script.

%targets = (

#### Basic configs that should work on any 32-bit box
    "gcc" => {
        cc               => "gcc",
        cflags           => "",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG",
    },
    "cc" => {
        cc               => "cc",
        cflags           => "-O",
        thread_cflag     => "(unknown)",
    },

#### VOS Configurations
    "vos-gcc" => {
        cc               => "gcc",
        cflags           => "-Wall -DOPENSSL_SYS_VOS -D_POSIX_C_SOURCE=200112L -D_BSD -D_VOS_EXTENDED_NAMES -DB_ENDIAN",
        debug_cflags     => "-O0 -g -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG",
        release_cflags   => "-O3",
        thread_cflag     => "(unknown)",
        sys_id           => "VOS",
        lflags           => "-Wl,-map",
        bn_ops           => "BN_LLONG",
        shared_extension => ".so",
    },

#### Solaris x86 with GNU C setups
    "solaris-x86-gcc" => {
        # -DOPENSSL_NO_INLINE_ASM switches off inline assembler. We have
        # to do it here because whenever GNU C instantiates an assembler
        # template it surrounds it with #APP #NO_APP comment pair which
        # (at least Solaris 7_x86) /usr/ccs/bin/as fails to assemble
        # with "Illegal mnemonic" error message.
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-march=pentium -Wall -DL_ENDIAN -DOPENSSL_NO_INLINE_ASM",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3 -fomit-frame-pointer",
        thread_cflag     => "-pthread",
        lflags           => "-lsocket -lnsl -ldl",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "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:-)
        #					<appro@fy.chalmers.se>
        inherit_from     => [ asm("x86_64_asm") ],
        cc               => "gcc",
        cflags           => "-m64 -Wall -DL_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-lsocket -lnsl -ldl",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "elf",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-m64 -shared -static-libgcc",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/64",
    },

#### Solaris x86 with Sun C setups
    "solaris-x86-cc" => {
        cc               => "cc",
        cflags           => "-xarch=generic -xstrconst -Xa -DL_ENDIAN",
        debug_cflags     => "-g",
        release_cflags   => "-xO5 -xregs=frameptr -xdepend -xbuiltin",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-lsocket -lnsl -ldl -mt -lpthread",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_UNROLL BF_PTR",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-KPIC",
        shared_ldflag    => "-G -dy -z text",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "solaris64-x86_64-cc" => {
        inherit_from     => [ asm("x86_64_asm") ],
        cc               => "cc",
        cflags           => "-xarch=generic64 -xstrconst -Xa -DL_ENDIAN",
        debug_cflags     => "-g",
        release_cflags   => "-xO5 -xdepend -xbuiltin",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-lsocket -lnsl -ldl -mt -lpthread",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "elf",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-KPIC",
        shared_ldflag    => "-xarch=generic64 -G -dy -z text",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/64",
    },

#### SPARC Solaris with GNU C setups
    "solaris-sparcv7-gcc" => {
        cc               => "gcc",
        cflags           => "-Wall -DB_ENDIAN -DBN_DIV2W",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-lsocket -lnsl -ldl",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "solaris-sparcv8-gcc" => {
        inherit_from     => [ "solaris-sparcv7-gcc", asm("sparcv8_asm") ],
        cflags           => sub { join(" ","-mcpu=v8",@_); },
    },
    "solaris-sparcv9-gcc" => {
        # -m32 should be safe to add as long as driver recognizes
	# -mcpu=ultrasparc
        inherit_from     => [ "solaris-sparcv7-gcc", asm("sparcv9_asm") ],
        cc               => "gcc",
        cflags           => sub { join(" ","-m32 -mcpu=ultrasparc",@_); },
        debug_cflags     => "-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -DPEDANTIC -O -g -pedantic -ansi -Wshadow -Wno-long-long -D__EXTENSIONS__",
        release_cflags   => "-O3",
    },
    "solaris64-sparcv9-gcc" => {
        inherit_from     => [ "solaris-sparcv9-gcc" ],
        cc               => "gcc",
        cflags           => "-m64 -mcpu=ultrasparc -Wall -DB_ENDIAN",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL BF_PTR",
        shared_ldflag    => "-m64 -shared",
        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" => {
        cc               => "cc",
        cflags           => "-xstrconst -Xa -DB_ENDIAN -DBN_DIV2W",
        debug_cflags     => "-g -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL",
        release_cflags   => "-xO5 -xdepend",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-lsocket -lnsl -ldl -mt -lpthread",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC1 DES_UNROLL BF_PTR",
        dso_scheme       => "dlfcn",
        shared_target    => "solaris-shared",
        shared_cflag     => "-KPIC",
        shared_ldflag    => "-G -dy -z text",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
####
    "solaris-sparcv8-cc" => {
        inherit_from     => [ "solaris-sparcv7-cc", asm("sparcv8_asm") ],
        cflags           => sub { join(" ","-xarch=v8",@_); },
    },
    "solaris-sparcv9-cc" => {
        inherit_from     => [ "solaris-sparcv7-cc", asm("sparcv9_asm") ],
        cflags           => sub { join(" ","-xarch=v8plus -xtarget=ultra",@_); },
    },
    "solaris64-sparcv9-cc" => {
        inherit_from     => [ "solaris-sparcv7-cc", asm("sparcv9_asm") ],
        cflags           => sub { join(" ","-xarch=v9 -xtarget=ultra",@_); },
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL BF_PTR",
        shared_ldflag    => "-xarch=v9 -G -dy -z text",
        multilib         => "/64",
    },

#### IRIX 5.x configs
# -mips2 flag is added by ./config when appropriate.
    "irix-gcc" => {
        inherit_from     => [ asm("mips32_asm") ],
        cc               => "gcc",
        cflags           => "-DB_ENDIAN",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O3",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG MD2_CHAR RC4_INDEX RC4_CHAR RC4_CHUNK DES_UNROLL DES_RISC2 DES_PTR BF_PTR",
        perlasm_scheme   => "o32",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "irix-cc" => {
        inherit_from     => [ asm("mips32_asm") ],
        cc               => "cc",
        cflags           => "-use_readonly_const -DB_ENDIAN",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O2",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC2 DES_UNROLL BF_PTR",
        perlasm_scheme   => "o32",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
#### IRIX 6.x configs
# Only N32 and N64 ABIs are supported. If you need O32 ABI build, invoke
# './Configure irix-cc -o32' manually.
    "irix-mips3-gcc" => {
        inherit_from     => [ asm("mips64_asm") ],
        cc               => "gcc",
        cflags           => "-mabi=n32 -DB_ENDIAN -DBN_DIV3W",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O3",
        thread_cflag     => "-D_SGI_MP_SOURCE -pthread",
        bn_ops           => "MD2_CHAR RC4_INDEX RC4_CHAR RC4_CHUNK_LL DES_UNROLL DES_RISC2 DES_PTR BF_PTR SIXTY_FOUR_BIT",
        perlasm_scheme   => "n32",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_ldflag    => "-mabi=n32",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "32",
    },
    "irix-mips3-cc" => {
        inherit_from     => [ asm("mips64_asm") ],
        cc               => "cc",
        cflags           => "-n32 -mips3 -use_readonly_const -G0 -rdata_shared -DB_ENDIAN -DBN_DIV3W",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O2",
        thread_cflag     => "-D_SGI_MP_SOURCE",
        lflags           => "-lpthread",
        bn_ops           => "DES_PTR RC4_CHAR RC4_CHUNK_LL DES_RISC2 DES_UNROLL BF_PTR SIXTY_FOUR_BIT",
        perlasm_scheme   => "n32",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_ldflag    => "-n32",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "32",
    },
    # N64 ABI builds.
    "irix64-mips4-gcc" => {
        inherit_from     => [ asm("mips64_asm") ],
        cc               => "gcc",
        cflags           => "-mabi=64 -mips4 -DB_ENDIAN -DBN_DIV3W",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O3",
        thread_cflag     => "-D_SGI_MP_SOURCE",
        bn_ops           => "RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG",
        perlasm_scheme   => "64",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_ldflag    => "-mabi=64",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "64",
    },
    "irix64-mips4-cc" => {
        inherit_from     => [ asm("mips64_asm") ],
        cc               => "cc",
        cflags           => "-64 -mips4 -use_readonly_const -G0 -rdata_shared -DB_ENDIAN -DBN_DIV3W",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O2",
        thread_cflag     => "-D_SGI_MP_SOURCE",
        lflags           => "-lpthread",
        bn_ops           => "RC4_CHAR RC4_CHUNK DES_RISC2 DES_UNROLL SIXTY_FOUR_BIT_LONG",
        perlasm_scheme   => "64",
        dso_scheme       => "dlfcn",
        shared_target    => "irix-shared",
        shared_ldflag    => "-64",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        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 ment 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_lcl.h.
# - originally there were 32-bit hpux-parisc2-* targets. They were
#   scrapped, because a) they were not interchangable with other 32-bit
#   targets; a) when critical 32-bit assembly modules detect if they
#   are executed on PA-RISC 2.0 and thus adequate performance is
#   provided. 
#					<appro@fy.chalmers.se>
    "hpux-parisc-gcc" => {
        cc               => "gcc",
        cflags           => "-DB_ENDIAN -DBN_DIV2W",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-Wl,+s -ldld",
        bn_ops           => "BN_LLONG DES_PTR DES_UNROLL DES_RISC1",
        dso_scheme       => "dl",
        shared_target    => "hpux-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-shared",
        shared_extension => ".sl.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "hpux-parisc1_1-gcc" => {
        inherit_from     => [ "hpux-parisc-gcc", asm("parisc11_asm") ],
        multilib         => "/pa1.1",
    },
    "hpux64-parisc2-gcc" => {
        inherit_from     => [ asm("parisc20_64_asm") ],
        cc               => "gcc",
        cflags           => "-DB_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-ldl",
        bn_ops           => "SIXTY_FOUR_BIT_LONG MD2_CHAR RC4_INDEX RC4_CHAR DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "-fpic",
        shared_ldflag    => "-shared",
        shared_extension => ".sl.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/pa20_64",
    },

    # More attempts at unified 10.X and 11.X targets for HP C compiler.
    #
    # Chris Ruemmler <ruemmler@cup.hp.com>
    # Kevin Steves <ks@hp.se>
    "hpux-parisc-cc" => {
        cc               => "cc",
        cflags           => "+Optrs_strongly_typed -Ae +ESlit -DB_ENDIAN -DBN_DIV2W -DMD32_XARRAY",
        debug_cflags      => "+O0 +d -g",
        release_cflags   => "+O3",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-Wl,+s -ldld -lpthread",
        bn_ops           => "MD2_CHAR RC4_INDEX RC4_CHAR DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dl",
        shared_target    => "hpux-shared",
        shared_cflag     => "+Z",
        shared_ldflag    => "-b",
        shared_extension => ".sl.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "hpux-parisc1_1-cc" => {
        inherit_from     => [ "hpux-parisc-cc", asm("parisc11_asm") ],
        cflags           => sub { join(" ","+DA1.1",@_); },
        multilib         => "/pa1.1",
    },
    "hpux64-parisc2-cc" => {
        inherit_from     => [ asm("parisc20_64_asm") ],
        cc               => "cc",
        cflags           => "+DD64 +Optrs_strongly_typed -Ae +ESlit -DB_ENDIAN -DMD32_XARRAY",
        debug_cflags      => "+O0 +d -g",
        release_cflags   => "+O3",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-ldl -lpthread",
        bn_ops           => "SIXTY_FOUR_BIT_LONG MD2_CHAR RC4_INDEX RC4_CHAR DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "+Z",
        shared_ldflag    => "+DD64 -b",
        shared_extension => ".sl.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/pa20_64",
    },

    # HP/UX IA-64 targets
    "hpux-ia64-cc" => {
        inherit_from     => [ asm("ia64_asm") ],
        cc               => "cc",
        cflags           => "-Ae +DD32 +Olit=all -z -DB_ENDIAN",
        debug_cflags     => "+O0 +d -g",
        release_cflags   => "+O2",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-ldl -lpthread",
        bn_ops           => "SIXTY_FOUR_BIT MD2_CHAR RC4_INDEX DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "+Z",
        shared_ldflag    => "+DD32 -b",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/hpux32",
    },
    # Frank Geurts <frank.geurts@nl.abnamro.com> has patiently assisted
    # with debugging of the following config.
    "hpux64-ia64-cc" => {
        inherit_from     => [ asm("ia64_asm") ],
        cc               => "cc",
        cflags           => "-Ae +DD64 +Olit=all -z -DB_ENDIAN",
        debug_cflags     => "+O0 +d -g",
        release_cflags   => "+O3",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-ldl -lpthread",
        bn_ops           => "SIXTY_FOUR_BIT_LONG MD2_CHAR RC4_INDEX DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "+Z",
        shared_ldflag    => "+DD64 -b",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/hpux64",
    },
    # GCC builds...
    "hpux-ia64-gcc" => {
        inherit_from     => [ asm("ia64_asm") ],
        cc               => "gcc",
        cflags           => "-DB_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-ldl",
        bn_ops           => "SIXTY_FOUR_BIT MD2_CHAR RC4_INDEX DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "-fpic",
        shared_ldflag    => "-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/hpux32",
    },
    "hpux64-ia64-gcc" => {
        inherit_from     => [ asm("ia64_asm") ],
        cc               => "gcc",
        cflags           => "-mlp64 -DB_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-ldl",
        bn_ops           => "SIXTY_FOUR_BIT_LONG MD2_CHAR RC4_INDEX DES_UNROLL DES_RISC1 DES_INT",
        dso_scheme       => "dlfcn",
        shared_target    => "hpux-shared",
        shared_cflag     => "-fpic",
        shared_ldflag    => "-mlp64 -shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        multilib         => "/hpux64",
    },

#### HP MPE/iX http://jazz.external.hp.com/src/openssl/
    "MPE/iX-gcc" => {
        cc               => "gcc",
        cflags           => "-D_ENDIAN -DBN_DIV2W -O3 -D_POSIX_SOURCE -D_SOCKET_SOURCE -I/SYSLOG/PUB",
        thread_cflag     => "(unknown)",
        sys_id           => "MPE",
        lflags           => "-L/SYSLOG/PUB -lsyslog -lsocket -lcurses",
        bn_ops           => "BN_LLONG DES_PTR DES_UNROLL DES_RISC1",
    },

#### DEC Alpha OSF/1/Tru64 targets.
#
#	"What's in a name? That which we call a rose
#	 By any other word would smell as sweet."
#
# - William Shakespeare, "Romeo & Juliet", Act II, scene II.
#
# For gcc, the following gave a %50 speedup on a 164 over the 'DES_INT' version
#
    "osf1-alpha-gcc" => {
        inherit_from     => [ asm("alpha_asm") ],
        cc               => "gcc",
        cflags           => "-O3",
        thread_cflag     => "(unknown)",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_UNROLL DES_RISC1",
        dso_scheme       => "dlfcn",
        shared_target    => "alpha-osf1-shared",
        shared_extension => ".so",
    },
    "osf1-alpha-cc" => {
        inherit_from     => [ asm("alpha_asm") ],
        cc               => "cc",
        cflags           => "-std1 -tune host -O4 -readonly_strings",
        thread_cflag     => "(unknown)",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK",
        dso_scheme       => "dlfcn",
        shared_target    => "alpha-osf1-shared",
        shared_extension => ".so",
    },
    "tru64-alpha-cc" => {
        inherit_from     => [ asm("alpha_asm") ],
        cc               => "cc",
        cflags           => "-std1 -tune host -fast -readonly_strings",
        thread_cflag     => "-pthread",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK",
        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" => {
        cc               => "gcc",
        cflags           => "-Wall",
        debug_cflags     => "-O0 -g -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread",
        lflags           => "-ldl",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
        dso_scheme       => "dlfcn",
        shared_target    => "linux-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "linux-generic64" => {
        inherit_from     => [ "linux-generic32" ],
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
    },

    "linux-ppc" => {
        inherit_from     => [ "linux-generic32", asm("ppc32_asm") ],
        perlasm_scheme   => "linux32",
    },
    "linux-ppc64" => {
        inherit_from     => [ "linux-generic64", asm("ppc64_asm") ],
        cflags           => "-m64 -Wall -DB_ENDIAN",
        perlasm_scheme   => "linux64",
        shared_ldflag    => "-m64",
        multilib         => "64",
    },
    "linux-ppc64le" => {
        inherit_from     => [ "linux-generic64", asm("ppc64_asm") ],
        cflags           => "-m64 -Wall -DL_ENDIAN",
        perlasm_scheme   => "linux64le",
        shared_ldflag    => "-m64",
    },

    "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-generic32", asm("armv4_asm") ],
        perlasm_scheme   => "linux32",
    },
    "linux-aarch64" => {
        inherit_from     => [ "linux-generic64", asm("aarch64_asm") ],
        perlasm_scheme   => "linux64",
    },
    "linux-arm64ilp32" => {  # https://wiki.linaro.org/Platform/arm64-ilp32
        inherit_from     => [ "linux-generic32", asm("aarch64_asm") ],
        cflags           => "-mabi=ilp32 -Wall",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
        perlasm_scheme   => "linux64",
        shared_ldflag    => "-mabi=ilp32",
    },

    "linux-mips32" => {
        # Configure script adds minimally required -march for assembly
        # support, if no -march was specified at command line.
        inherit_from     => [ "linux-generic32", asm("mips32_asm") ],
        cflags           => "-mabi=32 -Wall -DBN_DIV3W",
        perlasm_scheme   => "o32",
        shared_ldflag    => "-mabi=32",
    },
    # mips32 and mips64 below refer to contemporary MIPS Architecture
    # specifications, MIPS32 and MIPS64, rather than to kernel bitness.
    "linux-mips64" => {
        inherit_from     => [ "linux-generic32", asm("mips64_asm") ],
        cflags           => "-mabi=n32 -Wall -DBN_DIV3W",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
        perlasm_scheme   => "n32",
        shared_ldflag    => "-mabi=n32",
        multilib         => "32",
    },
    "linux64-mips64" => {
        inherit_from     => [ "linux-generic64", asm("mips64_asm") ],
        cflags           => "-mabi=64 -O3 -Wall -DBN_DIV3W",
        perlasm_scheme   => "64",
        shared_ldflag    => "-mabi=64",
        multilib         => "64",
    },

    #### IA-32 targets...
    "linux-elf" => {
        inherit_from     => [ "linux-generic32", asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-march=i486 -DL_ENDIAN -Wall",
        debug_cflags     => "-O0 -g -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG",
        release_cflags   => "-O3 -fomit-frame-pointer",
        debug_lflags     => "-lefence",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
    },
    "linux-aout" => {
        inherit_from     => [ asm("x86_asm") ],
        cc               => "gcc",
        cflags           => "-DL_ENDIAN -march=i486 -Wall",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3 -fomit-frame-pointer",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "a.out",
    },

    "linux-x86_64" => {
        inherit_from     => [ "linux-generic64", asm("x86_64_asm") ],
        cflags           => "-m64 -DL_ENDIAN -Wall",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "elf",
        shared_ldflag    => "-m64",
        multilib         => "64",
    },
    "linux-x86_64-clang" => {
        inherit_from     => [ "linux-x86_64" ],
        cc               => "clang",
        cflags           => "-m64 -DL_ENDIAN -Wall -Wextra -Qunused-arguments",
    },
    "linux-x32" => {
        inherit_from     => [ "linux-generic32", asm("x86_64_asm") ],
        cflags           => "-mx32 -DL_ENDIAN -Wall",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHUNK_LL DES_INT DES_UNROLL",
        perlasm_scheme   => "elf",
        shared_ldflag    => "-mx32",
        multilib         => "x32",
    },

    "linux-ia64" => {
        inherit_from     => [ "linux-generic64", asm("ia64_asm") ],
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_UNROLL DES_INT",
    },

    "linux64-s390x" => {
        inherit_from     => [ "linux-generic64", asm("s390x_asm") ],
        cflags           => "-m64 -Wall -DB_ENDIAN",
        perlasm_scheme   => "64",
        shared_ldflag    => "-m64",
        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", asm("s390x_asm") ],
        cflags           => "-m31 -Wall -Wa,-mzarch -DB_ENDIAN",
        bn_obj           => sub { my $r=join(" ",@_); $r=~s/bn\-s390x/bn_asm/; $r; },
        perlasm_scheme   => "31",
        shared_ldflag    => "-m31",
        multilib         => "/highgprs",
    },

    #### SPARC Linux setups
    # Ray Miller <ray.miller@computing-services.oxford.ac.uk> has
    # patiently assisted with debugging of following two configs.
    "linux-sparcv8" => {
        inherit_from     => [ "linux-generic32", asm("sparcv8_asm") ],
        cflags           => "-mcpu=v8 -Wall -DB_ENDIAN -DBN_DIV2W",
    },
    "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-generic32", asm("sparcv9_asm") ],
        cflags           => "-m32 -mcpu=ultrasparc -Wall -Wa,-Av8plus -DB_ENDIAN -DBN_DIV2W",
        shared_ldflag    => "-m32",
    },
    "linux64-sparcv9" => {
        # GCC 3.1 is a requirement
        inherit_from     => [ "linux-generic64", asm("sparcv9_asm") ],
        cflags           => "-m64 -mcpu=ultrasparc -Wall -DB_ENDIAN",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
        shared_ldflag    => "-m64",
        multilib         => "64",
    },

    "linux-alpha-gcc" => {
        inherit_from     => [ "linux-generic64", asm("alpha_asm") ],
        cflags           => "-DL_ENDIAN",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_RISC1 DES_UNROLL",
    },
    "linux-c64xplus" => {
        # TI_CGT_C6000_7.3.x is a requirement
        cc               => "cl6x",
        cflags           => "--linux -ea=.s -eo=.o -mv6400+ -o2 -ox -ms -pden -DOPENSSL_SMALL_FOOTPRINT",
        thread_cflag     => "-D_REENTRANT",
        bn_ops           => "BN_LLONG",
        cpuid_obj        => "c64xpluscpuid.o",
        bn_obj           => "bn-c64xplus.o c64xplus-gf2m.o",
        aes_obj          => "aes-c64xplus.o aes_cbc.o aes_ctr.o",
        sha1_obj         => "sha1-c64xplus.o sha256-c64xplus.o sha512-c64xplus.o",
        rc4_obj          => "rc4-c64xplus.o",
        modes_obj        => "ghash-c64xplus.o",
        perlasm_scheme   => "void",
        dso_scheme       => "dlfcn",
        shared_target    => "linux-shared",
        shared_cflag     => "--pic",
        shared_ldflag    => "-z --sysv --shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        ranlib           => "true",
    },

#### Android: linux-* but without pointers to headers and libs.
    #
    # It takes pair of prior-set environment variables to make it work:
    #
    # CROSS_SYSROOT=/some/where/android-ndk-<ver>/platforms/android-<apiver>/arch-<
    # CROSS_COMPILE=<prefix>
    #
    # As well as PATH adjusted to cover ${CROSS_COMPILE}gcc and company.
    # For example to compile for ICS and ARM with NDK 10d, you'd:
    #
    # ANDROID_NDK=/some/where/android-ndk-10d
    # CROSS_SYSROOT=$ANDROID_NDK/platforms/android-14/arch-arm
    # CROSS_COMPILE=arm-linux-adroideabi-
    # PATH=$ANDROID_NDK/toolchains/arm-linux-androideabi-4.8/prebuild/linux-x86_64/
    #
    "android" => {
        inherit_from     => [ "linux-generic32" ],
        # Special note about unconditional -fPIC and -pie. The underlying
        # reason is that Lollipop refuses to run non-PIE. But what about
        # older systems and NDKs? -fPIC was never problem, so the only
        # concern if -pie. Older toolchains, e.g. r4, appear to handle it
        # and binaries turn mostly functional. "Mostly" means that oldest
        # Androids, such as Froyo, fail to handle executable, but newer
        # systems are perfectly capable of executing binaries targeting
        # Froyo. Keep in mind that in the nutshell Android builds are
        # about JNI, i.e. shared libraries, not applications.
        cflags           => "-mandroid -fPIC --sysroot=\$(CROSS_SYSROOT) -Wa,--noexecstack -Wall",
        debug_cflags     => "-O0 -g",
        lflags           => "-pie%-ldl",
        shared_cflag     => "",
    },
    "android-x86" => {
        inherit_from     => [ "android", asm("x86_asm") ],
        release_cflags   => "-O3 -fomit-frame-pointer",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "android",
    },
    ################################################################
    # Contemporary Android applications can provide multiple JNI
    # providers in .apk, targeting multiple architectures. Among
    # them there is "place" for two ARM flavours: generic eabi and
    # armv7-a/hard-float. However, it should be noted that OpenSSL's
    # 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.]
    # 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
    # it might be appropriate to provide both libraries. Otherwise
    # just generic eabi would do. But in latter case it would be
    # appropriate to
    #
    #   ./Configure android-armeabi -D__ARM_MAX_ARCH__=8
    #
    # in order to build "universal" binary and allow OpenSSL take
    # advantage of NEON when it's available.
    #
    "android-armeabi" => {
        inherit_from     => [ "android", asm("armv4_asm") ],
    },
    "android-armv7" => {
        inherit_from     => [ "android-armeabi" ],
        cflags           => sub { join (" ","-march=armv7-a",@_); },
    },
    "android-mips" => {
        inherit_from     => [ "android", asm("mips32_asm") ],
        perlasm_scheme   => "o32",
    },

    "android64" => {
        inherit_from     => [ "linux-generic64" ],
        cflags           => "-mandroid -fPIC --sysroot=\$(CROSS_SYSROOT) -Wa,--noexecstack -Wall",
        debug_cflags     => "-O0 -g",
        lflags           => "-pie%-ldl",
        shared_cflag     => "",
    },
    "android64-aarch64" => {
        inherit_from     => [ "android64", asm("aarch64_asm") ],
        perlasm_scheme   => "linux64",
    },

#### *BSD
    "BSD-generic32" => {
        # As for thread_cflag. Idea is to maintain "collective" set of
        # flags, which would cover all BSD flavors. -pthread applies
        # to them all, but is treated differently. OpenBSD expands is
        # as -D_POSIX_THREAD -lc_r, which is sufficient. FreeBSD 4.x
        # expands it as -lc_r, which has to be accompanied by explicit
        # -D_THREAD_SAFE and sometimes -D_REENTRANT. FreeBSD 5.x
        # expands it as -lc_r, which seems to be sufficient?
        cc               => "cc",
        cflags           => "-Wall",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O3",
        thread_cflag     => "-pthread -D_THREAD_SAFE -D_REENTRANT",
        bn_ops           => "BN_LLONG RC2_CHAR RC4_INDEX DES_INT DES_UNROLL",
        dso_scheme       => "dlfcn",
        shared_target    => "bsd-gcc-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "BSD-generic64" => {
        inherit_from     => [ "BSD-generic32" ],
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
    },

    "BSD-x86" => {
        inherit_from     => [ "BSD-generic32", asm("x86_asm") ],
        cflags           => "-DL_ENDIAN -Wall",
        release_cflags   => "-O3 -fomit-frame-pointer",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        shared_target    => "bsd-shared",
        perlasm_scheme   => "a.out",
    },
    "BSD-x86-elf" => {
        inherit_from     => [ "BSD-x86" ],
        perlasm_scheme   => "elf",
    },

    "BSD-sparcv8" => {
        inherit_from     => [ "BSD-generic32", asm("sparcv8_asm") ],
        cflags           => "-mcpu=v8 -Wall -DB_ENDIAN",
    },
    "BSD-sparc64" => {
        # -DMD32_REG_T=int doesn't actually belong in sparc64 target, it
        # simply *happens* to work around a compiler bug in gcc 3.3.3,
        # triggered by RIPEMD160 code.
        inherit_from     => [ "BSD-generic64", asm("sparcv9_asm") ],
        cflags           => "-DB_ENDIAN -DMD32_REG_T=int -Wall",
        bn_ops           => "BN_LLONG RC2_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC2 BF_PTR",
    },

    "BSD-ia64" => {
        inherit_from     => [ "BSD-generic64", asm("ia64_asm") ],
        cflags           => "-DL_ENDIAN -Wall",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_UNROLL DES_INT",
    },

    "BSD-x86_64" => {
        inherit_from     => [ "BSD-generic64", asm("x86_64_asm") ],
        cflags           => "-DL_ENDIAN -Wall",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "elf",
    },

    "bsdi-elf-gcc" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-DPERL5 -DL_ENDIAN -fomit-frame-pointer -O3 -march=i486 -Wall",
        thread_cflag     => "(unknown)",
        lflags           => "-ldl",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        dso_scheme       => "dlfcn",
        shared_target    => "bsd-gcc-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },

    "nextstep" => {
        cc               => "cc",
        cflags           => "-O -Wall",
        unistd           => "<libc.h>",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
    },
    "nextstep3.3" => {
        cc               => "cc",
        cflags           => "-O3 -Wall",
        unistd           => "<libc.h>",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
    },

# QNX
    "qnx4" => {
        cc               => "cc",
        cflags           => "-DL_ENDIAN -DTERMIO",
        thread_cflag     => "(unknown)",
        bn_ops           => "${x86_gcc_des} ${x86_gcc_opts}",
    },
    "QNX6" => {
        cc               => "gcc",
        lflags           => "-lsocket",
        dso_scheme       => "dlfcn",
        shared_target    => "bsd-gcc-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "QNX6-i386" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-DL_ENDIAN -O2 -Wall",
        lflags           => "-lsocket",
        bn_ops           => "${x86_gcc_des} ${x86_gcc_opts}",
        dso_scheme       => "dlfcn",
        shared_target    => "bsd-gcc-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },

#### SCO/Caldera targets.
#
# Originally we had like unixware-*, unixware-*-pentium, unixware-*-p6, etc.
# Now we only have blended unixware-* as it's the only one used by ./config.
# If you want to optimize for particular microarchitecture, bypass ./config
# and './Configure unixware-7 -Kpentium_pro' or whatever appropriate.
# Note that not all targets include assembler support. Mostly because of
# lack of motivation to support out-of-date platforms with out-of-date
# compiler drivers and assemblers. Tim Rice <tim@multitalents.net> has
# patiently assisted to debug most of it.
#
# UnixWare 2.0x fails destest with -O.
    "unixware-2.0" => {
        cc               => "cc",
        cflags           => "-DFILIO_H -DNO_STRINGS_H",
        thread_cflag     => "-Kthread",
        lflags           => "-lsocket -lnsl -lresolv -lx",
        bn_ops           => "${x86_gcc_des} ${x86_gcc_opts}",
    },
    "unixware-2.1" => {
        cc               => "cc",
        cflags           => "-O -DFILIO_H",
        thread_cflag     => "-Kthread",
        lflags           => "-lsocket -lnsl -lresolv -lx",
        bn_ops           => "${x86_gcc_des} ${x86_gcc_opts}",
    },
    "unixware-7" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "cc",
        cflags           => "-O -DFILIO_H -Kalloca",
        thread_cflag     => "-Kthread",
        lflags           => "-lsocket -lnsl",
        bn_ops           => "BN_LLONG MD2_CHAR RC4_INDEX ${x86_gcc_des}",
        perlasm_scheme   => "elf-1",
        dso_scheme       => "dlfcn",
        shared_target    => "svr5-shared",
        shared_cflag     => "-Kpic",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "unixware-7-gcc" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-DL_ENDIAN -DFILIO_H -O3 -fomit-frame-pointer -march=pentium -Wall",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "-lsocket -lnsl",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "elf-1",
        dso_scheme       => "dlfcn",
        shared_target    => "gnu-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
# SCO 5 - Ben Laurie <ben@algroup.co.uk> says the -O breaks the SCO cc.
    "sco5-cc" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "cc",
        cflags           => "-belf",
        thread_cflag     => "(unknown)",
        lflags           => "-lsocket -lnsl",
        bn_ops           => "${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "elf-1",
        dso_scheme       => "dlfcn",
        shared_target    => "svr3-shared",
        shared_cflag     => "-Kpic",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },
    "sco5-gcc" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-O3 -fomit-frame-pointer",
        thread_cflag     => "(unknown)",
        lflags           => "-lsocket -lnsl",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "elf-1",
        dso_scheme       => "dlfcn",
        shared_target    => "svr3-shared",
        shared_cflag     => "-fPIC",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
    },

#### IBM's AIX.
    "aix-gcc" => {
        inherit_from     => [ asm("ppc32_asm") ],
        cc               => "gcc",
        cflags           => "-DB_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O",
        thread_cflag     => "-pthread",
        sys_id           => "AIX",
        bn_ops           => "BN_LLONG RC4_CHAR",
        perlasm_scheme   => "aix32",
        dso_scheme       => "dlfcn",
        shared_target    => "aix-shared",
        shared_ldflag    => "-shared -Wl,-G",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        arflags          => "-X32",
    },
    "aix64-gcc" => {
        inherit_from     => [ asm("ppc64_asm") ],
        cc               => "gcc",
        cflags           => "-maix64 -DB_ENDIAN",
        debug_cflags     => "-O0 -g",
        release_cflags   => "-O",
        thread_cflag     => "-pthread",
        sys_id           => "AIX",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR",
        perlasm_scheme   => "aix64",
        dso_scheme       => "dlfcn",
        shared_target    => "aix-shared",
        shared_ldflag    => "-maix64 -shared -Wl,-G",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        arflags          => "-X64",
    },
    # Below targets assume AIX 5. Idea is to effectively disregard
    # $OBJECT_MODE at build time. $OBJECT_MODE is respected at
    # ./config stage!
    "aix-cc" => {
        inherit_from     => [ asm("ppc32_asm") ],
        cc               => "cc",
        cflags           => "-q32 -DB_ENDIAN -qmaxmem=16384 -qro -qroconst",
        debug_cflags     => "",
        release_cflags   => "-O",
        thread_cflag     => "-qthreaded -D_THREAD_SAFE",
        sys_id           => "AIX",
        bn_ops           => "BN_LLONG RC4_CHAR",
        perlasm_scheme   => "aix32",
        dso_scheme       => "dlfcn",
        shared_target    => "aix-shared",
        shared_ldflag    => "-q32 -G",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        arflags          => "-X 32",
    },
    "aix64-cc" => {
        inherit_from     => [ asm("ppc64_asm") ],
        cc               => "cc",
        cflags           => "-q64 -DB_ENDIAN -qmaxmem=16384 -qro -qroconst",
        debug_cflags     => "",
        release_cflags   => "-O",
        thread_cflag     => "-qthreaded -D_THREAD_SAFE",
        sys_id           => "AIX",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR",
        perlasm_scheme   => "aix64",
        dso_scheme       => "dlfcn",
        shared_target    => "aix-shared",
        shared_ldflag    => "-q64 -G",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        arflags          => "-X 64",
    },

# SIEMENS BS2000/OSD: an EBCDIC-based mainframe
    "BS2000-OSD" => {
        cc               => "c89",
        cflags           => "-O -XLLML -XLLMK -XL -DB_ENDIAN -DCHARSET_EBCDIC",
        thread_cflag     => "(unknown)",
        lflags           => "-lsocket -lnsl",
        bn_ops           => "THIRTY_TWO_BIT DES_PTR DES_UNROLL MD2_CHAR RC4_INDEX RC4_CHAR BF_PTR",
    },

# OS/390 Unix an EBCDIC-based Unix system on IBM mainframe
# You need to compile using the c89.sh wrapper in the tools directory, because the
# IBM compiler does not like the -L switch after any object modules.
#
    "OS390-Unix" => {
        cc               => "c89.sh",
        cflags           => "-O -DB_ENDIAN -DCHARSET_EBCDIC -DNO_SYS_PARAM_H  -D_ALL_SOURCE",
        thread_cflag     => "(unknown)",
        bn_ops           => "THIRTY_TWO_BIT DES_PTR DES_UNROLL MD2_CHAR RC4_INDEX RC4_CHAR BF_PTR",
    },

#### Visual C targets
#
# Win64 targets, WIN64I denotes IA-64 and WIN64A - AMD64
#
# Note about -wd4090, disable warning C4090. This warning returns false
# positives in some situations. Disabling it altogether masks both
# legitimate and false cases, but as we compile on multiple platforms,
# we rely on other compilers to catch legitimate cases.
    "VC-common" => {
        template         => 1,
        cc               => "cl",
        cflags           => "-W3 -wd4090 -Gs0 -GF -Gy -nologo -DOPENSSL_SYS_WIN32 -DWIN32_LEAN_AND_MEAN -DL_ENDIAN -D_CRT_SECURE_NO_DEPRECATE",
        dso_scheme       => "win32",
    },
    "VC-WIN64I" => {
        inherit_from     => [ "VC-common", asm("ia64_asm") ],
        cflags           => sub { join(" ",@_,"-DUNICODE -D_UNICODE"); },
        sys_id           => "WIN64I",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHUNK_LL DES_INT EXPORT_VAR_AS_FN",
        bn_obj           => sub { my $r=join(" ",@_); $r=~s/bn\-//; $r; },
        rc4_obj          => "",
        perlasm_scheme   => "ias",
    },
    "VC-WIN64A" => {
        inherit_from     => [ "VC-common", asm("x86_64_asm") ],
        cflags           => sub { join(" ",@_,"-DUNICODE -D_UNICODE"); },
        sys_id           => "WIN64A",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHUNK_LL DES_INT EXPORT_VAR_AS_FN",
        bn_obj           => sub { my $r=join(" ",@_); $r=~s/x86_64\-gcc/bn_asm/; $r; },
        perlasm_scheme   => "auto",
    },
    "VC-WIN32" => {
        # x86 Win32 target defaults to ANSI API, if you want UNICODE,
        # configure with 'perl Configure VC-WIN32 -DUNICODE -D_UNICODE'
        inherit_from     => [ "VC-common", asm("x86_asm") ],
        sys_id           => "WIN32",
        bn_ops           => "BN_LLONG RC4_INDEX EXPORT_VAR_AS_FN ${x86_gcc_opts}",
        perlasm_scheme   => "win32n",
    },
    "VC-CE" => {
        cc               => "cl",
        sys_id           => "WINCE",
        bn_ops           => "BN_LLONG RC4_INDEX EXPORT_VAR_AS_FN ${x86_gcc_opts}",
        dso_scheme       => "win32",
    },

#### Borland C++ 4.5
    "BC-32" => {
        cc               => "bcc32",
        sys_id           => "WIN32",
        bn_ops           => "BN_LLONG DES_PTR RC4_INDEX EXPORT_VAR_AS_FN",
        dso_scheme       => "win32",
    },

#### MinGW
    "mingw" => {
        inherit_from     => [ asm("x86_asm") ],
        cc               => "gcc",
        cflags           => "-mno-cygwin -DL_ENDIAN -DWIN32_LEAN_AND_MEAN -march=i486 -Wall",
        debug_cflags     => "-g -O0",
        release_clags    => "-O3 -fomit-frame-pointer",
        thread_cflag     => "-D_MT",
        sys_id           => "MINGW32",
        lflags           => "-lws2_32 -lgdi32 -lcrypt32",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts} EXPORT_VAR_AS_FN",
        perlasm_scheme   => "coff",
        dso_scheme       => "win32",
        shared_target    => "cygwin-shared",
        shared_cflag     => "-D_WINDLL -DOPENSSL_USE_APPLINK",
        shared_ldflag    => "-mno-cygwin",
        shared_extension => ".dll.a",
    },
    "mingw64" => {
        # As for OPENSSL_USE_APPLINK. Applink makes it possible to use
        # .dll compiled with one compiler with application compiled with
        # another compiler. It's possible to engage Applink support in
        # mingw64 build, but it's not done, because till mingw64
        # supports structured exception handling, one can't seriously
        # consider its binaries for using with non-mingw64 run-time
        # environment. And as mingw64 is always consistent with itself,
        # Applink is never engaged and can as well be omitted.
        inherit_from     => [ asm("x86_64_asm") ],
        cc               => "gcc",
        cflags           => "-mno-cygwin -DL_ENDIAN -Wall -DWIN32_LEAN_AND_MEAN -DUNICODE -D_UNICODE",
        debug_cflags     => "-g -O0",
        release_clags    => "-O3",
        thread_cflag     => "-D_MT",
        sys_id           => "MINGW64",
        lflags           => "-lws2_32 -lgdi32 -lcrypt32",
        bn_ops           => "SIXTY_FOUR_BIT RC4_CHUNK_LL DES_INT EXPORT_VAR_AS_FN",
        perlasm_scheme   => "mingw64",
        dso_scheme       => "win32",
        shared_target    => "cygwin-shared",
        shared_cflag     => "-D_WINDLL",
        shared_ldflag    => "-mno-cygwin",
        shared_extension => ".dll.a",
    },

#### UEFI
    "UEFI" => {
        cc               => "cc",
        cflags           => "-DL_ENDIAN -O",
        sys_id           => "UEFI",
    },

#### UWIN
    "UWIN" => {
        cc               => "cc",
        cflags           => "-DTERMIOS -DL_ENDIAN -O -Wall",
        sys_id           => "UWIN",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        dso_scheme       => "win32",
    },

#### Cygwin
    "Cygwin" => {
        inherit_from     => [ asm("x86_asm") ],
        cc               => "gcc",
        cflags           => "-DTERMIOS -DL_ENDIAN -march=i486 -Wall",
        debug_cflags     => "-g -O0",
        release_clags    => "-O3 -fomit-frame-pointer",
        sys_id           => "CYGWIN",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "coff",
        dso_scheme       => "dlfcn",
        shared_target    => "cygwin-shared",
        shared_cflag     => "-D_WINDLL",
        shared_ldflag    => "-shared",
        shared_extension => ".dll.a",
    },
    "Cygwin-x86_64" => {
        inherit_from     => [ asm("x86_64_asm") ],
        cc               => "gcc",
        cflags           => "-DTERMIOS -DL_ENDIAN -Wall",
        debug_cflags     => "-g -O0",
        release_clags    => "-O3",
        sys_id           => "CYGWIN",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "mingw64",
        dso_scheme       => "dlfcn",
        shared_target    => "cygwin-shared",
        shared_cflag     => "-D_WINDLL",
        shared_ldflag    => "-shared",
        shared_extension => ".dll.a",
    },

#### NetWare from David Ward (dsward@novell.com)
# requires either MetroWerks NLM development tools, or gcc / nlmconv
# NetWare defaults socket bio to WinSock sockets. However,
# the builds can be configured to use BSD sockets instead.
# netware-clib => legacy CLib c-runtime support
    "netware-clib" => {
        cc               => "mwccnlm",
        bn_ops           => "${x86_gcc_opts}",
    },
    "netware-clib-bsdsock" => {
        cc               => "mwccnlm",
        bn_ops           => "${x86_gcc_opts}",
    },
    "netware-clib-gcc" => {
        cc               => "i586-netware-gcc",
        cflags           => "-nostdinc -I/ndk/nwsdk/include/nlm -I/ndk/ws295sdk/include -DL_ENDIAN -DNETWARE_CLIB -DOPENSSL_SYS_NETWARE -O2 -Wall",
        bn_ops           => "${x86_gcc_opts}",
    },
    "netware-clib-bsdsock-gcc" => {
        cc               => "i586-netware-gcc",
        cflags           => "-nostdinc -I/ndk/nwsdk/include/nlm -DNETWARE_BSDSOCK -DNETDB_USE_INTERNET -DL_ENDIAN -DNETWARE_CLIB -DOPENSSL_SYS_NETWARE -O2 -Wall",
        bn_ops           => "${x86_gcc_opts}",
    },
    # netware-libc => LibC/NKS support
    "netware-libc" => {
        cc               => "mwccnlm",
        bn_ops           => "BN_LLONG ${x86_gcc_opts}",
    },
    "netware-libc-bsdsock" => {
        cc               => "mwccnlm",
        bn_ops           => "BN_LLONG ${x86_gcc_opts}",
    },
    "netware-libc-gcc" => {
        cc               => "i586-netware-gcc",
        cflags           => "-nostdinc -I/ndk/libc/include -I/ndk/libc/include/winsock -DL_ENDIAN -DNETWARE_LIBC -DOPENSSL_SYS_NETWARE -DTERMIO -O2 -Wall",
        bn_ops           => "BN_LLONG ${x86_gcc_opts}",
    },
    "netware-libc-bsdsock-gcc" => {
        cc               => "i586-netware-gcc",
        cflags           => "-nostdinc -I/ndk/libc/include -DNETWARE_BSDSOCK -DL_ENDIAN -DNETWARE_LIBC -DOPENSSL_SYS_NETWARE -DTERMIO -O2 -Wall",
        bn_ops           => "BN_LLONG ${x86_gcc_opts}",
    },

#### DJGPP
    "DJGPP" => {
        inherit_from     => [ asm("x86_asm") ],
        cc               => "gcc",
        cflags           => "-I/dev/env/WATT_ROOT/inc -DTERMIO -DL_ENDIAN -fomit-frame-pointer -O2 -Wall",
        sys_id           => "MSDOS",
        lflags           => "-L/dev/env/WATT_ROOT/lib -lwatt",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        perlasm_scheme   => "a.out",
    },

#### Ultrix from Bernhard Simon <simon@zid.tuwien.ac.at>
    "ultrix-cc" => {
        cc               => "cc",
        cflags           => "-std1 -O -Olimit 2500 -DL_ENDIAN",
        thread_cflag     => "(unknown)",
    },
    "ultrix-gcc" => {
        cc               => "gcc",
        cflags           => "-O3 -DL_ENDIAN",
        thread_cflag     => "(unknown)",
        bn_ops           => "BN_LLONG",
    },
# K&R C is no longer supported; you need gcc on old Ultrix installations
##"ultrix","cc:-O2 -DNOPROTO -DNOCONST -DL_ENDIAN::(unknown):::::::",

##### MacOS X (a.k.a. Darwin) setup
    "darwin-common" => {
        template         => 1,
        cc               => "cc",
        cflags           => "",
        debug_cflags     => "-g -O0",
        release_cflags   => "-O3",
        thread_cflag     => "-D_REENTRANT",
        sys_id           => "MACOSX",
        lflags           => "-Wl,-search_paths_first%",
        bn_ops           => "BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR",
        perlasm_scheme   => "osx32",
        dso_scheme       => "dlfcn",
        shared_target    => "darwin-shared",
        shared_cflag     => "-fPIC -fno-common",
        shared_ldflag    => "-dynamiclib",
        shared_extension => ".\$(SHLIB_MAJOR).\$(SHLIB_MINOR).dylib",
    },
    "darwin-ppc-cc" => {
        inherit_from     => [ "darwin-common", asm("ppc32_asm") ],
        cflags           => "-arch ppc -DB_ENDIAN -Wa,-force_cpusubtype_ALL",
        perlasm_scheme   => "osx32",
        shared_ldflag    => "-arch ppc -dynamiclib",
    },
    "darwin64-ppc-cc" => {
        inherit_from     => [ "darwin-common", asm("ppc64_asm") ],
        cflags           => "-arch ppc64 -DB_ENDIAN",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR",
        perlasm_scheme   => "osx64",
        shared_ldflag    => "-arch ppc64 -dynamiclib",
    },
    "darwin-i386-cc" => {
        inherit_from     => [ "darwin-common", asm("x86_asm") ],
        cflags           => "-arch i386 -DL_ENDIAN",
        release_cflags   => "-O3 -fomit-frame-pointer",
        bn_ops           => "BN_LLONG RC4_INT RC4_CHUNK DES_UNROLL BF_PTR",
        perlasm_scheme   => "macosx",
        shared_ldflag    => "-arch i386 -dynamiclib",
    },
    "darwin64-x86_64-cc" => {
        inherit_from     => [ "darwin-common", asm("x86_64_asm") ],
        cflags           => "-arch x86_64 -DL_ENDIAN -Wall",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL",
        perlasm_scheme   => "macosx",
        shared_ldflag    => "-arch x86_64 -dynamiclib",
    },

#### iPhoneOS/iOS
#
# It takes three prior-set environment variables to make it work:
#
# CROSS_COMPILE=/where/toolchain/is/usr/bin/ [note ending slash]
# CROSS_TOP=/where/SDKs/are
# CROSS_SDK=iPhoneOSx.y.sdk
#
# Exact paths vary with Xcode releases, but for couple of last ones
# they would look like this:
#
# CROSS_COMPILE=`xcode-select --print-path`/Toolchains/XcodeDefault.xctoolchain/usr/bin/
# CROSS_TOP=`xcode-select --print-path`/Platforms/iPhoneOS.platform/Developer
# CROSS_SDK=iPhoneOS.sdk
#
    "iphoneos-cross" => {
        inherit_from     => [ "darwin-common" ],
        cflags           => "-isysroot \$(CROSS_TOP)/SDKs/\$(CROSS_SDK) -fno-common",
        sys_id           => "iOS",
    },
    "ios-cross" => {
        inherit_from     => [ "darwin-common", asm("armv4_asm") ],
        # It should be possible to go below iOS 6 and even add -arch armv6,
        # thus targeting iPhone pre-3GS, but it's assumed to be irrelevant
        # at this point.
        cflags           => "-arch armv7 -mios-version-min=6.0.0 -isysroot \$(CROSS_TOP)/SDKs/\$(CROSS_SDK) -fno-common",
        sys_id           => "iOS",
        perlasm_scheme   => "ios32",
    },
    "ios64-cross" => {
        inherit_from     => [ "darwin-common", asm("aarch64_asm") ],
        cflags           => "-arch arm64 -mios-version-min=7.0.0 -isysroot \$(CROSS_TOP)/SDKs/\$(CROSS_SDK) -fno-common",
        sys_id           => "iOS",
        bn_ops           => "SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR",
        perlasm_scheme   => "ios64",
    },

##### GNU Hurd
    "hurd-x86" => {
        inherit_from     => [ asm("x86_elf_asm") ],
        cc               => "gcc",
        cflags           => "-DL_ENDIAN -O3 -fomit-frame-pointer -march=i486 -Wall",
        thread_cflag     => "-pthread",
        lflags           => "-ldl",
        bn_ops           => "BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}",
        dso_scheme       => "dlfcn",
        shared_target    => "linux-shared",
        shared_cflag     => "-fPIC",
    },

##### OS/2 EMX
    "OS2-EMX" => {
        cc               => "gcc",
    },

##### VxWorks for various targets
    "vxworks-ppc60x" => {
        cc               => "ccppc",
        cflags           => "-D_REENTRANT -mrtp -mhard-float -mstrict-align -fno-implicit-fp -DPPC32_fp60x -O2 -fstrength-reduce -fno-builtin -fno-strict-aliasing -Wall -DCPU=PPC32 -DTOOL_FAMILY=gnu -DTOOL=gnu -I\$(WIND_BASE)/target/usr/h -I\$(WIND_BASE)/target/usr/h/wrn/coreip",
        sys_id           => "VXWORKS",
        lflags           => "-Wl,--defsym,__wrs_rtp_base=0xe0000000 -L \$(WIND_BASE)/target/usr/lib/ppc/PPC32/common",
    },
    "vxworks-ppcgen" => {
        cc               => "ccppc",
        cflags           => "-D_REENTRANT -mrtp -msoft-float -mstrict-align -O1 -fno-builtin -fno-strict-aliasing -Wall -DCPU=PPC32 -DTOOL_FAMILY=gnu -DTOOL=gnu -I\$(WIND_BASE)/target/usr/h -I\$(WIND_BASE)/target/usr/h/wrn/coreip",
        sys_id           => "VXWORKS",
        lflags           => "-Wl,--defsym,__wrs_rtp_base=0xe0000000 -L \$(WIND_BASE)/target/usr/lib/ppc/PPC32/sfcommon",
    },
    "vxworks-ppc405" => {
        cc               => "ccppc",
        cflags           => "-g -msoft-float -mlongcall -DCPU=PPC405 -I\$(WIND_BASE)/target/h",
        sys_id           => "VXWORKS",
        lflags           => "-r",
    },
    "vxworks-ppc750" => {
        cc               => "ccppc",
        cflags           => "-ansi -nostdinc -DPPC750 -D_REENTRANT -fvolatile -fno-builtin -fno-for-scope -fsigned-char -Wall -msoft-float -mlongcall -DCPU=PPC604 -I\$(WIND_BASE)/target/h \$(DEBUG_FLAG)",
        sys_id           => "VXWORKS",
        lflags           => "-r",
    },
    "vxworks-ppc750-debug" => {
        cc               => "ccppc",
        cflags           => "-ansi -nostdinc -DPPC750 -D_REENTRANT -fvolatile -fno-builtin -fno-for-scope -fsigned-char -Wall -msoft-float -mlongcall -DCPU=PPC604 -I\$(WIND_BASE)/target/h -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -DDEBUG_SAFESTACK -DDEBUG -g",
        sys_id           => "VXWORKS",
        lflags           => "-r",
    },
    "vxworks-ppc860" => {
        cc               => "ccppc",
        cflags           => "-nostdinc -msoft-float -DCPU=PPC860 -DNO_STRINGS_H -I\$(WIND_BASE)/target/h",
        sys_id           => "VXWORKS",
        lflags           => "-r",
    },
    "vxworks-simlinux" => {
        cc               => "ccpentium",
        cflags           => "-B\$(WIND_BASE)/host/\$(WIND_HOST_TYPE)/lib/gcc-lib/ -D_VSB_CONFIG_FILE=\"\$(WIND_BASE)/target/lib/h/config/vsbConfig.h\" -DL_ENDIAN -DCPU=SIMLINUX -DTOOL_FAMILY=gnu -DTOOL=gnu -fno-builtin -fno-defer-pop -DNO_STRINGS_H -I\$(WIND_BASE)/target/h -I\$(WIND_BASE)/target/h/wrn/coreip -DOPENSSL_NO_HW_PADLOCK",
        sys_id           => "VXWORKS",
        lflags           => "-r",
        ranlib           => "ranlibpentium",
    },
    "vxworks-mips" => {
        inherit_from     => [ asm("mips32_asm") ],
        cc               => "ccmips",
        cflags           => "-mrtp -mips2 -O -G 0 -B\$(WIND_BASE)/host/\$(WIND_HOST_TYPE)/lib/gcc-lib/ -D_VSB_CONFIG_FILE=\"\$(WIND_BASE)/target/lib/h/config/vsbConfig.h\" -DCPU=MIPS32 -msoft-float -mno-branch-likely -DTOOL_FAMILY=gnu -DTOOL=gnu -fno-builtin -fno-defer-pop -DNO_STRINGS_H -I\$(WIND_BASE)/target/usr/h -I\$(WIND_BASE)/target/h/wrn/coreip",
        thread_cflag     => "-D_REENTRANT",
        sys_id           => "VXWORKS",
        lflags           => "-Wl,--defsym,__wrs_rtp_base=0xe0000000 -L \$(WIND_BASE)/target/usr/lib/mips/MIPSI32/sfcommon",
        perlasm_scheme   => "o32",
        ranlib           => "ranlibmips",
    },

#### uClinux
    "uClinux-dist" => {
        cc               => "$ENV{'CC'}",
        cflags           => "\$(CFLAGS)",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "\$(LDFLAGS) \$(LDLIBS)",
        bn_ops           => "BN_LLONG",
        dso_scheme       => "$ENV{'LIBSSL_dlfcn'}",
        shared_target    => "linux-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        ranlib           => "$ENV{'RANLIB'}",
    },
    "uClinux-dist64" => {
        cc               => "$ENV{'CC'}",
        cflags           => "\$(CFLAGS)",
        thread_cflag     => "-D_REENTRANT",
        lflags           => "\$(LDFLAGS) \$(LDLIBS)",
        bn_ops           => "SIXTY_FOUR_BIT_LONG",
        dso_scheme       => "$ENV{'LIBSSL_dlfcn'}",
        shared_target    => "linux-shared",
        shared_cflag     => "-fPIC",
        shared_ldflag    => "-shared",
        shared_extension => ".so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
        ranlib           => "$ENV{'RANLIB'}",
    },

);