| #!/usr/bin/perl |
| |
| # |
| #//===----------------------------------------------------------------------===// |
| #// |
| #// The LLVM Compiler Infrastructure |
| #// |
| #// This file is dual licensed under the MIT and the University of Illinois Open |
| #// Source Licenses. See LICENSE.txt for details. |
| #// |
| #//===----------------------------------------------------------------------===// |
| # |
| |
| # Pragmas. |
| use strict; |
| use warnings; |
| |
| # Standard modules. |
| use Data::Dumper; # Not actually used, but useful for debugging dumps. |
| |
| # Enable `libomp/tools/lib/' module directory. |
| use FindBin; |
| use lib "$FindBin::Bin/lib"; |
| |
| # LIBOMP modules. |
| use Build; |
| use LibOMP; |
| use Platform ":vars"; |
| use Uname; |
| use tools; |
| |
| our $VERSION = "0.017"; |
| |
| # -------------------------------------------------------------------------------------------------- |
| # Important variables. |
| # -------------------------------------------------------------------------------------------------- |
| |
| my $root_dir = $ENV{ LIBOMP_WORK }; |
| |
| my %makefiles = ( |
| rtl => cat_file( $root_dir, "src", "makefile.mk" ), |
| timelimit => cat_file( $root_dir, "tools", "src", "timelimit", "makefile.mk" ), |
| ); |
| |
| # -------------------------------------------------------------------------------------------------- |
| # Parse command line. |
| # -------------------------------------------------------------------------------------------------- |
| |
| # Possible options. |
| # * targets: comma separated list of targets the option has meaning for. For example, |
| # "version" option (4 or 5) has a meaning only for "rtl" target, while "mode" option has |
| # meaning for all targets. |
| # * base: If base is true this is a base option. All the possible values of base options are |
| # iterated if "--all" option is specified. If base is 0, this is an extra option. |
| # * params: A hash of possible option values. "*" denotes default option value. For example, |
| # if "versio" option is not specified, "--version=5" will be used implicitly. |
| # * suffux: Only for extra options. Subroutine returning suffix for build and output |
| # directories. |
| my $opts = { |
| "target" => { targets => "", base => 1, parms => { map( ( $_ => "" ), keys( %makefiles ) ), rtl => "*" }, }, |
| "version" => { targets => "rtl", base => 1, parms => { 5 => "*", 4 => "" }, }, |
| "lib-type" => { targets => "rtl", base => 1, parms => { normal => "*", stubs => "" }, }, |
| "link-type" => { targets => "rtl", base => 1, parms => { dynamic => "*", static => "" }, }, |
| "target-compiler" => { targets => "rtl,dsl", base => 0, parms => { 12 => "*", 11 => "" }, suffix => sub { $_[ 0 ]; } }, |
| "mode" => { targets => "rtl,dsl,timelimit", base => 0, parms => { release => "*", diag => "", debug => "" }, suffix => sub { substr( $_[ 0 ], 0, 3 ); } }, |
| "omp-version" => { targets => "rtl", base => 0, parms => { 40 => "*", 30 => "", 25 => "" }, suffix => sub { $_[ 0 ]; } }, |
| "coverage" => { targets => "rtl", base => 0, parms => { off => "*", on => "" }, suffix => sub { $_[ 0 ] eq "on" ? "c1" : "c0"; } }, |
| "tcheck" => { targets => "rtl", base => 0, parms => { 0 => "*", 1 => "", 2 => "" }, suffix => sub { "t" . $_[ 0 ]; } }, |
| "mic-arch" => { targets => "rtl", base => 0, parms => { knf => "*", knc => "", knl => "" }, suffix => sub { $_[ 0 ]; } }, |
| "mic-os" => { targets => "rtl", base => 0, parms => { bsd => "*", lin => "" }, suffix => sub { $_[ 0 ]; } }, |
| "mic-comp" => { targets => "rtl", base => 0, parms => { native => "*", offload => "" }, suffix => sub { substr( $_[ 0 ], 0, 3 ); } }, |
| }; |
| my $synonyms = { |
| "debug" => [ qw{ dbg debg } ], |
| }; |
| # This array specifies order of options to process, so it cannot be initialized with keys( %$opts ). |
| my @all_opts = qw{ target version lib-type link-type target-compiler mode omp-version coverage tcheck mic-arch mic-os mic-comp }; |
| # This is the list of base options. |
| my @base_opts = grep( $opts->{ $_ }->{ base } == 1, @all_opts ); |
| # This is the list of extra options. |
| my @extra_opts = grep( $opts->{ $_ }->{ base } == 0, @all_opts ); |
| |
| sub suffix($$$) { |
| my ( $opt, $value, $skip_if_default ) = @_; |
| my $suffix = ""; |
| if ( not $skip_if_default or $value ne $opts->{ $opt }->{ dflt } ) { |
| $suffix = $opts->{ $opt }->{ suffix }->( $value ); |
| }; # if |
| return $suffix; |
| }; # sub suffix |
| |
| my $scuts = {}; # Shortcuts. Will help to locate proper item in $opts. |
| foreach my $opt ( keys( %$opts ) ) { |
| foreach my $parm ( keys( %{ $opts->{ $opt }->{ parms } } ) ) { |
| if ( $parm !~ m{\A(?:[012]|on|off)\z} ) { |
| $scuts->{ $parm } = $opts->{ $opt }; |
| }; # if |
| if ( $opts->{ $opt }->{ parms }->{ $parm } eq "*" ) { |
| $opts->{ $opt }->{ dflt } = $parm; |
| }; # if |
| }; # foreach $parm |
| }; # foreach $opt |
| |
| sub parse_option(@) { |
| # This function is called to process every option. $name is option name, $value is option value. |
| # For boolean options $value is either 1 or 0, |
| my ( $name, $value ) = @_; |
| if ( $name eq "all" or $name eq "ALL" ) { |
| foreach my $opt ( keys( %$opts ) ) { |
| if ( $opts->{ $opt }->{ base } or $name eq "ALL" ) { |
| foreach my $parm ( keys( %{ $opts->{ $opt }->{ parms } } ) ) { |
| $opts->{ $opt }->{ parms }->{ $parm } = 1; |
| }; # foreach $parm |
| }; # if |
| }; # foreach $opt |
| return; |
| }; # if |
| if ( exists( $opts->{ $name } ) ) { |
| # Suppose it is option with explicit value, like "target=normal". |
| if ( $value eq "all" ) { |
| foreach my $parm ( keys( %{ $opts->{ $name }->{ parms } } ) ) { |
| $opts->{ $name }->{ parms }->{ $parm } = 1; |
| }; # foreach |
| return; |
| } elsif ( exists( $opts->{ $name }->{ parms }->{ $value } ) ) { |
| $opts->{ $name }->{ parms }->{ $value } = 1; |
| return; |
| } elsif ( $value eq "" and exists( $opts->{ $name }->{ parms }->{ on } ) ) { |
| $opts->{ $name }->{ parms }->{ on } = 1; |
| return; |
| } else { |
| cmdline_error( "Illegal value of \"$name\" option: \"$value\"" ); |
| }; # if |
| }; # if |
| # Ok, it is not an option with explicit value. Try to treat is as a boolean option. |
| if ( exists( $scuts->{ $name } ) ) { |
| ( $value eq "1" or $value eq "0" ) or die "Internal error; stopped"; |
| $scuts->{ $name }->{ parms }->{ $name } = $value; |
| return; |
| }; # if |
| # No, it is not a valid option at all. |
| cmdline_error( "Illegal option: \"$name\"" ); |
| }; # sub parse_option |
| |
| my $clean = 0; |
| my $clean_common = 0; |
| my $clobber = 0; |
| my $test_deps = 1; |
| my $test_touch = 1; |
| my @goals; |
| |
| sub synonyms($) { |
| my ( $opt ) = @_; |
| return exists( $synonyms->{ $opt } ) ? "|" . join( "|", @{ $synonyms->{ $opt } } ) : ""; |
| }; # sub synonyms |
| |
| my @specs = ( |
| map( ( "$_" . synonyms( $_ ) . "=s" => \&parse_option ), keys( %$opts ) ), |
| map( ( "$_" . synonyms( $_ ) . "!" => \&parse_option ), keys( %$scuts ) ), |
| ); |
| my $answer; |
| get_options( |
| @specs, |
| Platform::target_options(), |
| "all" => \&parse_option, |
| "ALL" => \&parse_option, |
| "answer=s" => \$answer, |
| "test-deps!" => \$test_deps, |
| "test-touch!" => \$test_touch, |
| "version|ver:s" => |
| sub { |
| # It is a tricky option. It specifies library version to build and it is also a standard |
| # option to request tool version. |
| if ( $_[ 1 ] eq "" ) { |
| # No arguments => version request. |
| print( "$tool version $VERSION\n" ); |
| exit( 0 ); |
| } else { |
| # Arguments => version to build. |
| parse_option( @_ ) |
| }; |
| }, |
| ); |
| @goals = @ARGV; |
| if ( grep( $_ eq "clobber", @goals ) ) { |
| $clobber = 1; |
| }; # if |
| if ( grep( $_ eq "clean", @goals ) ) { |
| $clean = 1; |
| }; # if |
| |
| # Ok, now $opts is fulfilled with 0, 1 (explicitly set by the user) and "" and "*" (original |
| # values). In each option at least one 1 should be present (otherwise there is nothing to build). |
| foreach my $opt ( keys( %$opts ) ) { |
| if ( not grep( $_ eq "1", values( %{ $opts->{ $opt }->{ parms } } ) ) ) { |
| # No explicit "1" found. Enable default choice by replacing "*" with "1". |
| foreach my $parm ( keys( %{ $opts->{ $opt }->{ parms } } ) ) { |
| if ( $opts->{ $opt }->{ parms }->{ $parm } eq "*" ) { |
| $opts->{ $opt }->{ parms }->{ $parm } = 1; |
| }; # if |
| }; # foreach $parm |
| }; # if |
| }; # foreach $opt |
| |
| # Clear $opts. Leave only "1". |
| foreach my $opt ( keys( %$opts ) ) { |
| foreach my $parm ( keys( %{ $opts->{ $opt }->{ parms } } ) ) { |
| if ( $opts->{ $opt }->{ parms }->{ $parm } ne "1" ) { |
| delete( $opts->{ $opt }->{ parms }->{ $parm } ); |
| }; # if |
| }; # foreach $parm |
| }; # foreach $opt |
| |
| # -------------------------------------------------------------------------------------------------- |
| # Fill job queue. |
| # -------------------------------------------------------------------------------------------------- |
| |
| sub enqueue_jobs($$@); |
| sub enqueue_jobs($$@) { |
| my ( $jobs, $set, @rest ) = @_; |
| if ( @rest ) { |
| my $opt = shift( @rest ); |
| if ( |
| exists( $set->{ target } ) |
| and |
| $opts->{ $opt }->{ targets } !~ m{(?:\A|,)$set->{ target }(?:,|\z)} |
| ) { |
| # This option does not have meananing for the target, |
| # do not iterate, just use default value. |
| enqueue_jobs( $jobs, { $opt => $opts->{ $opt }->{ dflt }, %$set }, @rest ); |
| } else { |
| foreach my $parm ( sort( keys( %{ $opts->{ $opt }->{ parms } } ) ) ) { |
| enqueue_jobs( $jobs, { $opt => $parm, %$set }, @rest ); |
| }; # foreach $parm |
| }; # if |
| } else { |
| my $makefile = $makefiles{ $set->{ target } }; |
| my @base = map( substr( $set->{ $_ }, 0, 3 ), @base_opts ); |
| my @extra = map( suffix( $_, $set->{ $_ }, 0 ), @extra_opts ); |
| my @ex = grep( $_ ne "", map( suffix( $_, $set->{ $_ }, 1 ), @extra_opts ) ); |
| # Shortened version of @extra -- only non-default values. |
| my $suffix = ( @extra ? "." . join( ".", @extra ) : "" ); |
| my $knights = index( $suffix, "kn" ) - 1; |
| if ( $target_platform !~ "lrb" and $knights > 0 ) { |
| $suffix = substr( $suffix, 0, $knights ); |
| } |
| my $suf = ( @ex ? "." . join( ".", @ex ) : "" ); |
| # Shortened version of $siffix -- only non-default values. |
| my $build_dir = join( "-", $target_platform, join( "_", @base ) . $suffix, Uname::host_name() ); |
| my $out_arch_dir = cat_dir( $ENV{ LIBOMP_EXPORTS }, $target_platform . $suf ); |
| my $out_cmn_dir = cat_dir( $ENV{ LIBOMP_EXPORTS }, "common" ); |
| push( |
| @$jobs, |
| { |
| makefile => $makefile, |
| make_args => [ |
| "os=" . $target_os, |
| "arch=" . $target_arch, |
| "MIC_OS=" . $set->{ "mic-os" }, |
| "MIC_ARCH=" . $set->{ "mic-arch" }, |
| "MIC_COMP=" . $set->{ "mic-comp" }, |
| "date=" . Build::tstr( $Build::start ), |
| "TEST_DEPS=" . ( $test_deps ? "on" : "off" ), |
| "TEST_TOUCH=" . ( $test_touch ? "on" : "off" ), |
| "CPLUSPLUS=on", |
| "COVERAGE=" . $set->{ coverage }, |
| # Option "mode" controls 3 make flags: |
| # debug => Full debugging : diagnostics, debug info, no optimization. |
| # diag => Only diagnostics : diagnostics, debug info, optimization. |
| # release => Production build : no diagnostics, no debug info, optimization. |
| "DEBUG_INFO=" . ( $set->{ mode } ne "release" ? "on" : "off" ), |
| "DIAG=" . ( $set->{ mode } ne "release" ? "on" : "off" ), |
| "OPTIMIZATION=" . ( $set->{ mode } ne "debug" ? "on" : "off" ), |
| "LIB_TYPE=" . substr( $set->{ "lib-type" }, 0, 4 ), |
| "LINK_TYPE=" . substr( $set->{ "link-type" }, 0, 4 ), |
| "OMP_VERSION=" . $set->{ "omp-version" }, |
| "USE_TCHECK=" . $set->{ tcheck }, |
| "VERSION=" . $set->{ version }, |
| "TARGET_COMPILER=" . $set->{ "target-compiler" }, |
| "suffix=" . $suf, |
| @goals, |
| ], |
| build_dir => $build_dir |
| } |
| ); # push |
| }; # if |
| }; # sub enqueue_jobs |
| |
| my @jobs; |
| enqueue_jobs( \@jobs, {}, @all_opts ); |
| |
| # -------------------------------------------------------------------------------------------------- |
| # Do the work. |
| # -------------------------------------------------------------------------------------------------- |
| |
| my $exit = 0; |
| |
| Build::init(); |
| |
| if ( $clobber ) { |
| my @dirs = ( $ENV{ LIBOMP_TMP }, $ENV{ LIBOMP_EXPORTS }, cat_dir( $root_dir, "tools", "bin" ) ); |
| my $rc = 0; |
| question( |
| "Clobber " . join( ", ", map( "\"" . Build::shorter( $_ ) . "\"", @dirs ) ) . " dirs? ", |
| $answer, |
| qr{\A(y|yes|n|no)\z}i |
| ); |
| if ( $answer =~ m{\Ay}i ) { |
| info( "Clobbering..." ); |
| $rc = Build::clean( @dirs ); |
| info( Build::rstr( $rc ) ); |
| }; # if |
| if ( $rc != 0 ) { |
| $exit = 3; |
| }; # if |
| } else { # Build or clean. |
| if ( @jobs ) { |
| my $total = @jobs; # Total number of jobs. |
| my $n = 0; # Current job number. |
| Build::progress( "", "" ); # Output empty line to log file. |
| my $goals = join( " ", @goals ); |
| Build::progress( "Goals", $goals eq "" ? "(all)" : $goals ); |
| Build::progress( "Configurations", scalar( @jobs ) ); |
| foreach my $job ( @jobs ) { |
| ++ $n; |
| my $base = get_file( $job->{ build_dir } ); |
| Build::progress( "Making", "%3d of %3d : %s", $n, $total, $base ); |
| $job->{ rc } = Build::make( $job, $clean, sprintf( "%d/%d", $n, $total ) ); |
| }; # my $job |
| my $failures = Build::summary(); |
| if ( $failures > 0 ) { |
| $exit = 3; |
| }; # if |
| } else { |
| info( "Nothing to do." ); |
| }; # if |
| }; # if |
| |
| # And exit. |
| exit( $exit ); |
| |
| __END__ |
| |
| =pod |
| |
| =head1 NAME |
| |
| |
| B<build.pl> -- Build one or more configurations of OMP RTL libraries. |
| |
| =head1 SYNOPSIS |
| |
| B<build.pl> I<option>... [B<-->] I<make-option>... I<variable>... I<goal>... |
| |
| =head1 OPTIONS |
| |
| =over |
| |
| =item B<--all> |
| |
| Build all base configurations. |
| |
| =item B<--ALL> |
| |
| Build really all configurations, including extra ones. |
| |
| =item B<--answer=>I<str> |
| |
| Use specified string as default answer to all questions. |
| |
| =item B<--architecture=>I<arch> |
| |
| Specify target architecture to build. Default is architecture of host machine. I<arch> can be C<32>, |
| C<32e>, or one of known aliases like C<IA32>. |
| |
| If architecture is not specified explicitly, value of LIBOMP_ARCH environment variable is used. |
| If LIBOMP_ARCH is not defined, host architecture detected. |
| |
| =item B<--os=>I<os> |
| |
| Specify target OS. Default is OS of host machine. I<os> can be C<lin>, C<lrb>, C<mac>, C<win>, |
| or one of known aliases like C<Linux>, C<WinNT>, etc. |
| |
| =item B<--mic-os=>I<os> |
| |
| Specify OS on Intel(R) Many Integrated Core Architecture card. Default is C<bsd>. I<os> can be C<bsd>, C<lin>. |
| |
| =item B<--mic-arch=>I<arch> |
| |
| Specify architecture of Intel(R) Many Integrated Core Architecture card. Default is C<knf>. I<arch> can be C<knf>, C<knc>, C<knl>. |
| |
| =item B<--mic-comp=>I<compiler-type> |
| |
| Specify whether the Intel(R) Many Integrated Core Compiler is native or offload. Default is C<native>. |
| I<compiler-type> can be C<native> or C<offload>. |
| |
| =item B<-->[B<no->]B<test-deps> |
| |
| Enable or disable C<test-deps>. The test runs in any case, but result of disabled test is ignored. |
| By default, test is enabled. |
| |
| =item B<-->[B<no->]B<test-touch> |
| |
| Enable or disable C<test-touch>. The test runs in any case, but result of disabled test is ignored. |
| By default, test is enabled. |
| |
| =item Base Configuration Selection Options |
| |
| =over |
| |
| =item B<--target=>I<target> |
| |
| Build specified target, either C<rtl> (OMP Runtime Library; default), |
| or C<timelimit> (program used in testing), or C<all>. |
| |
| =item B<--lib-type=>I<lib> |
| |
| Build specified library, either C<normal> (default), or C<stubs>, or C<all>. |
| |
| =item B<--link-type=>I<type> |
| |
| Build specified link type, either C<dynamic> (default) or C<all>. |
| |
| =back |
| |
| =item Extra Configuration Selection Options |
| |
| =over |
| |
| =item B<--cover=>I<switch> |
| |
| Build for code coverage data collection. I<switch> can be C<off> (default), C<on> |
| or C<all>. |
| |
| =item B<--mode=>I<mode> |
| |
| Build library of specified I<mode>, either C<debug>, C<diag>, C<release> (default), or C<all>. |
| Mode controls 3 features: |
| |
| --------------------------------------------------- |
| feature/mode debug diag release |
| --------------------------------------------------- |
| debug info o o |
| diagnostics (asserts, traces) o o |
| code optimization o o |
| --------------------------------------------------- |
| |
| =item B<--target-compiler=>I<version> |
| |
| Build files for specified target compiler, C<11> or C<12>. |
| |
| =back |
| |
| =item Shortcuts |
| |
| If option with C<no> prefix is used, corresponding configuration will B<not> be built. |
| Useful for excluding some configurations if one or more other options specified with C<all> |
| value (see Examples). |
| |
| =over |
| |
| =item B<-->[B<no>]B<11> |
| |
| Build files for compiler C<11>. |
| |
| =item B<-->[B<no>]B<12> |
| |
| Build files for compiler C<12>. |
| |
| =item B<-->[B<no>]B<debug> |
| |
| =item B<-->[B<no>]B<debg> |
| |
| =item B<-->[B<no>]B<dbg> |
| |
| Build debuggable library. |
| |
| =item B<-->[B<no>]B<diag> |
| |
| Build library with diagnostics enabled. |
| |
| =item B<-->[B<no>]B<dynamic> |
| |
| Build dynamic library (default). |
| |
| =item B<-->[B<no>]B<normal> |
| |
| Build normal library (default). |
| |
| =item B<-->[B<no>]B<release> |
| |
| Build release library (default). |
| |
| =item B<-->[B<no>]B<rtl> |
| |
| Build OMP RTL (default). |
| |
| =item B<-->[B<no>]B<stubs> |
| |
| Build stubs library. |
| |
| =item B<-->[B<no>]B<timelimit> |
| |
| Build timelimit utility program. |
| |
| =back |
| |
| =item Standard Options |
| |
| =over |
| |
| =item B<--doc> |
| |
| =item B<--manual> |
| |
| Print full help message and exit. |
| |
| =item B<--help> |
| |
| Print short help message and exit. |
| |
| =item B<--usage> |
| |
| Print very short usage message and exit. |
| |
| =item B<--verbose> |
| |
| Do print informational messages. |
| |
| =item B<--version> |
| |
| Print program version and exit. |
| |
| =item B<--quiet> |
| |
| Work quiet, do not print informational messages. |
| |
| =back |
| |
| =back |
| |
| =head1 ARGUMENTS |
| |
| =over |
| |
| =item I<make-option> |
| |
| Any option for makefile, for example C<-k> or C<-n>. If you pass some options to makefile, C<--> |
| delimiter is mandatory, otherwise C<build.pl> processes all the options internally. |
| |
| =item I<variable> |
| |
| Define makefile variable in form I<name>B<=>I<value>. Most makefile capabilities are |
| accessible through C<build.pl> options, so there is no need in defining make variables in command |
| line. |
| |
| =item I<goal> |
| |
| Makefile goal to build (or clean). |
| |
| =over |
| |
| =item B<all> |
| |
| Build C<lib>, C<tests>, C<inc>. |
| |
| =item B<common> |
| |
| Build common (architecture-independent) files. Common files are not configuration-dependent, so |
| there is no point in building it for more than one configuration (thought it is harmless). |
| However, do not build common files on many machines simultaneously. |
| |
| =item B<clean> |
| |
| Delete the export files and clean build directory of configuration(s) specified by options. Note |
| that C<clean> goal cannot be mixed with other goals (except for C<clean-common>). |
| |
| =item B<clean-common> |
| |
| Delete the common files in F<exports/> directory. |
| |
| =item B<clobber> |
| |
| Clean F<export/> and F<tmp/> directories. If C<clobber> is specified, other goals and/or options |
| do not matter. |
| |
| Note: Clobbering is potentialy dangerous operation, because it deletes content of directory |
| pointed by If C<LIBOMP_TMP> environment variable, so C<build.pl> asks a confirmation before |
| clobbering. To suppress the question, use option C<--answer=yes>. |
| |
| =item B<fat> |
| |
| C<mac_32e> only: Build fat libraries for both mac_32 and mac_32e. Should be run when C<lib> |
| goal is built on both C<mac_32> and C<mac_32e>. |
| |
| =item I<file.o> |
| |
| (Windows* OS: I<file.obj>) Build specified object file only. |
| |
| =item I<file.i> |
| |
| Create preprocessed source file. |
| |
| =item B<force-tests> |
| |
| Force performing tests. |
| |
| =item B<force-test-deps> |
| |
| Force performing test-deps. |
| |
| =item B<force-test-instr> |
| |
| Force performing test-instr. |
| |
| =item B<force-test-relo> |
| |
| Force performing test-relo. |
| |
| =item B<force-test-touch> |
| |
| Force performing test-touch. |
| |
| =item B<inc> |
| |
| Build Fortran include files, omp_lib.h, omp_lib.mod and omp_lib_kinds.mod. |
| |
| =item B<lib> |
| |
| Build library (on Windows* OS in case of dynamic linking, it also builds import library). |
| |
| =item B<tests> |
| |
| Perform tests: C<test-deps>, C<test-instr>, C<test-relo>, and C<test-touch>. |
| |
| =item B<test-deps> |
| |
| Check the library dependencies. |
| |
| =item B<test-instr> |
| |
| Intel(R) Many Integrated Core Architecture only: check the library does not contain undesired instructions. |
| |
| =item B<test-relo> |
| |
| Linux* OS with dynamic linking only: check the library does not contain position-dependent |
| code. |
| |
| =item B<test-touch> |
| |
| Build a very simple application with native compiler (GNU on Linux* OS and OS X*, MS |
| on Windows* OS), check it does not depend on C<libirc> library, and run it. |
| |
| =back |
| |
| =back |
| |
| =head1 DESCRIPTION |
| |
| C<build.pl> constructs the name of a build directory, creates the directory if it |
| does not exist, changes to it, and runs make to build the goals in specified configuration. |
| If more than one configuration are specified in command line C<build.pl> builds them all. |
| |
| Being run with C<clean> goal, C<build.pl> does not build but deletes export files and |
| cleans build directories of configuration specified by other options. For example, |
| C<build.pl --all clean> means "clean build directories for all configurations", |
| it does B<not> mean "clean then build all". |
| |
| C<clear-common> goal deletes common files in F<exports/> directory. |
| Since common files are really common and not architecture and/or configuration dependent, |
| there are no much meaning in combining C<clear-common> with configuration selection options. |
| For example, C<build.pl --all clean-common> deletes the same files 13 times. |
| However, it does not hurt and can be used in conjunction with C<clear> goal. |
| |
| C<clobber> goal instructs C<build.pl> to clean exports and all build |
| directories, e. g. clean everything under F<exports/> and F<tmp/> directories. |
| |
| Logs are saved automatically, there is no need in explicit output redirection. |
| Log file for each particular configuration is named F<build.log> and located in build directory. |
| Summary log file (just result of each configuration) is saved in F<tmp/> directory. |
| |
| Log files are never overwritten. C<build.pl> always appends output to log files. |
| However (obviously), C<clear> deletes log file for cleared configurations, |
| and C<clobber> deletes all summary log files. |
| |
| =head2 Environment Variables |
| |
| =over |
| |
| =item B<LIBOMP_ARCH> |
| |
| Specifies target architecture. If not present, host architecture is used. Environment variable may |
| be overriden by C<--architecture> command line option. |
| |
| =item B<LIBOMP_EXPORTS> |
| |
| Specifies directory for output files. If not set, C<$LIBOMP_WORK/exports/> used by default. |
| |
| =item B<LIBOMP_OS> |
| |
| Specifies target OS. If not present, host OS is used. Environment variable may |
| be overriden by C<--os> command line option. |
| |
| =item B<LIBOMP_TMP> |
| |
| Directory for temporary files. C<build.pl> creates build directories there. If not set, |
| C<$LIBOMP_WORK/tmp/> used by default. |
| |
| On Windows* OS F<tmp/> directory on local drive speeds up the build process. |
| |
| =item B<LIBOMP_WORK> |
| |
| Root of libomp directory tree, contains F<src/>, F<tools/>, and F<exports/> subdirs. |
| If not set, C<build.pl> guesses the root dir (it is a parent of dir containing C<build.pl>). |
| |
| Note: Guessing it not reliable. Please set C<LIBOMP_WORK> environment variable appropriately. |
| |
| =back |
| |
| =head1 EXAMPLES |
| |
| =head2 Development |
| |
| Build normal (performance) dynamic library for debugging: |
| |
| $ build.pl --debug |
| |
| Build all libraries (normal, stub; dynamic RTL) for debugging: |
| |
| $ build.pl --all --debug |
| |
| Do a clean build for all: |
| |
| $ build.pl --all --debug clean && build.pl --all --debug |
| |
| Debugging libraries are saved in F<exports/I<platform>.deb/>. |
| |
| =head2 Promotion |
| |
| =over |
| |
| =item 1 |
| |
| Clobber everything; on one machine: |
| |
| $ build.pl clobber |
| |
| =item 2 |
| |
| Build common headers, on one machine: |
| |
| $ build.pl common |
| |
| =item 3 |
| |
| Build all platform-dependent files, on all machines: |
| |
| $ build.pl --all |
| |
| =item 4 |
| |
| Build OS X* universal (fat) libraries, on C<mac_32e>: |
| |
| $ build.pl fat |
| |
| =back |
| |
| =cut |
| |
| # end of file # |
