PERLCC(1)

NAME
perlcc - generate executables from Perl programs

SYNOPSIS
    perlcc hello.pl            # Compiles into executable 'a.out'
    perlcc -o hello hello.pl   # Compiles into executable 'hello'

    perlcc -O file.pl          # Compiles using the optimised CC backend
    perlcc -O3 file.pl         # Compiles with C, using -O3 optimizations
    perlcc -B file.pl          # Compiles using the bytecode backend
    perlcc -B -m file.pm       # Compiles a module to file.pmc

    perlcc -c file.pl          # Creates a C file, 'file.c'
    perlcc -S -o hello file.pl # Keep C file
    perlcc -c out.c file.pl    # Creates a C file, 'out.c' from 'file'
    perlcc --staticxs -r -o hello hello.pl # Compiles,links and runs with
                               # XS modules static/dynaloaded

    perlcc -e 'print q//'      # Compiles a one-liner into 'a.out'
    perlcc -c -e 'print q//'   # Creates a C file 'a.out.c'

    perlcc -I /foo hello       # extra headers for C
    perlcc -L /foo hello       # extra libraries for C
    perlcc --Wb=-Dsp           # extra perl compiler options
    perlcc -fno-delete-pkg     # extra perl compiler options
    perlcc --Wc=-fno-openmp    # extra C compiler options
    perlcc --Wl=-s             # extra C linker options

    perlcc -uIO::Socket        # force saving IO::Socket
    perlcc -UB                 # "unuse" B, compile without any B symbols

    perlcc -r hello            # compiles 'hello' into 'a.out', runs 'a.out'
    perlcc -r hello a b c      # compiles 'hello' into 'a.out', runs 'a.out'
                               # with arguments 'a b c'

    perlcc hello -log c.log    # compiles 'hello' into 'a.out', log into 'c.log'

    perlcc -h                  # help, only SYNOPSIS
    perlcc -v2 -h              # verbose help, also DESCRIPTION and OPTIONS
    perlcc --version           # prints internal perlcc and the B-C release version

DESCRIPTION
perlcc creates standalone executables from Perl programs, using the code generators provided by the B module. At present, you may either create executable Perl bytecode, using the "-B" option, or generate and compile C files using the standard and 'optimised' C backends.

The code generated in this way is not guaranteed to work. The whole codegen suite ("perlcc" included) should be considered very experimental. Use for production purposes is strongly discouraged.

OPTIONS

-LC library directories
    Adds the given directories to the library search path when C code is passed to your C compiler. For multiple paths use multiple -L options.

-IC include directories
    Adds the given directories to the include file search path when C code is passed to your C compiler; when using the Perl bytecode option, adds the given directories to Perl's include path. For multiple paths use multiple -I options.

-o output file name
    Specifies the file name for the final compiled executable.

    Without given output file name we use the base of the input file, or with "-e" a.out resp. a.exe and a randomized intermediate C filename. If the input file is an absolute path on a non-windows system use the basename.

-c C file name
    Create C file only; do not compile and link to a standalone binary.

-e perl code
    Compile a one-liner, much the same as "perl -e '...'"

--check
    Pass -c flag to the backend, prints all backend warnings to STDOUT and exits before generating and compiling code. Similar to perl -c.

--cross pathto/config.sh
    Use a different %B::C::Config from another config.sh for cross-compilation. Passes -cross=path to the backend.

-S  "Keep source". Do not delete generated C code after compilation.

-B  Use the Perl bytecode code generator.

--debug or -D
    Shortcut for --Wb=-Dfull -S to enable all debug levels and also preserve source code, also view --Wb to enable some specific debugging options.

-O  Use the 'optimised' C code generator B::CC. This is more experimental than everything else put together, and the code created is not guaranteed to compile in finite time and memory, or indeed, at all.

-O1-4
    Pass the numeric optimisation option to the compiler backend. Shortcut for "-Wb=-On".

    This does not enforce B::CC.

-v 0-6
    Set verbosity of output from 0 to max. 6.

-r  Run the resulting compiled script after compiling it.

--log logfile
    Log the output of compiling to a file rather than to stdout.

-f<option> or --f=<option>
    Pass the options to the compiler backend, such as "-fstash" or "-fno-delete-pkg".

--Wb=options
    Pass the options to the compiler backend, such as "--Wb=-O2,-v"

--Wc=options
    Pass comma-seperated options to cc.

--Wl=options
    Pass comma-seperated options to ld.

-T or -t
    run the backend using perl -T or -t

-A  Allow perl options to be passed to the executable first, like -D...

    Adds "-DALLOW_PERL_OPTIONS" which omits "--" from being added to the options handler.

-u package
    Add package(s) to compiler and force linking to it.

-U package
    Skip package(s). Do not compile and link the package and its sole dependencies.

--stash
    Detect external packages automatically via B::Stash

--static
    Link to static libperl.a

--staticxs
    Link to static XS if available. If the XS libs are only available as shared libs link to those ("prelink").

    Systems without rpath (windows, cygwin) must be extend LD_LIBRARY_PATH/PATH at run-time. Together with -static, purely static modules and no run-time eval or require this will gain no external dependencies.

--shared
    Link to shared libperl

--sharedxs
    Link shared XSUBs if the linker supports it. No DynaLoader needed. This will still require the shared XSUB libraries to be installed at the client, modification of @INC in the source is probably required. (Not yet implemented)

-m|--sharedlib [Modulename]
    Create a module, resp. a shared library. Currently only enabled for Bytecode and CC. (not yet tested)

--testsuite
    Tries be nice to Test:: modules, like preallocating the file handles 4 and 5, and munge the output of BEGIN.

      perlcc -r --testsuite t/harness

--time
    Benchmark the different phases c (B::* compilation), cc (cc compile + link), and r (runtime).

--no-spawn
    Do not spawn subprocesses for compilation, because broken shells might not be able to kill its children.