CP RM CONTEXT_DIFF
-WAY_*_NAME WAY_*_HC_OPTS
+WAY_*_NAME WAY_*_REAL_OPTS
LeadingUnderscore
+GhcWithRegisterised
+
\end{verbatim}
Establish what executables to run for the various phases, what the
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 = '';
+ $Oopt_UsageSPInf = ''; # Off by default
} # end of setupOptFlags
# Assign defaults to these right away.
$Lnkr = ''; # "linker" is normally GCC
@Ld_flags = ();
+@Dll_flags = ();
# 'nm' is used for consistency checking (ToDo: mk-world-ify)
# ToDo: check the OS or something ("alpha" is surely not the crucial question)
'-fwarn-missing-methods',
'-fwarn-duplicate-exports');
@MinusWOpts = (@StandardWarnings,
- '-fwarn-incomplete-patterns',
'-fwarn-unused-binds',
+ '-fwarn-unused-matches',
+ '-fwarn-incomplete-patterns',
'-fwarn-unused-imports');
@MinusWallOpts = (@MinusWOpts,
- '-fwarn-unused-matches',
+ '-fwarn-type-defaults',
'-fwarn-name-shadowing',
'-fwarn-missing-signatures');
\end{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",
+ '', 'Normal Sequential',
+ '_p', "Profiling",
+ '_t', "Ticky-ticky Profiling",
+ '_u', "Unregisterised",
+ '_mp', "Parallel",
+ '_mg', "Gransim",
# system ways end
'_a', "$WAY_a_NAME",
'_b', "$WAY_b_NAME",
#
%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",
+ '_a', "$WAY_a_REAL_OPTS",
+ '_b', "$WAY_b_REAL_OPTS",
+ '_c', "$WAY_c_REAL_OPTS",
+ '_d', "$WAY_d_REAL_OPTS",
+ '_e', "$WAY_e_REAL_OPTS",
+ '_f', "$WAY_f_REAL_OPTS",
+ '_g', "$WAY_g_REAL_OPTS",
+ '_h', "$WAY_h_REAL_OPTS",
+ '_i', "$WAY_i_REAL_OPTS",
+ '_j', "$WAY_j_REAL_OPTS",
+ '_k', "$WAY_k_REAL_OPTS",
+ '_l', "$WAY_l_REAL_OPTS",
+ '_m', "$WAY_m_REAL_OPTS",
+ '_n', "$WAY_n_REAL_OPTS",
+ '_o', "$WAY_o_REAL_OPTS",
+ '_A', "$WAY_A_REAL_OPTS",
+ '_B', "$WAY_B_REAL_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
+ '_p', "-fscc-profiling -DPROFILING -optc-DPROFILING",
+ '_t', "-fticky-ticky -DTICKY_TICKY -optc-DTICKY_TICKY",
+ '_u', "-optc-DNO_REGS -optc-DUSE_MINIINTERPRETER -fno-asm-mangling -funregisterised",
+ '_mp', "-fstack-check -fparallel -D__PARALLEL_HASKELL__ -optc-DPAR",
+ '_mg', "-fstack-check -fconcurrent -fgransim -D__GRANSIM__ -D__CONCURRENT_HASKELL__ -optc-DCONCURRENT -optc-DGRAN");
# where to look for interface files (system hi's, i.e., prelude and syslibs)
@SysImport_dir = ( $INSTALLING )
@HsSourceCppOpts =
( "-D__HASKELL1__=$Haskell1Version"
, "-D__GLASGOW_HASKELL__=$ProjectVersionInt"
- # not yet -- SDM
- # , "-D__CONCURRENT_HASKELL__"
+ , "-D__HASKELL98__"
+ , "-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_LIB_DIR/std/cbits"
)
);
-@SysLibrary = (); # will be built up as we go along
$TopClosureFile # defaults to 1.2 one; will be mangled later
= '';
# make depend for Haskell
$MkDependHS
- = ( $INSTALLING ) ? "$InstBinDirGhc/mkdependHS"
+ = ( $INSTALLING ) ? "$InstLibExecDirGhc/mkdependHS"
: "$TopPwd/$CURRENT_DIR/$GHC_UTILS_DIR/mkdependHS/mkdependHS";
# Fill in later
@MkDependHS_flags = ();
# 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}
$MinusO2ForC = 0; # set to 1 if -O2 should be given to C compiler
$StolenX86Regs = 4; # **HACK*** of the very worst sort
$CoreLint = '';
+$USPLint = '';
$StgLint = '';
@Import_dir = ('.'); #-i things
@Include_dir = ('.'); #-I things; other default(s) stuck on AFTER option processing
+@UserLibrary_dir= (); #-L things;...
+@UserLibrary = (); #-l things asked for by the user
+@SysLibrary = (); # will be built up as we go along
\end{code}
We are given a list of files with various presumably-known suffixes
$Cpp_flag_set = 0; # (hack)
$Only_preprocess_C = 0; # pretty hackish
$Only_preprocess_hc = 0; # ditto
-$Only_generate_deps = 0; # "
+$Only_generate_deps = 0; # ""
+$Only_generate_dll = 0;
$PostprocessCcOutput = 0;
+# Win32 only:
+# static = 0 => produce code for DLLs (when compiling & linking.)
+$Static = 1;
+$Static = 0 if ($EnableWin32DLLs eq 'YES');
+
# native code-gen or via C?
$HaveNativeCodeGen = $GhcWithNativeCodeGen;
$HscOut = '-C='; # '-C=' ==> .hc output; '-S=' ==> .s output; '-N=' ==> neither
$HscOut = '-S='
- if $HaveNativeCodeGen && $TargetPlatform =~ /^(alpha)-/;
+ if ($HaveNativeCodeGen ne 'YES') && $TargetPlatform =~ /^(alpha)-/;
# TEMP: disable x86 & Sparc if $HaveNativeCodeGen && $TargetPlatform =~ /^(i386|alpha|sparc)-/;
$ProduceHi = '-hifile=';
$HiOnStdout = 0;
$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
+$PROFdict = ''; # set to relevant hsc flag if -auto-dicts
$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
+$UNREGing = ($GhcWithRegisterised eq 'YES') ? '' : 'u';
$Specific_hi_file = ''; # set by -ohi <file>; "-" for stdout
$Specific_dump_file = ''; # set by -odump <file>; "-" for stdout
$Using_dump_file = 0;
$Osuffix = ''; # default: use the normal suffix for that kind of output
$HiSuffix = 'hi';
$HiSuffix_prelude = '';
+$CompilingPrelude=0;
$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;
exit $Status;
}
+# ..or just to construct a (Haskell) DLL.
+if ( $Status == 0 && $Only_generate_dll && $EnableWin32DLLs ) {
+
+ &createWin32DLL();
+ 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)
sub setupOptimiseFlags {
+ # this pass-ordering sequence was agreed by Simon and Andr\'e
+ # (WDP 94/07, 94/11).
+
@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,
+ = (
+ '-fsimplify',
+ '[',
+ '-finline-phase2',
+ $Oopt_MaxSimplifierIterations,
']',
+
$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)
= (
+ '-ffoldr-build-on',
+
'-fdo-eta-reduction',
+ '-fdo-lambda-eta-expansion',
+ '-fcase-of-case',
+ '-fcase-merge',
+ '-flet-to-case',
+ $Oopt_PedanticBottoms,
# 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,
+ '-finline-phase0', # Don't inline anything till full laziness has bitten
+ # In particular, inlining wrappers inhibits floating
+ # e.g. ...(case f x of ...)...
+ # ==> ...(case (case x of I# x# -> fw x#) of ...)...
+ # ==> ...(case x of I# x# -> case fw x# of ...)...
+ # and now the redex (f x) isn't floatable any more
+ '-fmax-simplifier-iterations2',
']',
- ($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',
- ']',
+ # Specialisation is best done before full laziness
+ # so that overloaded functions have all their dictionary lambdas manifest
+ ($Oopt_DoSpecialise) ? ( $Oopt_DoSpecialise, ) : (),
+ '-ffull-laziness',
+ '-ffloat-inwards',
-# ($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,
-# ']',
-# ) : (),
+# '-fsimplify',
+# '[',
+# # Run the simplifier before specialising, so that overloaded functions
+# # look like f = \d -> ...
+# # (Full laziness may lift out something hiding the \d
+# '-finline-phase1',
+# '-fmax-simplifier-iterations1',
+# ']',
- # 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,
- ']',
- ) : (),
+ '-fsimplify',
+ '[',
+ '-finline-phase1',
+ # Want to run with inline phase 1 after the specialiser to give
+ # maximum chance for fusion to work before we inline build/augment
+ # in phase 2. This made a difference in 'ansi' where an overloaded
+ # function wasn't inlined till too late.
+ $Oopt_MaxSimplifierIterations,
+ ']',
- '-ffloat-inwards',
+ $Oopt_UsageSPInf, # infer usage information here in case we need it later.
+ # (add more of these where you need them --KSW 1999-04)
'-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,
+ # Need inline-phase2 here so that build/augment get
+ # inlined. I found that spectral/hartel/genfft lost some useful
+ # strictness in the function sumcode' if augment is not inlined
+ # before strictness analysis runs
+
+ '-finline-phase2',
+ $Oopt_MaxSimplifierIterations,
']',
+
'-fstrictness',
+ '-fcpr-analyse',
+ '-fworker-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',
- '-flet-to-case', # Aha! Only done after strictness analysis
- $Oopt_PedanticBottoms,
- $Oopt_MonadEtaExpansion,
- $Oopt_MaxSimplifierIterations,
- $Oopt_ShowSimplifierProgress,
+ $Oopt_MaxSimplifierIterations,
+ # No -finline-phase: allow all Ids to be inlined now
']',
+ '-fcse', # CSE must immediately follow a simplification pass, because it relies
+ # on the no-shadowing invariant. See comments at the top of CSE.lhs
+
+ '-ffull-laziness', # nofib/spectral/hartel/wang doubles in speed if you
+ # do full laziness late in the day. It only happens
+ # after fusion and other stuff, so the early pass doesn't
+ # catch it. For the record, the redex is
+ # f_el22 (f_el21 r_midblock)
'-ffloat-inwards',
# Case-liberation for -O2. This should be after
# ( ($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 ]" ),
+# : "-fliberate-case -fsimplify [ $Oopt_FB_Support -ffloat-lets-exposing-whnf -ffloat-primops-ok -fcase-of-case -fdo-case-elim -fcase-merge -fdo-lambda-eta-expansion -freuse-con -flet-to-case $Oopt_PedanticBottoms $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,
+ $Oopt_MaxSimplifierIterations,
+ # No -finline-phase: allow all Ids to be inlined now
']',
# '-fstatic-args',
-#LATER: '-fcalc-inlinings2', -- pointless for 2.01
-
# stg2stg passes
- '-flambda-lift',
+# '-flambda-lift',
$Oopt_FinalStgProfilingMassage,
$Oopt_StgStats,
%************************************************************************
Sort out @$BuildTag@, @$PROFing@, @$PARing@,
-@$GRANing@, @$TICKYing@:
+@$GRANing@, @$TICKYing@, @UNREGing@:
\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;
+ 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};
} elsif ( $TICKYing eq 't' ) {
$BuildTag = '_t';
- }
+ } elsif ( $UNREGing eq 'u' ) {
+ if ($GhcWithRegisterised eq 'YES') {
+ $BuildTag = '_u';
+ }
+ }
\end{code}
After the sanity checks, add flags to the necessary parts of the driver pipeline:
# 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";
+
+ if ($CompilingPrelude) {
+ $HiSuffix_prelude = "$HiSuffix" if $CompilingPrelude;
+ } else {
+ local($Tag) = "${BuildTag}";
+
+ $Tag =~ s/_//;
+ $Tag = "${Tag}_" if $Tag ne '';
+ $HiSuffix_prelude="${Tag}hi";
+ }
}
} # setupBuildFlags
\end{code}
unshift(@CcRegd_flags_hc, '-fno-defer-pop');
unshift(@CcRegd_flags_hc, '-fomit-frame-pointer');
unshift(@CcRegd_flags, "-DSTOLEN_X86_REGS=$StolenX86Regs");
+
+ unshift(@CcBoth_flags, ('-DDONT_WANT_WIN32_DLL_SUPPORT')) if ($Static);
} elsif ($TargetPlatform =~ /^m68k-/) {
# -fno-defer-pop : for the .hc files, we want all the pushing/
# 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}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}PrelStable_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}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}PrelStable_StablePtr_con_info"
,'-u', "${uscore}PrelBase_False_static_closure"
,'-u', "${uscore}PrelBase_True_static_closure"
,'-u', "${uscore}PrelPack_unpackCString_closure"
+ ,'-u', "${uscore}PrelException_stackOverflow_closure"
+ ,'-u', "${uscore}PrelException_heapOverflow_closure"
+ ,'-u', "${uscore}PrelException_NonTermination_static_closure"
));
if (!$NoHaskellMain) {
unshift (@Ld_flags,'-u', "${uscore}PrelMain_mainIO_closure");
unshift(@Ld_flags, ('-Xlinker -bbigtoc'));
}
+
} # end of setupLinkOpts
\end{code}
# 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(@SysLibrary, '-lwinmm') if $TargetPlatform eq 'i386-unknown-cygwin32';
+ # Note: currently only tested with mingw, may cause conflicts when linking
+ # with libcygwin.a
+ push(@SysLibrary, '-lwsock32') if ($TargetPlatform =~ /-(mingw32|cygwin32)$/);
# Push the pvm libraries
if ($BuildTag eq '_mp') {
push(@SysLibrary, "-l$LibGmp");
}
-push(@SysLibrary, '-lm');
+push(@SysLibrary, '-lm') if !( $TargetPlatform =~ /^.*(cygwin32|mingw32)$/ );
\end{code}
%************************************************************************
&ProcessInputFile($ifile);
}
-if ( $Status > 0 ) { # don't link if there were errors...
+# don't link if there were errors...
+if ( $Status > 0 ) {
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);
- }
-}
-
-local($return_val) = 0;
-system("$SysMan $debug $pvm_executable $nprocessors @nonPVM_args");
-$return_val = $?;
-system("mv $ENV{'HOME'}/$pvm_executable_base.???.gr .") if -f "$ENV{'HOME'}/$pvm_executable_base.001.gr";
-exit($return_val);
-EOSCRIPT2
- close(EXEC) || die "Failed closing $executable\n";
- chmod 0755, $executable;
- }
-}
+# Link if appropriate.
+&runLinker() if $Do_lnkr;
# that... that's all, folks!
&tidy_up();
push(@HsC_flags, '-fsource-unchanged');
}
+ # Indicate whether we're static or not.
+ # This will only ever
+ push(@HsC_flags, '-static') if $Static;
+
# Run the compiler
&runHsc($ifile_root, $hsc_out, $hsc_hi, $hsc_out_c_stub, $hsc_out_h_stub, $going_interactive);
sub runHsc {
local($ifile_root, $hsc_out, $hsc_hi, $hsc_out_c_stub, $hsc_out_h_stub, $going_interactive) = @_;
- # prepend comma to HsP flags (so hsc can tell them apart...)
- foreach $a ( @HsP_flags ) { $a = ",$a" unless $a =~ /^,/; }
-
&makeHiMap() unless $HiMapDone;
push(@HsC_flags, "-himap=$HiIncludeString");
if ( $going_interactive ) {
# don't need .hi unless we're going to show it on stdout:
- $ProduceHi = '-nohifile=' if ! $HiOnStdout;
+ $ProduceHi = '-nohifile=' if ! ($HiOnStdout || $Specific_hi_file ne '' );
$do_cc = 0; $do_as = 0; $Do_lnkr = 0; # and we won't go any further...
}
local($to_do_opts) = "$Tmp_prefix.opts";
open(OPTS, "> $Tmp_prefix.opts") || &tidy_up_and_die(1,"Can't open $Tmp_prefix.opts\n");
- print OPTS "$dump @HsC_flags $CoreLint $StgLint $Verbose";
+ print OPTS "$dump @HsC_flags $CoreLint $USPLint $StgLint $Verbose";
close(OPTS);
- $to_do = "$HsC @HsP_flags ,$hscpp_hsc \@$Tmp_prefix.opts $output +RTS @HsC_rts_flags";
+ $to_do = "$HsC $hscpp_hsc \@$Tmp_prefix.opts $output +RTS @HsC_rts_flags";
} else {
- $to_do = "$HsC @HsP_flags ,$hscpp_hsc $dump @HsC_flags $CoreLint $StgLint $Verbose $output +RTS @HsC_rts_flags";
+ $to_do = "$HsC $hscpp_hsc $dump @HsC_flags $CoreLint $USPLint $StgLint $Verbose $output +RTS @HsC_rts_flags";
}
&run_something($to_do, 'Haskell compiler');
\end{code}
+Invoke the 'linker' - either the standard linker or the one used to build
+a (Win32) DLL.
+
+\begin{code}
+sub runLinker()
+{
+ local($libdirs) = '';
+
+ # append last minute flags linker and consistency flags
+ &setupBuildFlags();
+ &setupSyslibs();
+ &setupLinkOpts();
+
+ # 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';
+
+ &prepareWin32DllLink(1);
+
+ 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);
+ }
+}
+
+local($return_val) = 0;
+system("$SysMan $debug $pvm_executable $nprocessors @nonPVM_args");
+$return_val = $?;
+system("mv $ENV{'HOME'}/$pvm_executable_base.???.gr .") if -f "$ENV{'HOME'}/$pvm_executable_base.001.gr";
+exit($return_val);
+EOSCRIPT2
+ close(EXEC) || die "Failed closing $executable\n";
+ chmod 0755, $executable;
+ }
+}
+
+sub createWin32DLL()
+{
+ local ($libdirs);
+
+ # append last minute flags linker and consistency flags
+ &setupBuildFlags();
+ &setupSyslibs();
+ &setupLinkOpts();
+
+ # glue them together:
+ push(@UserLibrary_dir, @SysLibrary_dir);
+
+ $libdirs = '-L' . join(' -L',@UserLibrary_dir) if $#UserLibrary_dir >= 0;
+
+ &prepareWin32DllLink(0);
+
+ local ($bld_dll) = "dllwrap";
+
+ local ($output) = ($Specific_output_file ne '') ? "$Specific_output_file" : 'HSdll.dll';
+ local ($output_dir);
+ local ($output_file);
+ local ($output_lib, $output_def);
+
+ ($output_dir = $output) =~ s|(.*/)[^/]+$|$1|;
+ $output_dir = "" if ($output_dir eq $output);
+ ($output_file = $output) =~ s|.*/([^/]+)$|$1|;
+
+ ($output_lib = $output_file) =~ s|(.+)\.[^\.]*$|${output_dir}lib$1_imp.a|;
+ ($output_def = $output_file) =~ s|(.+)\.[^\.]*$|${output_dir}$1.def|;
+
+ push (@Dll_flags, "-mno-cygwin --target=i386-mingw32") if ($TargetPlatform =~ /^.*mingw32$/);
+ push (@Dll_flags, "--output-lib $output_lib");
+ # If the "--def " option hasn't been supplied, assume everything
+ # is going to be exported via the DLL.."
+ if (!grep(/--def/, @Dll_flags)) {
+ push (@Dll_flags, "--export-all --output-def $output_def");
+ }
+
+ local($to_do) = "$bld_dll @Dll_flags -o $output @Link_file $libdirs @UserLibrary @SysLibrary";
+ # Make sure the user sees this piece of magic.
+ print STDERR "$to_do\n" if (!$Verbose);
+ &run_something($to_do, 'DLL creator');
+}
+
+sub prepareWin32DllLink ()
+{
+ local($linking_main) = @_;
+
+ #
+ # Win32 DLLs - link with import libraries, not the real archives.
+ #
+ if ( $TargetPlatform =~ /-mingw32$/ ) {
+ if (!$Static) {
+ #
+ # If the libraries have the form libHSfoo.a, we
+ # transform that into libHSfoo_imp.a - the import
+ # library of the DLL.
+ #
+ foreach $a ( @SysLibrary ) {
+ $a = "${a}_imp" if ($a =~ /^-lHS/);
+ }
+ foreach $a ( @UserLibrary ) {
+ $a = "${a}_imp" if ($a =~ /^-lHS/);
+ }
+ push(@Link_file, ( $INSTALLING ) ? "$InstLibDirGhc/Main.o"
+ : "$TopPwd/$CURRENT_DIR/$GHC_RUNTIME_DIR/Main.o") if $linking_main;
+ push(@Link_file, ( $INSTALLING ) ? "$InstLibDirGhc/PrelMain.o"
+ : "$TopPwd/$CURRENT_DIR/$GHC_LIB_DIR/PrelMain.o") if $linking_main;
+ }
+ push(@Ld_flags, "-mno-cygwin");
+ }
+}
+\end{code}
+
+
%************************************************************************
%* *
\section[Driver-misc-utils]{Miscellaneous utilities}
local($c_flags) = "@CcBoth_flags";
local($ddebug_flag) = ( $DEBUGging ) ? '-DDEBUG' : '';
+ $c_flags .= " -mno-cygwin" if ( $TargetPlatform =~ /-mingw32$/ );
+
# "input" files to use that are not in some weird directory;
# to help C compilers grok .hc files [ToDo: de-hackify]
local($cc_help) = "ghc$$.c";
$GCs = $1 if /^\s*([0-9,]+) (collections? in generation 0|garbage collections? performed)/;
+ if ( /^\s+([0-9]+)\s+Mb total memory/ ) {
+ $TotMem = $1;
+ }
+
# The presence of -? in the following pattern is only there to
# accommodate 0.29 && <= 2.05 RTS'
if ( /^\s*INIT\s+time\s*(\d+\.\d\d)s\s*\(\s*-?(\d+\.\d\d)s elapsed\)/ ) {
# print out what we found
print STDERR "<<$SysSpecificTiming: ",
- "$BytesAlloc bytes, $GCs GCs, $AvgResidency/$MaxResidency avg/max bytes residency ($ResidencySamples samples), $InitTime INIT ($InitElapsed elapsed), $MutTime MUT ($MutElapsed elapsed), $GcTime GC ($GcElapsed elapsed)",
+ "$BytesAlloc bytes, $GCs GCs, $AvgResidency/$MaxResidency avg/max bytes residency ($ResidencySamples samples), ${TotMem}M in use, $InitTime INIT ($InitElapsed elapsed), $MutTime MUT ($MutElapsed elapsed), $GcTime GC ($GcElapsed elapsed)",
" :$SysSpecificTiming>>\n";
# OK, party over
, '' # extra ghc opts
, '' # extra cc opts
, '-luser32 -lgdi32' # extra ld opts
+ ],
+ com,
+ [ # where to slurp interface files from
+ ( $INSTALLING
+ ? "$InstLibDirGhc/imports/com"
+ : "$TopPwd/hdirect/lib"
+ )
+ , # where to find the archive to use when linking
+ ( $INSTALLING
+ ? "$InstLibDirGhc"
+ : "$TopPwd/hdirect/lib"
+ )
+ , ''
+ , 'exts' # Syslib dependencies
+ , '' # extra ghc opts
+ , '' # extra cc opts
+ , '-luser32 -lole32 -loleaut32 -ladvapi32'
+ # extra ld opts
]
);
# stop after preprocessing C
/^-M$/ && do { $Only_generate_deps = 1; $Do_as = 0; $Do_lnkr = 0; next arg; };
# only generate dependency information.
+ /^--mk-dll$/ && do { $Only_generate_dll = 1; $Do_as = 0; $Do_lnkr = 0; next arg; };
+ # Build a Win32 DLL (where supported).
/^-S$/ && do { $Do_as = 0; $Do_lnkr = 0; next arg; };
# stop after generating assembler
# stop after generating .o files
/^-link-chk$/ && do { $LinkChk = 1; next arg; };
- /^-no-link-chk$/ && do { $LinkChk = 0; next arg; };
# don't do consistency-checking after a link
+ /^-no-link-chk$/ && do { $LinkChk = 0; next arg; };
/^-tmpdir$/ && do { $Tmp_prefix = &grab_arg_arg(*Args,'-tmpdir', '');
$Tmp_prefix = "$Tmp_prefix/ghc$$";
$Status++;
}
}
+ $ProduceHi='-hifile=';
next arg; };
# The suffix to use when looking for interface files
/^-prof$/ && do { $PROFing = 'p'; next arg; }; # profiling -- details later!
- /^-auto/ && do {
- # generate auto SCCs on top level bindings
- # -auto-all = all top level bindings
- # -auto = only top level exported bindings
- $PROFauto = ( /-all/ )
- ? '-fauto-sccs-on-all-toplevs'
- : '-fauto-sccs-on-exported-toplevs';
+ /^-auto-dicts$/ && do {
+ $PROFdicts = '-fauto-sccs-on-dicts';
+ next arg; };
+ /^-auto-all$/ && do {
+ $PROFauto = '-fauto-sccs-on-all-toplevs';
+ next arg; };
+ /^-auto$/ && do {
+ $PROFauto = '-fauto-sccs-on-exported-toplevs';
next arg; };
/^-caf-all/ && do { # generate individual CAF SCC annotations
/^-optP(.*)$/ && do { push(@HsCpp_flags, $1); next arg; };
/^-optCrts(.*)$/&& do { push(@HsC_rts_flags, $1); next arg; };
/^-optC(.*)$/ && do { push(@HsC_flags, $1); next arg; };
- /^-optp(.*)$/ && do { push(@HsP_flags, $1); next arg; };
/^-optcpp(.*)$/ && do { push(@Cpp_define, $1); $Only_preprocess_hc = ($1 eq "-E"); next arg; };
/^-optc(.*)$/ && do { push(@CcBoth_flags, $1); next arg; };
/^-opta(.*)$/ && do { push(@As_flags, $1); next arg; };
/^-optl(.*)$/ && do { push(@Ld_flags, $1); next arg; };
+ /^-optdll(.*)$/ && do { push(@Dll_flags, $1); next arg; };
/^-optdep(.*)$/ && do { push(@MkDependHS_flags, $1); next arg; };
#---------- Haskell C pre-processor (hscpp) ----------------------------
/^-keep-s-files?-too$/ && do { $Keep_s_file_too = 1; next arg; };
/^-fignore-interface-pragmas$/ && do { push(@HsC_flags, $_); next arg; };
+ /^-fignore-asserts$/ && do { push(@HsC_flags, $_); next arg; };
/^-fno-implicit-prelude$/ && do { $NoImplicitPrelude= 1; push(@HsC_flags, $_); next arg; };
}
next arg; };
- /^-fno-asm-mangling$/ && do { $DoAsmMangling = 0; next arg; };
+ /^-unreg$/ && do { $UNREGing = 'u'; next arg; };
+ /^-funregisterised$/ && do { push(@HsC_flags, $_); next arg; };
+ /^-fno-asm-mangling$/ && do { $DoAsmMangling = 0; next arg; };
/^-fallow-overlapping-instances$/ && do { push(@HsC_flags, $_); next arg; };
/^-fallow-undecidable-instances$/ && do { push(@HsC_flags, $_); next arg; };
+ /^-fhistory-size.*$/ && do { push(@HsC_flags, $_); next arg; };
+ /^-fdicts-strict$/ && do { push(@HsC_flags, $_); next arg; };
/^-fglasgow-exts$/
&& do { push(@HsC_flags, $_);
- push(@HsP_flags, '-N');
# -fglasgow-exts implies -syslib exts
&add_syslib('exts');
/^-fno-speciali[sz]e$/
&& do { $Oopt_DoSpecialise = ''; next arg; };
+ /^-fusagesp$/
+ && do { $Oopt_UsageSPInf = '-fusagesp';
+ push (@HsC_flags, '-fusagesp-on'); next arg; };
+
+ /^-fcompiling-prelude$/ && do { $CompilingPrelude=1; push(@HsC_flags, $_); next arg; };
# Now the foldr/build options, which are *on* by default (for -O).
/^-ffoldr-build$/
&& do { $Oopt_FoldrBuild = 1;
- $Oopt_FB_Support = '-fdo-arity-expand';
#print "Yes F/B\n";
next arg; };
/^-fno-foldr-build$/
&& do { $Oopt_FoldrBuild = 0;
- $Oopt_FB_Support = '';
- next arg; };
-
- /^-fno-foldr-build-rule$/
- && do { $Oopt_FoldrBuild = 0;
- next arg; };
-
- /^-fno-enable-tech$/
- && do { $Oopt_FB_Support = '';
- next arg; };
-
- /^-fno-snapback-to-append$/
- && do { $Oopt_FoldrBuildInline .= ' -fdo-not-fold-back-append ';
next arg; };
# --------------- Renamer -------------
/^-fno-pre-inlining$/
&& do { push(@HsC_flags, $_); next arg };
- /^-fdo-monad-eta-expansion$/
- && do { $Oopt_MonadEtaExpansion = $_; next arg; };
-
/^-fno-let-from-(case|app|strict-let)$/ # experimental, really (WDP 95/10)
&& do { push(@HsC_flags, $_); next arg; };
+ /^-funbox-strict-fields$/
+ && do { push(@HsC_flags, $_); next arg; };
+
# --------------- Warnings etc. ------
/^-fwarn-(.*)$/ && do { push(@HsC_flags, $_); next arg; };
# -d(no-)core-lint is done this way so it is turn-off-able.
/^-dcore-lint/ && do { $CoreLint = '-dcore-lint'; next arg; };
/^-dno-core-lint/ && do { $CoreLint = ''; next arg; };
+ # Ditto for USP lint
+ /^-dusagesp-lint/ && do { $USPLint = '-dusagesp-lint'; next arg; };
+ /^-dno-usagesp-lint/ && do { $USPLint = ''; next arg; };
# Ditto for STG lint
/^-dstg-lint/ && do { $StgLint = '-dstg-lint'; next arg; };
/^-dno-stg-lint/ && do { $StgLint = ''; next arg; };
#---------- Linker (gcc, really) ---------------------------------------
- /^-static$/ && do { push(@Ld_flags, $_); next arg; };
+ /^-static$/ && do { $Static=1; push(@Ld_flags, $_); next arg; };
/^-no-hs-main$/ && do { $NoHaskellMain=1; next arg; };
#---------- mixed cc and linker magic ----------------------------------
projects / ghc-hetmet.git / blobdiff