ghc.lprl

% (c) The GRASP/AQUA Project, Glasgow University, 1992-1997
%

This is the driver script for the Glasgow Haskell compilation system.
It is written in \tr{perl}.  The first section includes a long
``usage'' message that describes how the driver is supposed to work.

%************************************************************************
%*									*
\section[Driver-usage]{Usage message}
%*									*
%************************************************************************

\begin{code}
($Pgm = $0) =~ s|.*/||;
$ShortUsage  =  "\nUsage: For basic information, try the `-help' option.\n";
$LongUsage = "\n" . <<EOUSAGE;
Use of the Glorious Haskell Compilation System driver:

    $Pgm [command-line-options-and-input-files]

------------------------------------------------------------------------
This driver ($Pgm) guides each input file through (some of the)
possible phases of a compilation:

    - unlit:	extract code from a "literate program"
    - hscpp:	run code through the C pre-processor (if -cpp flag given)
    - hsc:	run the Haskell compiler proper
    - gcc:	run the C compiler (if compiling via C)
    - as:	run the assembler
    - ld:	run the linker

For each input file, the phase to START with is determined by the
file's suffix:
    - .lhs	literate Haskell: unlit
    - .hs	illiterate Haskell: hsc
    - .hc	C from the Haskell compiler: gcc
    - .c	C not from the Haskell compiler: gcc
    - .s	assembly language: as
    - other	passed directly to the linker: ld

If no files are given on the command line, input is taken from
standard input, and processing is as for an .hs file.  (All output is
to stdout or stderr, however).

The phase at which to STOP processing is determined by a command-line
option:
    -E		stop after generating preprocessed, de-litted Haskell (used in conjunction with -cpp)
    -C		stop after generating C (.hc output)
    -S		stop after generating assembler (.s output)
    -c		stop after generating object files (.o output)

Other commonly-used options are:

    -O		An `optimising' package of compiler flags, for faster code

    -prof	Compile for cost-centre profiling
		(add -auto for automagic cost-centres on top-level functions)

    -fglasgow-exts  Allow Glasgow extensions (unboxed types, etc.)

    -H14m	Increase compiler's heap size

    -M          Output the Makefile rules recording the
                dependencies of a list of Haskell files.
	        (ghc driver script calls upon the help of a
                 compatible mkdependHS script to do the actual
		 processing)

The User's Guide has more information about GHC's *many* options.

Given the above, here are some TYPICAL invocations of $Pgm:

    # compile a Haskell module to a .o file, optimising:
    % $Pgm -c -O Foo.hs
    # link three .o files into an executable called "test":
    % $Pgm -o test Foo.o Bar.o Baz.o
    # compile a Haskell module to C (a .hc file), using a bigger heap:
    % $Pgm -C -H16m Foo.hs
    # compile Haskell-produced C (.hc) to assembly language:
    % $Pgm -S Foo.hc
------------------------------------------------------------------------
EOUSAGE
\end{code}

%************************************************************************
%*									*
\section[Driver-init]{Initialisation}
%*									*
%************************************************************************

The driver script need to be told where to find these executables, so
in the course of building the driver `executable', make-variables holding
these are prepended to the de-litted version of this file. The variables are:

\begin{verbatim}
INSTALLING

HOSTPLATFORM TARGETPLATFORM

ProjectName ProjectVersion ProjectVersionInt ProjectPatchLevel 

HscMajorVersion HscMinorVersion CcMajorVersion CcMinorVersion

TOP_PWD

bindir libdir libexecdir datadir

CURRENT_DIR TMPDIR

GHC_LIB_DIR GHC_RUNTIME_DIR GHC_UTILS_DIR GHC_INCLUDE_DIR

GHC_OPT_HILEV_ASM GhcWithNativeCodeGen

GHC_UNLIT GHC_HSCPP GHC_HSC GHC_SYSMAN

CP RM CONTEXT_DIFF

WAY_*_NAME WAY_*_HC_OPTS

LeadingUnderscore

\end{verbatim}

Establish what executables to run for the various phases, what the
default options are for those phases, and other similar boring stuff.

\begin{code}
select(STDERR); $| = 1; select(STDOUT); # no STDERR buffering, please.

$TargetPlatform = $TARGETPLATFORM;

$TopPwd	           = "${TOP_PWD}";
$InstBinDirGhc     = "${bindir}";
$InstLibDirGhc     = "${libdir}";
#
# Normally the same as InstLibDirGhc, but we accommodate
# for it being separate.
#
$InstLibExecDirGhc = "${libexecdir}";
$InstDataDirGhc    = "${datadir}";

$Status  = 0; # just used for exit() status
$Verbose = '';

# set up signal handler
sub quit_upon_signal { &tidy_up_and_die(1, ''); }
$SIG{'INT'}  = 'quit_upon_signal';
$SIG{'QUIT'} = 'quit_upon_signal';

# where to get "require"d .prl files at runtime (poor man's dynamic loading)
#   (use LIB, not DATA, because we can't be sure of arch-independence)
@INC = ( ( $INSTALLING ) ? $InstLibDirGhc
			   : "$TopPwd/${CURRENT_DIR}" );

if ( $ENV{'TMPDIR'} ) { # where to make tmp file names
    $Tmp_prefix = ($ENV{'TMPDIR'} . "/ghc$$");
} else {
    print STDERR "TMPDIR has not been set to anything useful!\n" if (${TMPDIR} eq '');
    $Tmp_prefix ="${TMPDIR}/ghc$$"; # TMPDIR set via Makefile when booting..
    $ENV{'TMPDIR'} = ${TMPDIR}; # set the env var as well
}

# Some shells run into real trouble when command line and environment
# gets big (e.g., cmd lines of >4K to /bin/sh causes havoc on our 
# Solaris-2.5.1 boxes - even though sysconf(_SC_ARG_MAX) reports 1M ...).
# To work around any such */bin/sh* problems, we will scribble such
# awfully long command lines into a temp file and exec that temp file
# with $(REAL_SHELL) (don't use the SHELL variable directly as this
# will normally get you the wrong thing when the driver is invoked
# from within `make'). If the REAL_SHELL variable isn't set, you'll
# get SHELL. This is all a terrible hack. (in case you hadn't reached
# the same conclusion by now :-)
#
# TBC..
#
if ( ! $ENV{'REAL_SHELL'} ) {
    $ENV{'REAL_SHELL'} = $ENV{'SHELL'};
}

@Files_to_tidy = (); # files we nuke in the case of abnormal termination

$Unlit = ( $INSTALLING ) ? "$InstLibExecDirGhc/unlit"
			 : "$TopPwd/${CURRENT_DIR}/${GHC_UNLIT}";

$Cp   = $CP;
$Rm   = $RM;
$Diff = $CONTEXT_DIFF;
$Cat  = 'cat';
$Cmp  = 'cmp';
$Time = '';

$HsCpp	 = # but this is re-set to "cat" (after options) if -cpp not seen
	   ( $INSTALLING ) ? "$InstLibExecDirGhc/hscpp"
			   : "$TopPwd/${CURRENT_DIR}/${GHC_HSCPP}";

@HsCpp_flags	= ();
$HsC	 = ( $INSTALLING ) ? "$InstLibExecDirGhc/hsc"
			   : "$TopPwd/${CURRENT_DIR}/${GHC_HSC}";

# For PVM fiends only
$SysMan	 = ( $INSTALLING ) ? "$InstLibExecDirGhc/SysMan"
			   : "$TopPwd/${CURRENT_DIR}/${GHC_SYSMAN}";

@Unlit_flags	= ();

#
# HsC_rts_flags: if we want to talk to the LML runtime system
# NB: we don't use powers-of-2 sizes, because this may do
#   terrible things to cache behavior.
#
$Specific_heap_size = 6 * 1000 * 1000;
$Specific_stk_size  = 1000 * 1000;
$Scale_sizes_by     = 1.0;

\end{code}

The variables set by @setupOptFlags@ represent parts of the
-O/-O2/etc ``templates,'' which are filled in later, using these.
These are the default values, which may be changed by user flags.

\begin{code}
sub setupOptFlags {
   $Oopt_MaxSimplifierIterations  = '-fmax-simplifier-iterations4';
   $Oopt_PedanticBottoms	  = '-fpedantic-bottoms'; # ON by default
   $Oopt_MonadEtaExpansion	  = '';
   $Oopt_FinalStgProfilingMassage = '';
   $Oopt_StgStats		  = '';
   $Oopt_DoSpecialise		  = '-fspecialise';
   $Oopt_FoldrBuild		  = 0; # *Off* by default!
   $Oopt_FB_Support		  = ''; # was '-fdo-arity-expand';
#  $Oopt_FoldrBuildWW		  = 0; # Off by default
   $Oopt_FoldrBuildInline	  = ''; # was '-fdo-inline-foldr-build';
   $Oopt_ShowSimplifierProgress   = '';
} # end of setupOptFlags

# Assign defaults to these right away.
&setupOptFlags();
\end{code}

Things to do with C compilers/etc:

(added -Wimplicit: implicit prototypes cause very hard-to-find
problems, so I'm turing on the warnings -- SDM 4/5/98)

\begin{code}
$CcRegd	 	= $GHC_OPT_HILEV_ASM;
@CcBoth_flags	= ('-S','-Wimplicit');   # flags for *any* C compilation
@CcInjects	= ();

# GCC flags: 
#    those for all files, 
#    those only for .c files;
#    those only for .hc files

@CcRegd_flags    = ();
@CcRegd_flags_c	 = ();
@CcRegd_flags_hc = ();

$As	 	 = ''; # "assembler" is normally GCC
@As_flags	 = ();

$Lnkr	 	 = ''; # "linker" is normally GCC
@Ld_flags	 = ();

# 'nm' is used for consistency checking (ToDo: mk-world-ify)
# ToDo: check the OS or something ("alpha" is surely not the crucial question)
$Nm = ($TargetPlatform =~ /^alpha-/) ? 'nm -B' : 'nm';
\end{code}

Warning packages that are controlled by -W and -Wall.  The 'standard'
warnings that you get all the time are
	
	-fwarn-overlapping-patterns
	-fwarn-missing-methods
	-fwarn-duplicate-exports

these are turned off by -Wnot.

\begin{code}
@StandardWarnings = ('-fwarn-overlapping-patterns', 
		     '-fwarn-missing-methods',
		     '-fwarn-duplicate-exports');
@MinusWOpts    	  = (@StandardWarnings, 
		     '-fwarn-incomplete-patterns', 
		     '-fwarn-unused-binds',
		     '-fwarn-unused-imports');
@MinusWallOpts 	  = (@MinusWOpts, 
		     '-fwarn-unused-matches',
		     '-fwarn-name-shadowing',
		     '-fwarn-missing-signatures');
\end{code}

What options \tr{-user-setup-a} turn into (user-defined ``packages''

of options).  Note that a particular user-setup implies a particular
Prelude ({\em including} its interface file(s)).
\begin{code}
$BuildTag	= ''; # default is sequential build w/ Appel-style GC

%BuildDescr	= (# system ways begin
                   '',	    'normal sequential',
		   '_p',    "$WAY_p_NAME",
		   '_t',    "$WAY_t_NAME",
		   '_u',    "$WAY_u_NAME",
		   '_mp',   "$WAY_mp_NAME",
		   '_mg',   "$WAY_mg_NAME",
		   # system ways end
		   '_a',    "$WAY_a_NAME",
		   '_b',    "$WAY_b_NAME",
		   '_c',    "$WAY_c_NAME",
		   '_d',    "$WAY_d_NAME",
		   '_e',    "$WAY_e_NAME",
		   '_f',    "$WAY_f_NAME",
		   '_g',    "$WAY_g_NAME",
		   '_h',    "$WAY_h_NAME",
		   '_i',    "$WAY_i_NAME",
		   '_j',    "$WAY_j_NAME",
		   '_k',    "$WAY_k_NAME",
		   '_l',    "$WAY_l_NAME",
		   '_m',    "$WAY_m_NAME",
		   '_n',    "$WAY_n_NAME",
		   '_o',    "$WAY_o_NAME",
		   '_A',    "$WAY_A_NAME",
		   '_B',    "$WAY_B_NAME" );

# these are options that are "fed back" through the option processing loop
#
%SetupOpts = 
       (
	'_a', "$WAY_a_HC_OPTS",
	'_b', "$WAY_b_HC_OPTS",
	'_c', "$WAY_c_HC_OPTS",
	'_d', "$WAY_d_HC_OPTS",
	'_e', "$WAY_e_HC_OPTS",
	'_f', "$WAY_f_HC_OPTS",
	'_g', "$WAY_g_HC_OPTS",
	'_h', "$WAY_h_HC_OPTS",
	'_i', "$WAY_i_HC_OPTS",
	'_j', "$WAY_j_HC_OPTS",
	'_k', "$WAY_k_HC_OPTS",
	'_l', "$WAY_l_HC_OPTS",
	'_m', "$WAY_m_HC_OPTS",
	'_n', "$WAY_n_HC_OPTS",
	'_o', "$WAY_o_HC_OPTS",
	'_A', "$WAY_A_HC_OPTS",
	'_B', "$WAY_B_HC_OPTS",

	# system ways
	'_p',  "$WAY_p_HC_OPTS",
	'_t',  "$WAY_t_HC_OPTS",
	'_u',  "$WAY_u_HC_OPTS",
	'_mp', "$WAY_mp_HC_OPTS",
	'_mg', "$WAY_mg_HC_OPTS");

\end{code}

Import/include directories (\tr{-I} options) are sufficiently weird to
require special handling.

\begin{code}
@Import_dir	= ('.'); #-i things
@Include_dir	= ('.'); #-I things; other default(s) stuck on AFTER option processing

# where to look for interface files (system hi's, i.e., prelude and syslibs)
@SysImport_dir	= ( $INSTALLING )
		    ? ( "$InstLibDirGhc/imports/std" )
		    : ( "$TopPwd/$CURRENT_DIR/$GHC_LIB_DIR/std" );

# We need to look in ghc/ and glaExts/ when searching for implicitly needed .hi files, but 
# we should really *not* look there for explicitly imported modules.

$Haskell1Version = 5; # i.e., Haskell 1.4
@Cpp_define	 = ();

# Cpp symbols defined when we're processing Haskell source.

@HsSourceCppOpts = 
	( "-D__HASKELL1__=$Haskell1Version"
	, "-D__GLASGOW_HASKELL__=$ProjectVersionInt"
	# not yet -- SDM
	# , "-D__CONCURRENT_HASKELL__"
	);

@UserLibrary_dir= ();	#-L things;...
@UserLibrary   	= ();	#-l things asked for by the user

@SysLibrary_dir = ( ( $INSTALLING )	#-syslib things supplied by the system
		    ? $InstLibDirGhc
		    : ( "$TopPwd/$CURRENT_DIR/$GHC_RUNTIME_DIR"
		      , "$TopPwd/$CURRENT_DIR/$GHC_RUNTIME_DIR/gmp"
		      , "$TopPwd/$CURRENT_DIR/$GHC_LIB_DIR/std"
		      , "$TopPwd/$CURRENT_DIR/$GHC_LIB_DIR/std/cbits"
		      )
		  );
@SysLibrary = (); # will be built up as we go along

$TopClosureFile # defaults to 1.2 one; will be mangled later
	= '';
#	( $INSTALLING)  ? "$InstLibDirGhc/TopClosureXXXX.o"
#			  : "$TopPwd/$CURRENT_DIR/$GHC_RUNTIME_DIR/main/TopClosureXXXX.o";

# make depend for Haskell
$MkDependHS
	= ( $INSTALLING ) ? "$InstBinDirGhc/mkdependHS"
			  : "$TopPwd/$CURRENT_DIR/$GHC_UTILS_DIR/mkdependHS/mkdependHS";
# Fill in later
@MkDependHS_flags = ();

# do_link flag should not be reset while rescanning the cmd-line.
$Do_lnkr    = 1;
$Specific_output_dir = '';  	# set by -odir <dir>
$Specific_output_file = '';	# set by -o <file>; "-" for stdout
\end{code}

Function to initialise the per-compilation-unit globals that
are used to guide and control the invocation of the different phases.

\begin{code} 
sub initDriverGlobals {

# reset the following options:
# RTS flags to use while compiling
@HsC_rts_flags      = ();
@HsP_flags	= (); # these are the flags destined solely for
		      # the flex/yacc parser
@HsC_flags	= ();
@HsC_antiflags  = ();
\end{code}

The optimisations/etc to be done by the compiler are {\em normally}
expressed with a \tr{-O} (or \tr{-O2}) flag, or by its absence.

\begin{code}
$OptLevel      = 0; # no -O == 0; -O == 1; -O2 == 2; -Ofile == 3
$MinusO2ForC   = 0; # set to 1 if -O2 should be given to C compiler
$StolenX86Regs = 4; # **HACK*** of the very worst sort
$CoreLint      = '';
$StgLint       = '';

@Import_dir	= ('.'); #-i things
@Include_dir	= ('.'); #-I things; other default(s) stuck on AFTER option processing


\end{code}

We are given a list of files with various presumably-known suffixes
(unknown-suffix files go straight to the linker).  For each file, we
begin by assuming that we'll run every phase over it.  However: (1)
global flags (\tr{-c}, \tr{-S}, etc.) tell us not to run any phase
past a certain point; and (2) the file's suffix tells us what phase to
start with.  Linking is weird and kept track of separately.

Here are the initial defaults applied to all files:
\begin{code}
$Cpp_flag_set = 0;	  # (hack)
$Only_preprocess_C = 0;	  # pretty hackish
$Only_preprocess_hc = 0;  # ditto
$Only_generate_deps = 0;  # "
$PostprocessCcOutput = 0;

# native code-gen or via C?
$HaveNativeCodeGen = $GhcWithNativeCodeGen;
$HscOut = '-C='; # '-C=' ==> .hc output; '-S=' ==> .s output; '-N=' ==> neither
$HscOut = '-S='
    if $HaveNativeCodeGen && $TargetPlatform =~ /^(alpha)-/;
# TEMP: disable x86 & Sparc if $HaveNativeCodeGen && $TargetPlatform =~ /^(i386|alpha|sparc)-/;
$ProduceHi    = '-hifile=';
$HiOnStdout   = 0;
$HiWith       = '';
$HiDiff_flag  = '';
$Keep_HiDiffs = 0;

$CollectingGCstats = 0;
$CollectGhcTimings = 0;
$DEBUGging = '';	# -DDEBUG and all that it entails (um... not really)
$PROFing = '';		# set to p or e if profiling
$PROFgroup = '';	# set to group if an explicit -Ggroup specified
$PROFauto = '';	        # set to relevant hsc flag if -auto or -auto-all
$PROFcaf  = '';	        # set to relevant hsc flag if -caf-all
$PROFignore_scc = '';	# set to relevant parser flag if explicit sccs ignored
$UNPROFscc_auto = '';	# set to relevant hsc flag if forcing auto sccs without profiling
$TICKYing = '';    	# set to t if compiling for ticky-ticky profiling
$PARing = '';		# set to p if compiling for PAR
$GRANing = '';		# set to g if compiling for GRAN
$Specific_hi_file = '';		# set by -ohi <file>; "-" for stdout
$Specific_dump_file = '';	# set by -odump <file>; "-" for stdout
$Using_dump_file = 0;
$Isuffix    = '';
$Osuffix    = '';	# default: use the normal suffix for that kind of output
$HiSuffix   = 'hi';
$HiSuffix_prelude = '';
$Do_recomp_chkr = 0;	# don't use the recompilatio checker unless asked
$Do_cc	    = -1;   # a MAGIC indeterminate value; will be set to 1 or 0.
$Do_as	    = 1;

$Keep_hc_file_too = 0;
$Keep_s_file_too = 0;
$UseGhcInternals = 0; # if 1, may use GHC* modules
$SplitObjFiles = 0;
$DoAsmMangling = 1; # on by default, off by -fno-asm-mangling
$NoOfSplitFiles = 0;
$Dump_parser_output = 0;
$Dump_raw_asm = 0;
$Dump_asm_splitting_info = 0;
$NoImplicitPrelude = 0;
# 1 => don't tell the linker to hoist in PrelMain.Main, as an 
# external main is provided instead.
$NoHaskellMain=0;

} # end of initDriverGlobals (Sigh)

# we split the argv passed to the driver into three:

# the list of files
@Input_file = ();

# and files to be linked...
@Link_file  = ();

# and whatever else
@Cmd_opts  = ();

# cmd line options prefixing the unit we're compiling
@File_options = ();

\end{code}

We inject consistency-checking information into \tr{.hc} files (both
when created by the Haskell compiler and when compiled by the C
compiler), so that we can check that an executable is made from
consistently-built pieces.  (The check is normally done just after
linking.)  The checking is done by introducing/munging
\tr{what(1)}-style strings.  Anyway, here are the relevant global
variables and their defaults:
\begin{code}
$LinkChk = 0;	# set to 0 if the link check should *not* be done

# major & minor version numbers; major numbers must always agree;
# minor disagreements yield a warning.
$HsC_major_version = $HscMajorVersion;
$HsC_minor_version = $HscMinorVersion;
$Cc_major_version  = $CcMajorVersion;
$Cc_minor_version  = $CcMinorVersion;

# options: these must always agree
$HsC_consist_options = '';    # we record, in this order:
			      #	    Build tag; debugging?
$Cc_consist_options  = '';    # we record, in this order:
			      #	    Build tag; debugging?
\end{code}

%************************************************************************
%*									*
\section[Driver-parse-argv]{Munge the command-line options}
%*									*
%************************************************************************

Now slurp through the arguments.
\begin{code}

&initDriverGlobals();
&splitCmdLine(@ARGV);
# Run through the cmd-line first time.
&processArgs(@Cmd_opts);

# Check to see if driver is only in the business
# to generate dependencies
if (  $Status == 0 && $Only_generate_deps ) {

    push (@MkDependHS_flags, "-o$Osuffix") if $Osuffix;
    push (@MkDependHS_flags, "-s$BuildTag") if $BuildTag;
    # They're not (currently) needed, but we need to quote any -#include options
    foreach (@Cmd_opts) {
    	s/-#include.*$/'$&'/g;
    };
    local($to_do) = "$MkDependHS @MkDependHS_flags @HsSourceCppOpts -- @Cmd_opts -- @Input_file" ;
    &run_something($to_do, 'Haskell dependencies');
    exit $Status;
}

# if there are several input files,
# we don't allow \tr{-o <file>} or \tr{-ohi <file>} options...
# (except if linking, of course)

if ($#Input_file > 0 && ( ! $Do_lnkr )) {
    if ( ($Specific_output_file ne '' && $Specific_output_file ne '-')
      || ($Specific_hi_file ne ''     && $Specific_hi_file ne '-') ) {
	print STDERR "$Pgm: You can't use -o or -ohi options if you have multiple input files.\n";
	print STDERR "\tPerhaps the -odir option will do what you want.\n";
	$Status++;
    }
}

# check for various pathological -o and -odir combinations...
if ($Specific_output_dir ne '' && $Specific_output_file ne '') {
    if ($Specific_output_file eq '-') {
	print STDERR "$Pgm: can't set output directory with -ohi AND have output to stdout\n";
	$Status++;
    } else { # amalgamate...
    	$Specific_output_file = "$Specific_output_dir/$Specific_output_file";
	# ToDo: check we haven't got a junk name now...
	$Specific_output_dir  = ''; # reset
    }
}

# crash and burn if there were errors
if ( $Status > 0 ) {
    print STDERR $ShortUsage;
    exit $Status;
}
\end{code}

%************************************************************************
%*									*
\section[Driver-post-argv-mangling]{Setup after reading options}
%*									*
%************************************************************************

%************************************************************************
%*									*
\subsection{Set up for optimisation level (\tr{-O} or whatever)}
%*									*
%************************************************************************

We come now to the default ``wads of options'' that are turned on by
\tr{-O0} (do min optimisation), \tr{-O} (ordinary optimisation),
\tr{-O2} (aggressive optimisation), or no O-ish flag (compile speed is
more important).

The user can also specify his/her own list of options in a file; in
that case, the work is already done (see stuff about @minusO3@,
earlier...).

GHC allows very precise control of what happens during a compilation.
Core-to-Core and STG-to-STG passes can be run in any order, as many
times as you like.  Individual transformations can be turned on or
disabled.

Sadly, however, there are some interdependencies \& Things You Must
Not Do.  Here is the list.

CORE-TO-CORE PASSES:
\begin{description}
\item[\tr{-fspecialise}:]
The specialiser must have dependency-analysed input; but if you run
the simplifier to do this, you must not let it toss away unused
bindings!  (The typechecker conveys some specialisation info via
``unused'' bindings...)

\item[\tr{-ffloat-inwards}:]
Floating inwards should be done before strictness analysis, because
the latter will give better results.

\item[\tr{-fstatic-args}:]
The static-arguments-transformation pass {\em must} have the
simplifier run right after it.

\item[\tr{-fcalc-inlinings[12]}:]
Not required, but there may be slight gains by re-simplifying after
this is done.  (You could then \tr{-fcalc-inlinings} again, just for
fun.)

\item[\tr{-ffull-laziness}:]
The (outwards-)let-floater should be the {\em last} Core-to-Core pass
that's run.  (Um, well, howzabout the simplifier just once more...)
\end{description}

STG-TO-STG PASSES:
\begin{description}
\item[\tr{-fupdate-analysis}:]
It really really wants to be the last STG-to-STG pass that is run.
\end{description}

\begin{code}

sub setupOptimiseFlags {

   @HsC_minusNoO_flags 
    = (	'-fsimplify',
	  '[',
	  $Oopt_FB_Support,
	  '-ffloat-lets-exposing-whnf',
	  '-ffloat-primops-ok',
	  '-fcase-of-case',
	  '-fdo-case-elim',
#	  '-fdo-lambda-eta-expansion',	# too complicated
	  '-freuse-con',
#	  '-flet-to-case',		# no strictness analysis, so...
	  $Oopt_PedanticBottoms,
#	  $Oopt_MonadEtaExpansion,	# no thanks

# These two work fine, if you really want no simplification at all,
# for bizarre test reasons.  But you get really terrible code if you use them,
#	for example: let x = e in x
# with dozens of redundant thunks etc.  So I'm leaving them out.
#
#	  '-fsimpl-uf-use-threshold0',
#	  '-fessential-unfoldings-only',

	  #
	  # The presence of -fclone-binds is *temporary* to work around
          # the fact that the desugarer in 3.0{2.3} does generate
	  # bindings with identical ids, and the type checker doesn't perform
	  # properly cloned type substitutions. Instead, we make sure that all 
	  # binders are cloned first time through the simplifier.
          #
	  # Will be properly fixed in the `new compiler` I hear, at which point
	  # the cloning can be turned off here.
	  #
          # Let's find out..
          #'-fclone-binds',

	  $Oopt_MaxSimplifierIterations,
	  $Oopt_ShowSimplifierProgress,
	  ']',
	$Oopt_AddAutoSccs,
#	'-ffull-laziness',	# removed 95/04 WDP following Andr\'e's lead
	
	$Oopt_FinalStgProfilingMassage
      );

   @HsC_minusO_flags # NOTE: used for *both* -O and -O2 (some conditional bits)
    = (
        '-fdo-eta-reduction',

	# initial simplify: mk specialiser happy: minimum effort please
	'-fsimplify',
	  '[', 
	  $Oopt_FB_Support,
	  '-fkeep-spec-pragma-ids',	# required before specialisation

# I don't understand why we want -fessential-unfoldings-only here
# If we have it, the following nasty thing happens:
#	f  = E
#	g* = f
#	...g...
# where "*" means exported.
# In the essential-unfoldings pass we still substitute f for g
# but we don't substitute E for f first.  So we get
#	f  = E
#	g* = f
#	...f...
# The g=f will get reverse-substituted later, but it's untidy. --SLPJ
#
# SDM: Here's why it's necessary.
#
#   If we unfold in the first pass before the specialiser is run
#   we miss opportunities for specialisation because eg. wrappers
#   have been inlined for specialisable functions.  
#
#   This shows up in PrelArr.lhs - the specialised instance for newArray 
#   calls the generic rangeSize, because rangeSize is strict and is
#   replaced by its wrapper by the simplifier.

	  '-fessential-unfoldings-only',
	  '-fsimpl-uf-use-threshold0',

	  # See remark re: cloning in defn of minusnotO
	  '-fclone-binds',

	  '-fmax-simplifier-iterations1',
	  $Oopt_PedanticBottoms,
	  ']',

	($Oopt_DoSpecialise) ? (
	  $Oopt_DoSpecialise,
	) : (),

	'-fsimplify', 		# need dependency anal after specialiser ...
	  '[', 			# need tossing before calc-inlinings ...
	  $Oopt_FB_Support,
	  '-ffloat-lets-exposing-whnf',
	  '-ffloat-primops-ok',
	  '-fcase-of-case',
	  '-fdo-case-elim',
	  '-fcase-merge',
#	  '-fdo-eta-reduction',
	  '-fdo-lambda-eta-expansion',
	  '-freuse-con',
	  $Oopt_PedanticBottoms,
	  $Oopt_MonadEtaExpansion,
	  $Oopt_MaxSimplifierIterations,
	  $Oopt_ShowSimplifierProgress,
	  #
	  # The presence of -fclone-binds is *crucial* here as
	  # -ffull-laziness (which we're about to do next) floats
	  # bindings outwards, so we better make sure that this
	  # doesn't result in the floating out of bindings
	  # with identical uniques, i.e., -ffull-laziness needs
	  # to be preceeded by a simplifier pass with -fclone-binds
	  # set.
          '-fclone-binds',
	  ']',

#	($Oopt_FoldrBuildWW) ? (
#		'-ffoldr-build-ww-anal',
#		'-ffoldr-build-worker-wrapper',
#		'-fsimplify', 
#		  '[', 
#		  $Oopt_FB_Support,
#		  '-ffloat-lets-exposing-whnf',
#		  '-ffloat-primops-ok',
#		  '-fcase-of-case',
#		  '-fdo-case-elim',
#		  '-fcase-merge',
#		  '-fdo-eta-reduction',
#		  '-fdo-lambda-eta-expansion',
#		  '-freuse-con',
#		  $Oopt_PedanticBottoms,
#		  $Oopt_MonadEtaExpansion,
#		  $Oopt_MaxSimplifierIterations,
#		  $Oopt_ShowSimplifierProgress,
#		  ']',
#	 ) : (),

	# this pass-ordering sequence was agreed by Simon and Andr\'e
	# (WDP 94/07, 94/11).
	'-ffull-laziness',

	($Oopt_FoldrBuild) ? (
	  '-ffoldr-build-on',		# desugar list comprehensions for foldr/build

	  '-fsimplify', 
	    '[', 
	    '-fignore-inline-pragma',	# **** NB!
	    '-fdo-foldr-build',		# NB
	    $Oopt_FB_Support,
	    '-ffloat-lets-exposing-whnf',
	    '-ffloat-primops-ok',
	    '-fcase-of-case',
	    '-fdo-case-elim',
	    '-fcase-merge',
#	    '-fdo-eta-reduction',
	    '-fdo-lambda-eta-expansion',	# After full laziness
	    '-freuse-con',
	    $Oopt_PedanticBottoms,
	    $Oopt_MonadEtaExpansion,
	    $Oopt_MaxSimplifierIterations,
	    $Oopt_ShowSimplifierProgress,
	    ']',
	) : (),

	'-ffloat-inwards',

	'-fsimplify',
	  '[', 
	  $Oopt_FB_Support,
	  '-ffloat-lets-exposing-whnf',
	  '-ffloat-primops-ok',
	  '-fcase-of-case',
	  '-fdo-case-elim',
	  '-fcase-merge',
	  '-fdo-eta-reduction',
	  '-fdo-lambda-eta-expansion',
	  '-freuse-con',
  	  ($Oopt_FoldrBuildInline),
			# you need to inline foldr and build
	  ($Oopt_FoldrBuild) ? ('-fdo-foldr-build') : (), 
			# but do reductions if you see them!
	  $Oopt_PedanticBottoms,
	  $Oopt_MonadEtaExpansion,
	  $Oopt_MaxSimplifierIterations,
	  $Oopt_ShowSimplifierProgress,
	  ']',

	'-fstrictness',

	'-fsimplify',
	  '[', 
	  $Oopt_FB_Support,
	  '-ffloat-lets-exposing-whnf',
	  '-ffloat-primops-ok',
	  '-fcase-of-case',
	  '-fdo-case-elim',
	  '-fcase-merge',
#	  '-fdo-eta-reduction',
	  '-fdo-lambda-eta-expansion',
	  '-freuse-con',
	  '-flet-to-case',		# Aha! Only done after strictness analysis
	  $Oopt_PedanticBottoms,
	  $Oopt_MonadEtaExpansion,
	  $Oopt_MaxSimplifierIterations,
	  $Oopt_ShowSimplifierProgress,
	  ']',

	'-ffloat-inwards',

# Case-liberation for -O2.  This should be after
# strictness analysis and the simplification which follows it.

#	( ($OptLevel != 2)
#        ? ''
#	: "-fliberate-case -fsimplify [ $Oopt_FB_Support -ffloat-lets-exposing-whnf -ffloat-primops-ok -fcase-of-case -fdo-case-elim -fcase-merge -fdo-eta-reduction -fdo-lambda-eta-expansion -freuse-con -flet-to-case $Oopt_PedanticBottoms $Oopt_MonadEtaExpansion $Oopt_MaxSimplifierIterations $Oopt_ShowSimplifierProgress ]" ),

# Final clean-up simplification:

	'-fsimplify',
	  '[', 
	  $Oopt_FB_Support,
	  '-ffloat-lets-exposing-whnf',
	  '-ffloat-primops-ok',
	  '-fcase-of-case',
	  '-fdo-case-elim',
	  '-fcase-merge',
#	  '-fdo-eta-reduction',
	  '-fdo-lambda-eta-expansion',
	  '-freuse-con',
	  '-flet-to-case',
	  '-fignore-inline-pragma',	# **** NB!
	  $Oopt_FoldrBuildInline,	
	  ($Oopt_FoldrBuild) ? ('-fdo-foldr-build') : (), 
			# but still do reductions if you see them!
	  $Oopt_PedanticBottoms,
	  $Oopt_MonadEtaExpansion,
	  $Oopt_MaxSimplifierIterations,
	  $Oopt_ShowSimplifierProgress,
	  ']',

      #	'-fstatic-args',

#LATER:	'-fcalc-inlinings2', -- pointless for 2.01

      # stg2stg passes
	'-flambda-lift',
	$Oopt_FinalStgProfilingMassage,
	$Oopt_StgStats,

      # flags for stg2stg
	'-flet-no-escape',

      # SPECIAL FLAGS for -O2
	($OptLevel == 2) ? (
	  '-fupdate-analysis',	# virtually useless; relegated to -O2
	  '-fsemi-tagging',
	) : (),
      );

\end{code}

Sort out what we're going to do about optimising.  First, the @hsc@
flags and regular @cc@ flags to worry about:
\begin{code}
if ( $OptLevel <= 0 ) {

    # for this level, we tell the parser -fignore-interface-pragmas
    push(@HsC_flags, '-fignore-interface-pragmas');
    # and tell the compiler not to produce them
    push(@HsC_flags, '-fomit-interface-pragmas');

    &add_Hsc_flags( @HsC_minusNoO_flags );
    push(@CcBoth_flags, ($MinusO2ForC) ? '-O2' : '-O');	# not optional!

} elsif ( $OptLevel == 1 || $OptLevel == 2 ) {

    &add_Hsc_flags( @HsC_minusO_flags );
    push(@CcBoth_flags, ($MinusO2ForC || $OptLevel == 2) ? '-O2' : '-O'); # not optional!
    # -O? to GCC is not optional! -O2 probably isn't worth it generally,
    # but it *is* useful in compiling the garbage collector.

} else { # -Ofile, then...

    &add_Hsc_flags( @HsC_minusO3_flags );
    push(@HsC_flags, $Oopt_FinalStgProfilingMassage) if $Oopt_FinalStgProfilingMassage;

    push(@CcBoth_flags, ($MinusO2ForC) ? '-O2' : '-O');	# possibly to be elaborated...
}

} # setupOptimiseFlags

\end{code}

%************************************************************************
%*									*
\subsection{Check for consistency, etc.}
%*									*
%************************************************************************

Sort out @$BuildTag@, @$PROFing@, @$PARing@,
@$GRANing@, @$TICKYing@:
\begin{code}
sub setupBuildFlags {


   # PROFILING stuff after argv mangling:
   if ( ! $PROFing ) {
     # warn about any scc exprs found (in case scc used as identifier)
     push(@HsP_flags, '-W');

     # add -auto sccs even if not profiling !
     push(@HsC_flags, $UNPROFscc_auto) if $UNPROFscc_auto;

   } else {
      push(@HsC_flags, $PROFauto) if $PROFauto;
      push(@HsC_flags, $PROFcaf)  if $PROFcaf;
      #push(@HsC_flags, $PROFdict) if $PROFdict;

      $Oopt_FinalStgProfilingMassage = '-fmassage-stg-for-profiling';

      # Ignore user sccs when auto annotating, but warn when doing so.
      $PROFignore_scc = '-W' if $PROFauto; 

      push(@HsP_flags, (($PROFignore_scc) ? $PROFignore_scc : '-S'));
  }
  #if ( $BuildTag ne '' ) {
  #    local($b) = $BuildDescr{$BuildTag};
  #    if ($PARing    eq 'p') { print STDERR "$Pgm: Can't mix $b with -parallel.\n"; exit 1; }
  #    if ($GRANing   eq 'g') { print STDERR "$Pgm: Can't mix $b with -gransim.\n"; exit 1; }
  #    if ($TICKYing  eq 't') { print STDERR "$Pgm: Can't mix $b with -ticky.\n"; exit 1; }

  #    # ok to have a user-way profiling build
  #    # eval the profiling opts ... but leave user-way BuildTag 
  #    if ($PROFing   eq 'p') { &processArgs(split(' ', $SetupOpts{'_p'})); } # eval($EvaldSetupOpts{'_p'}); }

  if ( $PROFing eq 'p' ) {
      if ($PARing   eq 'p') { print STDERR "$Pgm: Can't do profiling with -parallel.\n"; exit 1; }
      if ($GRANing  eq 'g') { print STDERR "$Pgm: Can't do profiling with -gransim.\n"; exit 1; }
      if ($TICKYing eq 't') { print STDERR "$Pgm: Can't do profiling with -ticky.\n"; exit 1; }
      $BuildTag = '_p' ;

  } elsif ( $PARing eq 'p' ) {
      if ($GRANing  eq 'g') { print STDERR "$Pgm: Can't mix -parallel with -gransim.\n"; exit 1; }
      if ($TICKYing eq 't') { print STDERR "$Pgm: Can't mix -parallel with -ticky.\n"; exit 1; }
      $BuildTag = '_mp';

      if ( $Do_lnkr && ( ! $ENV{'PVM_ROOT'} || ! $ENV{'PVM_ARCH'} )) {
	  print STDERR "$Pgm: both your PVM_ROOT and PVM_ARCH environment variables must be set for linking under -parallel.\n";
	  exit(1);
      }

  } elsif ( $GRANing eq 'g' ) {
      if ($TICKYing eq 't') { print STDERR "$Pgm: Can't mix -gransim with -ticky.\n"; exit 1; }
      $BuildTag = '_mg';

  } elsif ( $TICKYing eq 't' ) {
      $BuildTag = '_t';
  }

\end{code}

After the sanity checks, add flags to the necessary parts of the driver pipeline:

\begin{code}
  if ( $BuildTag ne '' ) { # something other than normal sequential...

      local($Tag) = "${BuildTag}";
      $Tag =~ s/_//;  # move the underscore to the back

      $HscOut = '-C='; # must go via C
      &processArgs(split(' ', $SetupOpts{$BuildTag}));
#      eval($EvaldSetupOpts{$BuildTag});
  }
\end{code}

Decide what the consistency-checking options are in force for this run:
\begin{code}

  $HsC_consist_options = "${BuildTag},${DEBUGging}";
  $Cc_consist_options  = "${BuildTag},${DEBUGging}";

  #
  # Funny place to put it, but why not.
  #
  if ( $HiSuffix_prelude eq '' ) {
       local($Tag) = "${BuildTag}";
       $Tag =~ s/_//;
       $Tag = "${Tag}_" if $Tag ne '';
       $HiSuffix_prelude="${Tag}hi";
  }
} # setupBuildFlags
\end{code}

%************************************************************************
%*									*
\subsection{Add on machine-specific C-compiler flags}
%*									*
%************************************************************************

Shove on magical machine-specific options.  We use \tr{unshift} to
stick them on the {\em front} of the arrays, so that ``later''
user-specified flags can clobber them (e.g., \tr{-U__STG_REV_TBLS__}).

Note: a few ``always apply'' flags were set at the very beginning.

\begin{code}
sub setupMachOpts {

  if ($TargetPlatform =~ /^alpha-/) {
      unshift(@CcBoth_flags,  ('-static'));

  } elsif ($TargetPlatform =~ /^hppa/) {
      unshift(@CcBoth_flags,  ('-static'));
      #
      # We don't put in '-mlong-calls', because it's only
      # needed for very big modules (sigh), and we don't want
      # to hobble ourselves further on all the other modules
      # (most of them).
      #  
      # [Dated comment (gcc-2.6.x?), -mlong-calls is no longer
      #  a supported gcc HPPA flag]
      unshift(@CcBoth_flags,  ('-D_HPUX_SOURCE'));
        # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
        # (very nice, but too bad the HP /usr/include files don't agree.)

  } elsif ($TargetPlatform =~ /^i386-/) {
      # -fno-defer-pop : basically the same game as for m68k
      #
      # -fomit-frame-pointer : *must* in .hc files; because we're stealing
      #	 the fp (%ebp) for our register maps.

      unshift(@CcRegd_flags_hc, '-fno-defer-pop');
      unshift(@CcRegd_flags_hc, '-fomit-frame-pointer');
      unshift(@CcRegd_flags,    "-DSTOLEN_X86_REGS=$StolenX86Regs");

  } elsif ($TargetPlatform =~ /^m68k-/) {
      # -fno-defer-pop : for the .hc files, we want all the pushing/
      #    popping of args to routines to be explicit; if we let things
      #    be deferred 'til after an STGJUMP, imminent death is certain!
      #
      # -fomit-frame-pointer : *don't*
      #	   It's better to have a6 completely tied up being a frame pointer
      #	   rather than let GCC pick random things to do with it.
      #	   (If we want to steal a6, then we would try to do things
      #	   as on iX86, where we *do* steal the frame pointer [%ebp].)

      unshift(@CcRegd_flags_hc, '-fno-defer-pop');
      unshift(@CcRegd_flags,    '-fno-omit-frame-pointer');
	# maybe gives reg alloc a better time
	# also: -fno-defer-pop is not sufficiently well-behaved without it

  } elsif ($TargetPlatform =~ /^mips-/) {
      unshift(@CcBoth_flags,  ('-static'));

  } elsif ($TargetPlatform =~ /^powerpc-|^rs6000-/) {
      unshift(@CcBoth_flags,  ('-static')); # always easier to start with
      unshift(@CcRegd_flags, ('-finhibit-size-directive')); # avoids traceback tables
  } elsif ($TargetPlatform =~ /^sparc-/) {
  }
} # end of setupMachOpts
\end{code}

%************************************************************************
%*									*
\subsection{Set up for warnings}
%*									*
%************************************************************************

Several warnings are turned on by default.  These are supposed to be
the 'I'm pretty sure you've made a mistake here' kind of warnings.
The rest are turned on by the -W and -Wall options, or individually
via their -fwarn and -fno-warn flags.

\begin{code}
sub setupWarningFlags {
&add_Hsc_flags( @StandardWarnings );
}
\end{code}

Same unshifting magic, but for special linker flags.

The configure script determines whether the object file symbol tables
have a leading underscore, and sets @LeadingUnderscore@ accordingly.
(The driver script `sees' the setting of the @LeadingUnderscore@
by having the Makefile prepend it).

\begin{code}
sub setupLinkOpts {
  local($uscore) = ( ${LeadingUnderscore} eq 'YES' ) ? '_' : '';

  unshift(@Ld_flags,
        (($Ld_main) ? ( '-u', "${uscore}Main_" . $Ld_main . '_closure' ) : ()));

  # things that are referenced by the RTS - make sure that we pull 'em in
  unshift(@Ld_flags,
         ( '-u', "${uscore}PrelBase_IZh_static_info"
          ,'-u', "${uscore}PrelBase_CZh_static_info"
          ,'-u', "${uscore}PrelBase_FZh_static_info"
          ,'-u', "${uscore}PrelBase_DZh_static_info"
          ,'-u', "${uscore}PrelAddr_AZh_static_info"
          ,'-u', "${uscore}PrelAddr_WZh_static_info"
          ,'-u', "${uscore}PrelAddr_I64Zh_static_info"
          ,'-u', "${uscore}PrelAddr_W64Zh_static_info"
          ,'-u', "${uscore}PrelForeign_StablePtr_static_info"
	  ,'-u', "${uscore}PrelBase_IZh_con_info"
          ,'-u', "${uscore}PrelBase_CZh_con_info"
          ,'-u', "${uscore}PrelBase_FZh_con_info"
          ,'-u', "${uscore}PrelBase_DZh_con_info"
          ,'-u', "${uscore}PrelAddr_AZh_con_info"
          ,'-u', "${uscore}PrelAddr_WZh_con_info"
          ,'-u', "${uscore}PrelAddr_I64Zh_con_info"
          ,'-u', "${uscore}PrelAddr_W64Zh_con_info"
          ,'-u', "${uscore}PrelForeign_StablePtr_con_info"
          ,'-u', "${uscore}PrelBase_False_static_closure"
          ,'-u', "${uscore}PrelBase_True_static_closure"
          ,'-u', "${uscore}PrelPack_unpackCString_closure"
	));
  if (!$NoHaskellMain) {
   unshift (@Ld_flags,'-u', "${uscore}PrelMain_mainIO_closure");
  }
  if ($TargetPlatform =~ /^powerpc-|^rs6000-/) {
    # sometimes we have lots of toc entries...
    #  unshift(@Ld_flags, ('-Xlinker -bbigtoc -Xlinker -bnoquiet')); 
    unshift(@Ld_flags, ('-Xlinker -bbigtoc')); 
  }

} # end of setupLinkOpts

\end{code}

%************************************************************************
%*									*
\subsection{Set up include paths and system-library enslurpment}
%*									*
%************************************************************************

Now that we know what garbage-collector, etc., are required, we can
finalise our list of libraries to slurp through, and generally Get
Ready for Business.

\begin{code}
sub setupIncPaths {
  # default includes must be added AFTER option processing
  if ( ! $INSTALLING ) {
      push (@Include_dir, "$TopPwd/${CURRENT_DIR}/${GHC_INCLUDE_DIR}");
  } else {
      push (@Include_dir, "$InstLibDirGhc/includes");
      push (@Include_dir, "$InstLibDirGhc/includes");
  }
} # end of setupIncPaths
\end{code}

\begin{code}
sub setupSyslibs {
  push(@SysLibrary, ( '-lHS', '-lHS_cbits' )); # basic I/O and prelude stuff

  local($f);
  foreach $f (@SysLibrary) {
      next if $f =~ /_cbits/;
      $f .= $BuildTag if $f =~ /^-lHS/;
  }

  # Push library HSrts, plus boring clib bit
  push(@SysLibrary, "-lHSrts${BuildTag}");

  #
  # RTS compiled with cygwin32, uses the WinMM API
  # to implement the itimers, since cygwin.dll does not
  # support it. Only reqd. for `ways' that use itimers.
  #
  push(@SysLibrary, '-lwinmm') if $TargetPlatform eq 'i386-unknown-cygwin32';

  # Push the pvm libraries
  if ($BuildTag eq '_mp') {
      $pvmlib = "$ENV{'PVM_ROOT'}/lib/$ENV{'PVM_ARCH'}";
      push(@SysLibrary, "-L$pvmlib", '-lgpvm3', '-lpvm3');
      if ( $ENV{'PVM_ARCH'} eq 'SUNMP' ) {
          push(@SysLibrary, '-lthread', '-lsocket', '-lnsl');
      } elsif ( $ENV{'PVM_ARCH'} eq 'SUN4SOL2' ) {
          push(@SysLibrary, '-lsocket', '-lnsl');
      }
  }

# Push the GNU multi-precision arith lib; and the math library

# If this machine has GMP already installed, then we'll get the installed
# lib here, because presumably the one in the tree won't have been built.

if ($LibGmp eq 'not-installed') {
  push(@SysLibrary, "-lgmp");
} else {
  push(@SysLibrary, "-l$LibGmp");
}

push(@SysLibrary, '-lm');
\end{code}

%************************************************************************
%*									*
\subsection{Check that this system was built to do what we are asking}
%*									*
%************************************************************************

Before continuing we check that the appropriate build is available.

\begin{code}
#die "$Pgm: no BuildAvail?? $BuildTag\n" if $BuildDescr{$BuildTag} eq '' ; # sanity

if ( $BuildDescr{$BuildTag} eq '' ) {
    print STDERR "$Pgm: a `", $BuildDescr{$BuildTag},
	"' \"build\" is not available with your GHC setup.\n";
    print STDERR "(It was not configured for it at your site.)\n";
    print STDERR $ShortUsage;
    exit 1;
}

} # end of setupSyslibs

\end{code}

%************************************************************************
%*									*
\subsection{Final miscellaneous setup bits before we start going}
%*									*
%************************************************************************

Record largest specific heapsize, if any.
\begin{code}
sub setupHeapStackSize {
   $Specific_heap_size = $Specific_heap_size * $Scale_sizes_by;
   push(@HsC_rts_flags, '-H'.$Specific_heap_size);
   $Specific_stk_size = $Specific_stk_size * $Scale_sizes_by;
   push(@HsC_rts_flags, "-K$Specific_stk_size");
}
\end{code}

If no input or link files seen, then we let 'em feed in stdin; this is
mainly for debugging.

\begin{code}

if ($#Input_file < 0 && $#Link_file < 0) {
    @Input_file = ( '-' );

    open(INF, "> $Tmp_prefix.hs") || &tidy_up_and_die(1,"Can't open $Tmp_prefix.hs\n");
    print STDERR "Enter your Haskell program, end with ^D (on a line of its own):\n" if -t;
    while (<STDIN>) { print INF $_; }
    close(INF) || &tidy_up_and_die(1,"Failed writing to $Tmp_prefix.hs\n");
}

\end{code}

Tell the world who we are, if they asked.
\begin{code}
print STDERR "${ProjectName}, version ${ProjectVersion}, patchlevel ${ProjectPatchLevel}\n"
    if $Verbose;
\end{code}

%************************************************************************
%*									*
\section[Driver-main-loop]{Main loop: Process input files, and link if required}
%*									*
%************************************************************************

Process the input files; don't continue with linking if there are
problems (global variable @$Status@ non-zero).
\begin{code}
foreach $ifile (@Input_file) {
    &ProcessInputFile($ifile);
}

if ( $Status > 0 ) { # don't link if there were errors...
    print STDERR $ShortUsage;
    &tidy_up();
    exit $Status;
}

# append last minute flags linker and consistency flags
&setupBuildFlags();
&setupSyslibs();
&setupLinkOpts();

\end{code}

Link if appropriate.
\begin{code}
if ($Do_lnkr) {
    local($libdirs) = '';

    # glue them together:
    push(@UserLibrary_dir, @SysLibrary_dir);

    $libdirs = '-L' . join(' -L',@UserLibrary_dir) if $#UserLibrary_dir >= 0;

    # for a linker, use an explicitly given one, or the going C compiler ...
    local($lnkr) = ( $Lnkr ) ? $Lnkr : $CcRegd;

    if ( ($Specific_output_file eq '') && 
         ($TargetPlatform eq 'i386-unknown-cygwin32') ) {
         $Specific_output_file = 'main.exe';
         print STDERR "Output file not specified, defaulting to \"main.exe\"\n";
    }

    local($output) = ($Specific_output_file ne '') ? "-o $Specific_output_file" : '';
    @Files_to_tidy = ($Specific_output_file ne '') ? $Specific_output_file : 'a.out'; 

    local($to_do) = "$lnkr $Verbose @Ld_flags $output @Link_file $TopClosureFile $libdirs @UserLibrary @SysLibrary";
    &run_something($to_do, 'Linker');

    # finally, check the consistency info in the binary
    local($executable) = $Files_to_tidy[0];
    @Files_to_tidy = (); # reset; we don't want to nuke it if it's inconsistent

    if ( $LinkChk ) {
    	# dynamically load consistency-chking code; then do it.
	require('ghc-consist.prl')
	    || &tidy_up_and_die(1,"$Pgm: panic: can't load ghc-consist.prl!\n");

    	&chk_consistency_info ( $executable );
    }

    # if PVM parallel stuff, we do truly weird things.
    # Essentially: (1) move the executable over to where PVM expects
    # to find it.  (2) create a script in place of the executable
    # which will cause the program to be run, via SysMan.
    if ( $PARing eq 'p' ) {
	local($pvm_executable) = $executable;
	local($pvm_executable_base);

	if ( $pvm_executable !~ /^\// ) { # a relative path name: make absolute
	    local($pwd) = `pwd`;
	    chop($pwd);
	    $pwd =~ s/^\/tmp_mnt//;
	    $pvm_executable = "$pwd/$pvm_executable";
	}

	$pvm_executable =~ s|/|=|g; # make /s into =s
	$pvm_executable_base = $pvm_executable;

	$pvm_executable = $ENV{'PVM_ROOT'} . '/bin/' . $ENV{'PVM_ARCH'}
			. "/$pvm_executable";

	&run_something("$Rm -f $pvm_executable; $Cp -p $executable $pvm_executable && $Rm -f $executable", 'Moving binary to PVM land');

	# OK, now create the magic script for "$executable"
	open(EXEC, "> $executable") || &tidy_up_and_die(1,"$Pgm: couldn't open $executable to write!\n");
	print EXEC <<EOSCRIPT1;
eval 'exec perl -S \$0 \${1+"\$@"}'
  if \$running_under_some_shell;
# =!=!=!=!=!=!=!=!=!=!=!
# This script is automatically generated: DO NOT EDIT!!!
# Generated by Glasgow Haskell, version ${ProjectVersion} ${ProjectPatchLevel}
#
\$pvm_executable      = '$pvm_executable';
\$pvm_executable_base = '$pvm_executable_base';
\$SysMan = '$SysMan';
EOSCRIPT1

	print EXEC <<\EOSCRIPT2;
# first, some magical shortcuts to run "commands" on the binary
# (which is hidden)
if ($#ARGV == 1 && $ARGV[0] eq '+RTS' && $ARGV[1] =~ /^--((size|file|strip|rm|nm).*)/ ) {
    local($cmd) = $1;
    system("$cmd $pvm_executable");
    exit(0); # all done
}

# OK, really run it; process the args first
$ENV{'PE'} = $pvm_executable_base;
$debug = '';
$nprocessors = 2; # the default
@nonPVM_args = ();
$in_RTS_args = 0;

# ToDo: handle --RTS
args: while ($a = shift(@ARGV)) {
    if ( $a eq '+RTS' ) {
	$in_RTS_args = 1;
    } elsif ( $a eq '-RTS' ) {
	$in_RTS_args = 0;
    }
    if ( $a eq '-d' && $in_RTS_args ) {
	$debug = '-';
    } elsif ( $a =~ /^-N(\d+)/ && $in_RTS_args ) {
	$nprocessors = $1;
    } else {
	push(@nonPVM_args, $a);
    }
}