| Configurations of OpenSSL target platforms |
| ========================================== |
| |
| Target configurations are a collection of facts that we know about |
| different platforms and their capabilities. We organise them in a |
| hash table, where each entry represent a specific target. |
| |
| In each table entry, the following keys are significant: |
| |
| inherit_from => Other targets to inherit values from. |
| Explained further below. [1] |
| template => Set to 1 if this isn't really a platform |
| target. Instead, this target is a template |
| upon which other targets can be built. |
| Explained further below. [1] |
| |
| sys_id => System identity for systems where that |
| is difficult to determine automatically. |
| |
| cc => The C compiler command, usually one of "cc", |
| "gcc" or "clang". This command is normally |
| also used to link object files and |
| libraries into the final program. |
| cxx => The C++ compiler command, usually one of |
| "c++", "g++" or "clang++". This command is |
| also used when linking a program where at |
| least one of the object file is made from |
| C++ source. |
| cflags => Flags that are used at all times when |
| compiling C object files. |
| cxxflags => Flags that are used at all times when |
| compiling C++ object files. If unset, it |
| gets the same value as cflags. |
| defines => As an alternative, macro definitions may be |
| present here instead of in `cflags'. If |
| given here, they MUST be as an array of the |
| string such as "MACRO=value", or just |
| "MACRO" for definitions without value. |
| shared_cflag => Extra compilation flags used when |
| compiling for shared libraries, typically |
| something like "-fPIC". |
| |
| (linking is a complex thing, see [3] below) |
| ld => Linker command, usually not defined |
| (meaning the compiler command is used |
| instead). |
| (NOTE: this is here for future use, it's |
| not implemented yet) |
| lflags => Flags that are used when linking apps. |
| shared_ldflag => Flags that are used when linking shared |
| or dynamic libraries. |
| plib_lflags => Extra linking flags to appear just before |
| the libraries on the command line. |
| ex_libs => Extra libraries that are needed when |
| linking. |
| |
| ar => The library archive command, the default is |
| "ar". |
| (NOTE: this is here for future use, it's |
| not implemented yet) |
| arflags => Flags to be used with the library archive |
| command. |
| |
| ranlib => The library archive indexing command, the |
| default is 'ranlib' it it exists. |
| |
| unistd => An alternative header to the typical |
| '<unistd.h>'. This is very rarely needed. |
| |
| shared_extension => File name extension used for shared |
| libraries. |
| obj_extension => File name extension used for object files. |
| On unix, this defaults to ".o" (NOTE: this |
| is here for future use, it's not |
| implemented yet) |
| exe_extension => File name extension used for executable |
| files. On unix, this defaults to "" (NOTE: |
| this is here for future use, it's not |
| implemented yet) |
| |
| thread_scheme => The type of threads is used on the |
| configured platform. Currently known |
| values are "(unknown)", "pthreads", |
| "uithreads" (a.k.a solaris threads) and |
| "winthreads". Except for "(unknown)", the |
| actual value is currently ignored but may |
| be used in the future. See further notes |
| below [2]. |
| dso_scheme => The type of dynamic shared objects to build |
| for. This mostly comes into play with |
| engines, but can be used for other purposes |
| as well. Valid values are "DLFCN" |
| (dlopen() et al), "DLFCN_NO_H" (for systems |
| that use dlopen() et al but do not have |
| fcntl.h), "DL" (shl_load() et al), "WIN32" |
| and "VMS". |
| perlasm_scheme => The perlasm method used to created the |
| assembler files used when compiling with |
| assembler implementations. |
| shared_target => The shared library building method used. |
| This is a target found in Makefile.shared. |
| build_scheme => The scheme used to build up a Makefile. |
| In its simplest form, the value is a string |
| with the name of the build scheme. |
| The value may also take the form of a list |
| of strings, if the build_scheme is to have |
| some options. In this case, the first |
| string in the list is the name of the build |
| scheme. |
| Currently recognised build scheme is "unified". |
| For the "unified" build scheme, this item |
| *must* be an array with the first being the |
| word "unified" and the second being a word |
| to identify the platform family. |
| |
| multilib => On systems that support having multiple |
| implementations of a library (typically a |
| 32-bit and a 64-bit variant), this is used |
| to have the different variants in different |
| directories. |
| |
| bn_ops => Building options (was just bignum options |
| in the earlier history of this option, |
| hence the name). This a string of words |
| that describe properties on the designated |
| target platform, such as the type of |
| integers used to build up the bitnum, |
| different ways to implement certain ciphers |
| and so on. To fully comprehend the |
| meaning, the best is to read the affected |
| source. |
| The valid words are: |
| |
| BN_LLONG use 'unsigned long long' in |
| some bignum calculations. |
| This has no value when |
| SIXTY_FOUR_BIT or |
| SIXTY_FOUR_BIT_LONG is given. |
| RC4_CHAR makes the basic RC4 unit of |
| calculation an unsigned char. |
| SIXTY_FOUR_BIT processor registers |
| are 64 bits, long is |
| 32 bits, long long is |
| 64 bits. |
| SIXTY_FOUR_BIT_LONG processor registers |
| are 64 bits, long is |
| 64 bits. |
| THIRTY_TWO_BIT processor registers |
| are 32 bits. |
| EXPORT_VAR_AS_FN for shared libraries, |
| export vars as |
| accessor functions. |
| |
| apps_extra_src => Extra source to build apps/openssl, as |
| needed by the target. |
| cpuid_asm_src => assembler implementation of cpuid code as |
| well as OPENSSL_cleanse(). |
| Default to mem_clr.c |
| bn_asm_src => Assembler implementation of core bignum |
| functions. |
| Defaults to bn_asm.c |
| ec_asm_src => Assembler implementation of core EC |
| functions. |
| des_asm_src => Assembler implementation of core DES |
| encryption functions. |
| Defaults to 'des_enc.c fcrypt_b.c' |
| aes_asm_src => Assembler implementation of core AES |
| functions. |
| Defaults to 'aes_core.c aes_cbc.c' |
| bf_asm_src => Assembler implementation of core BlowFish |
| functions. |
| Defaults to 'bf_enc.c' |
| md5_asm_src => Assembler implementation of core MD5 |
| functions. |
| sha1_asm_src => Assembler implementation of core SHA1, |
| functions, and also possibly SHA256 and |
| SHA512 ones. |
| cast_asm_src => Assembler implementation of core CAST |
| functions. |
| Defaults to 'c_enc.c' |
| rc4_asm_src => Assembler implementation of core RC4 |
| functions. |
| Defaults to 'rc4_enc.c rc4_skey.c' |
| rmd160_asm_src => Assembler implementation of core RMD160 |
| functions. |
| rc5_asm_src => Assembler implementation of core RC5 |
| functions. |
| Defaults to 'rc5_enc.c' |
| wp_asm_src => Assembler implementation of core WHIRLPOOL |
| functions. |
| cmll_asm_src => Assembler implementation of core CAMELLIA |
| functions. |
| Defaults to 'camellia.c cmll_misc.c cmll_cbc.c' |
| modes_asm_src => Assembler implementation of cipher modes, |
| currently the functions gcm_gmult_4bit and |
| gcm_ghash_4bit. |
| padlock_asm_src => Assembler implementation of core parts of |
| the padlock engine. This is mandatory on |
| any platform where the padlock engine might |
| actually be built. |
| |
| |
| [1] as part of the target configuration, one can have a key called |
| 'inherit_from' that indicate what other configurations to inherit |
| data from. These are resolved recursively. |
| |
| Inheritance works as a set of default values that can be overridden |
| by corresponding key values in the inheriting configuration. |
| |
| Note 1: any configuration table can be used as a template. |
| Note 2: pure templates have the attribute 'template => 1' and |
| cannot be used as build targets. |
| |
| If several configurations are given in the 'inherit_from' array, |
| the values of same attribute are concatenated with space |
| separation. With this, it's possible to have several smaller |
| templates for different configuration aspects that can be combined |
| into a complete configuration. |
| |
| instead of a scalar value or an array, a value can be a code block |
| of the form 'sub { /* your code here */ }'. This code block will |
| be called with the list of inherited values for that key as |
| arguments. In fact, the concatenation of strings is really done |
| by using 'sub { join(" ",@_) }' on the list of inherited values. |
| |
| An example: |
| |
| "foo" => { |
| template => 1, |
| haha => "ha ha", |
| hoho => "ho", |
| ignored => "This should not appear in the end result", |
| }, |
| "bar" => { |
| template => 1, |
| haha => "ah", |
| hoho => "haho", |
| hehe => "hehe" |
| }, |
| "laughter" => { |
| inherit_from => [ "foo", "bar" ], |
| hehe => sub { join(" ",(@_,"!!!")) }, |
| ignored => "", |
| } |
| |
| The entry for "laughter" will become as follows after processing: |
| |
| "laughter" => { |
| haha => "ha ha ah", |
| hoho => "ho haho", |
| hehe => "hehe !!!", |
| ignored => "" |
| } |
| |
| [2] OpenSSL is built with threading capabilities unless the user |
| specifies 'no-threads'. The value of the key 'thread_scheme' may |
| be "(unknown)", in which case the user MUST give some compilation |
| flags to Configure. |
| |
| [3] OpenSSL has three types of things to link from object files or |
| static libraries: |
| |
| - shared libraries; that would be libcrypto and libssl. |
| - shared objects (sometimes called dynamic libraries); that would |
| be the engines. |
| - applications; those are apps/openssl and all the test apps. |
| |
| Very roughly speaking, linking is done like this (words in braces |
| represent the configuration settings documented at the beginning |
| of this file): |
| |
| shared libraries: |
| {ld} $(CFLAGS) {shared_ldflag} -shared -o libfoo.so \ |
| -Wl,--whole-archive libfoo.a -Wl,--no-whole-archive \ |
| {plib_lflags} -lcrypto {ex_libs} |
| |
| shared objects: |
| {ld} $(CFLAGS) {shared_ldflag} -shared -o libeng.so \ |
| blah1.o blah2.o {plib_lflags} -lcrypto {ex_libs} |
| |
| applications: |
| {ld} $(CFLAGS) {lflags} -o app \ |
| app1.o utils.o {plib_lflags} -lssl -lcrypto {ex_libs} |
| |
| |
| Historically, the target configurations came in form of a string with |
| values separated by colons. This use is deprecated. The string form |
| looked like this: |
| |
| "target" => "{cc}:{cflags}:{unistd}:{thread_cflag}:{sys_id}:{lflags}:{bn_ops}:{cpuid_obj}:{bn_obj}:{ec_obj}:{des_obj}:{aes_obj}:{bf_obj}:{md5_obj}:{sha1_obj}:{cast_obj}:{rc4_obj}:{rmd160_obj}:{rc5_obj}:{wp_obj}:{cmll_obj}:{modes_obj}:{padlock_obj}:{perlasm_scheme}:{dso_scheme}:{shared_target}:{shared_cflag}:{shared_ldflag}:{shared_extension}:{ranlib}:{arflags}:{multilib}" |
| |
| |
| Build info files |
| ================ |
| |
| The build.info files that are spread over the source tree contain the |
| minimum information needed to build and distribute OpenSSL. It uses a |
| simple and yet fairly powerful language to determine what needs to be |
| built, from what sources, and other relationships between files. |
| |
| For every build.info file, all file references are relative to the |
| directory of the build.info file for source files, and the |
| corresponding build directory for built files if the build tree |
| differs from the source tree. |
| |
| When processed, every line is processed with the perl module |
| Text::Template, using the delimiters "{-" and "-}". The hashes |
| %config and %target are passed to the perl fragments, along with |
| $sourcedir and $builddir, which are the locations of the source |
| directory for the current build.info file and the corresponding build |
| directory, all relative to the top of the build tree. |
| |
| To begin with, things to be built are declared by setting specific |
| variables: |
| |
| PROGRAMS=foo bar |
| LIBS=libsomething |
| ENGINES=libeng |
| SCRIPTS=myhack |
| EXTRA=file1 file2 |
| |
| Note that the files mentioned for PROGRAMS, LIBS and ENGINES *must* be |
| without extensions. The build file templates will figure them out. |
| |
| For each thing to be built, it is then possible to say what sources |
| they are built from: |
| |
| PROGRAMS=foo bar |
| SOURCE[foo]=foo.c common.c |
| SOURCE[bar]=bar.c extra.c common.c |
| |
| It's also possible to tell some other dependencies: |
| |
| DEPEND[foo]=libsomething |
| DEPEND[libbar]=libsomethingelse |
| |
| (it could be argued that 'libsomething' and 'libsomethingelse' are |
| source as well. However, the files given through SOURCE are expected |
| to be located in the source tree while files given through DEPEND are |
| expected to be located in the build tree) |
| |
| It's also possible to depend on static libraries explicitely: |
| |
| DEPEND[foo]=libsomething.a |
| DEPEND[libbar]=libsomethingelse.a |
| |
| This should be rarely used, and care should be taken to make sure it's |
| only used when supported. For example, native Windows build doesn't |
| support build static libraries and DLLs at the same time, so using |
| static libraries on Windows can only be done when configured |
| 'no-shared'. |
| |
| For some libraries, we maintain files with public symbols and their |
| slot in a transfer vector (important on some platforms). It can be |
| declared like this: |
| |
| ORDINALS[libcrypto]=crypto |
| |
| The value is not the name of the file in question, but rather the |
| argument to util/mkdef.pl that indicates which file to use. |
| |
| One some platforms, shared libraries come with a name that's different |
| from their static counterpart. That's declared as follows: |
| |
| SHARED_NAME[libfoo]=cygfoo-{- $config{shlibver} -} |
| |
| The example is from Cygwin, which has a required naming convention. |
| |
| Sometimes, it makes sense to rename an output file, for example a |
| library: |
| |
| RENAME[libfoo]=libbar |
| |
| That lines has "libfoo" get renamed to "libbar". While it makes no |
| sense at all to just have a rename like that (why not just use |
| "libbar" everywhere?), it does make sense when it can be used |
| conditionally. See a little further below for an example. |
| |
| In some cases, it's desirable to include some source files in the |
| shared form of a library only: |
| |
| SHARED_SOURCE[libfoo]=dllmain.c |
| |
| For any file to be built, it's also possible to tell what extra |
| include paths the build of their source files should use: |
| |
| INCLUDE[foo]=include |
| |
| In some cases, one might want to generate some source files from |
| others, that's done as follows: |
| |
| GENERATE[foo.s]=asm/something.pl $(CFLAGS) |
| GENERATE[bar.s]=asm/bar.S |
| |
| The value of each GENERATE line is a command line or part of it. |
| Configure places no rules on the command line, except the the first |
| item muct be the generator file. It is, however, entirely up to the |
| build file template to define exactly how those command lines should |
| be handled, how the output is captured and so on. |
| |
| Sometimes, the generator file itself depends on other files, for |
| example if it is a perl script that depends on other perl modules. |
| This can be expressed using DEPEND like this: |
| |
| DEPEND[asm/something.pl]=../perlasm/Foo.pm |
| |
| There may also be cases where the exact file isn't easily specified, |
| but an inclusion directory still needs to be specified. INCLUDE can |
| be used in that case: |
| |
| INCLUDE[asm/something.pl]=../perlasm |
| |
| NOTE: GENERATE lines are limited to one command only per GENERATE. |
| |
| As a last resort, it's possible to have raw build file lines, between |
| BEGINRAW and ENDRAW lines as follows: |
| |
| BEGINRAW[Makefile(unix)] |
| haha.h: {- $builddir -}/Makefile |
| echo "/* haha */" > haha.h |
| ENDRAW[Makefile(unix)] |
| |
| The word within square brackets is the build_file configuration item |
| or the build_file configuration item followed by the second word in the |
| build_scheme configuration item for the configured target within |
| parenthesis as shown above. For example, with the following relevant |
| configuration items: |
| |
| build_file => "build.ninja" |
| build_scheme => [ "unified", "unix" ] |
| |
| ... these lines will be considered: |
| |
| BEGINRAW[build.ninja] |
| build haha.h: echo "/* haha */" > haha.h |
| ENDRAW[build.ninja] |
| |
| BEGINRAW[build.ninja(unix)] |
| build hoho.h: echo "/* hoho */" > hoho.h |
| ENDRAW[build.ninja(unix)] |
| |
| Should it be needed because the recipes within a RAW section might |
| clash with those generated by Configure, it's possible to tell it |
| not to generate them with the use of OVERRIDES, for example: |
| |
| SOURCE[libfoo]=foo.c bar.c |
| |
| OVERRIDES=bar.o |
| BEGINRAW[Makefile(unix)] |
| bar.o: bar.c |
| $(CC) $(CFLAGS) -DSPECIAL -c -o $@ $< |
| ENDRAW[Makefile(unix)] |
| |
| See the documentation further up for more information on configuration |
| items. |
| |
| Finally, you can have some simple conditional use of the build.info |
| information, looking like this: |
| |
| IF[1] |
| something |
| ELSIF[2] |
| something other |
| ELSE |
| something else |
| ENDIF |
| |
| The expression in square brackets is interpreted as a string in perl, |
| and will be seen as true if perl thinks it is, otherwise false. For |
| example, the above would have "something" used, since 1 is true. |
| |
| Together with the use of Text::Template, this can be used as |
| conditions based on something in the passed variables, for example: |
| |
| IF[{- $disabled{shared} -}] |
| LIBS=libcrypto |
| SOURCE[libcrypto]=... |
| ELSE |
| LIBS=libfoo |
| SOURCE[libfoo]=... |
| ENDIF |
| |
| or: |
| |
| # VMS has a cultural standard where all libraries are prefixed. |
| # For OpenSSL, the choice is 'ossl_' |
| IF[{- $config{target} =~ /^vms/ -}] |
| RENAME[libcrypto]=ossl_libcrypto |
| RENAME[libssl]=ossl_libssl |
| ENDIF |
| |
| |
| Build-file programming with the "unified" build system |
| ====================================================== |
| |
| "Build files" are called "Makefile" on Unix-like operating systems, |
| "descrip.mms" for MMS on VMS, "makefile" for nmake on Windows, etc. |
| |
| To use the "unified" build system, the target configuration needs to |
| set the three items 'build_scheme', 'build_file' and 'build_command'. |
| In the rest of this section, we will assume that 'build_scheme' is set |
| to "unified" (see the configurations documentation above for the |
| details). |
| |
| For any name given by 'build_file', the "unified" system expects a |
| template file in Configurations/ named like the build file, with |
| ".tmpl" appended, or in case of possible ambiguity, a combination of |
| the second 'build_scheme' list item and the 'build_file' name. For |
| example, if 'build_file' is set to "Makefile", the template could be |
| Configurations/Makefile.tmpl or Configurations/unix-Makefile.tmpl. |
| In case both Configurations/unix-Makefile.tmpl and |
| Configurations/Makefile.tmpl are present, the former takes |
| precedence. |
| |
| The build-file template is processed with the perl module |
| Text::Template, using "{-" and "-}" as delimiters that enclose the |
| perl code fragments that generate configuration-dependent content. |
| Those perl fragments have access to all the hash variables from |
| configdata.pem. |
| |
| The build-file template is expected to define at least the following |
| perl functions in a perl code fragment enclosed with "{-" and "-}". |
| They are all expected to return a string with the lines they produce. |
| |
| generatesrc - function that produces build file lines to generate |
| a source file from some input. |
| |
| It's called like this: |
| |
| generatesrc(src => "PATH/TO/tobegenerated", |
| generator => [ "generatingfile", ... ] |
| generator_incs => [ "INCL/PATH", ... ] |
| generator_deps => [ "dep1", ... ] |
| generator => [ "generatingfile", ... ] |
| incs => [ "INCL/PATH", ... ], |
| deps => [ "dep1", ... ], |
| intent => one of "libs", "dso", "bin" ); |
| |
| 'src' has the name of the file to be generated. |
| 'generator' is the command or part of command to |
| generate the file, of which the first item is |
| expected to be the file to generate from. |
| generatesrc() is expected to analyse and figure out |
| exactly how to apply that file and how to capture |
| the result. 'generator_incs' and 'generator_deps' |
| are include directories and files that the generator |
| file itself depends on. 'incs' and 'deps' are |
| include directories and files that are used if $(CC) |
| is used as an intermediary step when generating the |
| end product (the file indicated by 'src'). 'intent' |
| indicates what the generated file is going to be |
| used for. |
| |
| src2obj - function that produces build file lines to build an |
| object file from source files and associated data. |
| |
| It's called like this: |
| |
| src2obj(obj => "PATH/TO/objectfile", |
| srcs => [ "PATH/TO/sourcefile", ... ], |
| deps => [ "dep1", ... ], |
| incs => [ "INCL/PATH", ... ] |
| intent => one of "lib", "dso", "bin" ); |
| |
| 'obj' has the intended object file *without* |
| extension, src2obj() is expected to add that. |
| 'srcs' has the list of source files to build the |
| object file, with the first item being the source |
| file that directly corresponds to the object file. |
| 'deps' is a list of explicit dependencies. 'incs' |
| is a list of include file directories. Finally, |
| 'intent' indicates what this object file is going |
| to be used for. |
| |
| obj2lib - function that produces build file lines to build a |
| static library file ("libfoo.a" in Unix terms) from |
| object files. |
| |
| called like this: |
| |
| obj2lib(lib => "PATH/TO/libfile", |
| objs => [ "PATH/TO/objectfile", ... ]); |
| |
| 'lib' has the intended library file name *without* |
| extension, obj2lib is expected to add that. 'objs' |
| has the list of object files (also *without* |
| extension) to build this library. |
| |
| libobj2shlib - function that produces build file lines to build a |
| shareable object library file ("libfoo.so" in Unix |
| terms) from the corresponding static library file |
| or object files. |
| |
| called like this: |
| |
| libobj2shlib(shlib => "PATH/TO/shlibfile", |
| lib => "PATH/TO/libfile", |
| objs => [ "PATH/TO/objectfile", ... ], |
| deps => [ "PATH/TO/otherlibfile", ... ], |
| ordinals => [ "word", "/PATH/TO/ordfile" ]); |
| |
| 'lib' has the intended library file name *without* |
| extension, libobj2shlib is expected to add that. |
| 'shlib' has the corresponding shared library name |
| *without* extension. 'deps' has the list of other |
| libraries (also *without* extension) this library |
| needs to be linked with. 'objs' has the list of |
| object files (also *without* extension) to build |
| this library. 'ordinals' MAY be present, and when |
| it is, its value is an array where the word is |
| "crypto" or "ssl" and the file is one of the ordinal |
| files util/libeay.num or util/ssleay.num in the |
| source directory. |
| |
| This function has a choice; it can use the |
| corresponding static library as input to make the |
| shared library, or the list of object files. |
| |
| obj2dso - function that produces build file lines to build a |
| dynamic shared object file from object files. |
| |
| called like this: |
| |
| obj2dso(lib => "PATH/TO/libfile", |
| objs => [ "PATH/TO/objectfile", ... ], |
| deps => [ "PATH/TO/otherlibfile", |
| ... ]); |
| |
| This is almost the same as libobj2shlib, but the |
| intent is to build a shareable library that can be |
| loaded in runtime (a "plugin"...). The differences |
| are subtle, one of the most visible ones is that the |
| resulting shareable library is produced from object |
| files only. |
| |
| obj2bin - function that produces build file lines to build an |
| executable file from object files. |
| |
| called like this: |
| |
| obj2bin(bin => "PATH/TO/binfile", |
| objs => [ "PATH/TO/objectfile", ... ], |
| deps => [ "PATH/TO/libfile", ... ]); |
| |
| 'bin' has the intended executable file name |
| *without* extension, obj2bin is expected to add |
| that. 'objs' has the list of object files (also |
| *without* extension) to build this library. 'deps' |
| has the list of library files (also *without* |
| extension) that the programs needs to be linked |
| with. |
| |
| in2script - function that produces build file lines to build a |
| script file from some input. |
| |
| called like this: |
| |
| in2script(script => "PATH/TO/scriptfile", |
| sources => [ "PATH/TO/infile", ... ]); |
| |
| 'script' has the intended script file name. |
| 'sources' has the list of source files to build the |
| resulting script from. |
| |
| In all cases, file file paths are relative to the build tree top, and |
| the build file actions run with the build tree top as current working |
| directory. |
| |
| Make sure to end the section with these functions with a string that |
| you thing is appropriate for the resulting build file. If nothing |
| else, end it like this: |
| |
| ""; # Make sure no lingering values end up in the Makefile |
| -} |
