\begin{code}
module CmdLineOpts (
- CoreToDo(..), StgToDo(..),
+ CoreToDo(..), buildCoreToDo, StgToDo(..),
SimplifierSwitch(..),
SimplifierMode(..), FloatOutSwitches(..),
-- Manipulating DynFlags
defaultDynFlags, -- DynFlags
- defaultHscLang, -- HscLang
dopt, -- DynFlag -> DynFlags -> Bool
dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
dopt_CoreToDo, -- DynFlags -> [CoreToDo]
getOpts, -- (DynFlags -> [a]) -> IO [a]
setLang,
getVerbFlag,
+ setOptLevel,
-- Manipulating the DynFlags state
getDynFlags, -- IO DynFlags
restoreDynFlags, -- IO DynFlags
-- sets of warning opts
- standardWarnings,
minusWOpts,
minusWallOpts,
-- Output style options
- opt_PprStyle_NoPrags,
- opt_PprStyle_RawTypes,
opt_PprUserLength,
opt_PprStyle_Debug,
opt_AutoSccsOnAllToplevs,
opt_AutoSccsOnExportedToplevs,
opt_AutoSccsOnIndividualCafs,
- opt_AutoSccsOnDicts,
opt_SccProfilingOn,
opt_DoTickyProfiling,
-- language opts
- opt_AllStrict,
opt_DictsStrict,
opt_MaxContextReductionDepth,
opt_IrrefutableTuples,
- opt_NumbersStrict,
opt_Parallel,
opt_SMP,
opt_RuntimeTypes,
opt_Flatten,
-- optimisation opts
- opt_NoMethodSharing,
- opt_DoSemiTagging,
- opt_FoldrBuildOn,
+ opt_NoMethodSharing,
+ opt_NoStateHack,
opt_LiberateCaseThreshold,
- opt_StgDoLetNoEscapes,
- opt_UnfoldCasms,
opt_CprOff,
- opt_UsageSPOn,
- opt_UnboxStrictFields,
+ opt_RulesOff,
opt_SimplNoPreInlining,
- opt_SimplDoEtaReduction,
- opt_SimplDoLambdaEtaExpansion,
- opt_SimplCaseMerge,
opt_SimplExcessPrecision,
opt_MaxWorkerArgs,
opt_UF_FunAppDiscount,
opt_UF_KeenessFactor,
opt_UF_UpdateInPlace,
- opt_UF_CheapOp,
opt_UF_DearOp,
-- misc opts
+ opt_ErrorSpans,
opt_InPackage,
opt_EmitCExternDecls,
opt_EnsureSplittableC,
opt_GranMacros,
opt_HiVersion,
opt_HistorySize,
- opt_IgnoreAsserts,
- opt_IgnoreIfacePragmas,
- opt_NoHiCheck,
opt_OmitBlackHoling,
- opt_OmitInterfacePragmas,
- opt_NoPruneTyDecls,
- opt_NoPruneDecls,
opt_Static,
opt_Unregisterised,
- opt_EmitExternalCore
+ opt_EmitExternalCore,
+ opt_PIC
) where
#include "HsVersions.h"
import Config
import Maybes ( firstJust )
+import Panic ( ghcError, GhcException(UsageError) )
import GLAEXTS
import DATA_IOREF ( IORef, readIORef, writeIORef )
import UNSAFE_IO ( unsafePerformIO )
| CoreDoWorkerWrapper
| CoreDoSpecialising
| CoreDoSpecConstr
- | CoreDoUSPInf
| CoreDoOldStrictness
| CoreDoGlomBinds
| CoreCSE
data DynFlag
-- debugging flags
- = Opt_D_dump_absC
+ = Opt_D_dump_cmm
| Opt_D_dump_asm
| Opt_D_dump_cpranal
| Opt_D_dump_deriv
| Opt_D_dump_inlinings
| Opt_D_dump_occur_anal
| Opt_D_dump_parsed
- | Opt_D_dump_realC
| Opt_D_dump_rn
| Opt_D_dump_simpl
| Opt_D_dump_simpl_iterations
| Opt_D_dump_tc
| Opt_D_dump_types
| Opt_D_dump_rules
- | Opt_D_dump_usagesp
| Opt_D_dump_cse
| Opt_D_dump_worker_wrapper
| Opt_D_dump_rn_trace
| Opt_D_dump_rn_stats
- | Opt_D_dump_stix
+ | Opt_D_dump_opt_cmm
| Opt_D_dump_simpl_stats
| Opt_D_dump_tc_trace
+ | Opt_D_dump_if_trace
| Opt_D_dump_splices
| Opt_D_dump_BCOs
| Opt_D_dump_vect
| Opt_D_dump_minimal_imports
| Opt_DoCoreLinting
| Opt_DoStgLinting
- | Opt_DoUSPLinting
+ | Opt_DoCmmLinting
| Opt_WarnIsError -- -Werror; makes warnings fatal
| Opt_WarnDuplicateExports
| Opt_WarnUnusedImports
| Opt_WarnUnusedMatches
| Opt_WarnDeprecations
- | Opt_WarnMisc
+ | Opt_WarnDodgyImports
-- language opts
| Opt_AllowOverlappingInstances
| Opt_GlasgowExts
| Opt_FFI
| Opt_PArr -- syntactic support for parallel arrays
- | Opt_With -- deprecated keyword for implicit parms
+ | Opt_Arrows -- Arrow-notation syntax
+ | Opt_TH
+ | Opt_ImplicitParams
| Opt_Generics
| Opt_NoImplicitPrelude
+ -- optimisation opts
+ | Opt_Strictness
+ | Opt_FullLaziness
+ | Opt_CSE
+ | Opt_IgnoreInterfacePragmas
+ | Opt_OmitInterfacePragmas
+ | Opt_DoLambdaEtaExpansion
+ | Opt_IgnoreAsserts
+ | Opt_DoEtaReduction
+ | Opt_CaseMerge
+ | Opt_UnboxStrictFields
+
deriving (Eq)
data DynFlags = DynFlags {
- coreToDo :: [CoreToDo],
+ coreToDo :: Maybe [CoreToDo], -- reserved for use with -Ofile
stgToDo :: [StgToDo],
hscLang :: HscLang,
hscOutName :: String, -- name of the output file
hscStubCOutName :: String, -- name of the .stub_c output file
extCoreName :: String, -- name of the .core output file
verbosity :: Int, -- verbosity level
+ optLevel :: Int, -- optimisation level
+ maxSimplIterations :: Int, -- max simplifier iterations
+ ruleCheck :: Maybe String,
cppFlag :: Bool, -- preprocess with cpp?
ppFlag :: Bool, -- preprocess with a Haskell Pp?
stolen_x86_regs :: Int,
defaultHscLang
| cGhcWithNativeCodeGen == "YES" &&
(prefixMatch "i386" cTARGETPLATFORM ||
- prefixMatch "sparc" cTARGETPLATFORM) = HscAsm
+ prefixMatch "sparc" cTARGETPLATFORM ||
+ prefixMatch "powerpc" cTARGETPLATFORM) = HscAsm
| otherwise = HscC
defaultDynFlags = DynFlags {
- coreToDo = [], stgToDo = [],
+ coreToDo = Nothing, stgToDo = [],
hscLang = defaultHscLang,
hscOutName = "",
hscStubHOutName = "", hscStubCOutName = "",
extCoreName = "",
- verbosity = 0,
+ verbosity = 0,
+ optLevel = 0,
+ maxSimplIterations = 4,
+ ruleCheck = Nothing,
cppFlag = False,
ppFlag = False,
stolen_x86_regs = 4,
opt_I = [],
opt_i = [],
#endif
- flags = [Opt_Generics] ++ standardWarnings,
- -- Generating the helper-functions for
- -- generics is now on by default
+ flags = [
+ Opt_Generics,
+ -- Generating the helper-functions for
+ -- generics is now on by default
+ Opt_Strictness,
+ -- strictness is on by default, but this only
+ -- applies to -O.
+ Opt_CSE, -- similarly for CSE.
+ Opt_FullLaziness, -- ...and for full laziness
+
+ Opt_DoLambdaEtaExpansion,
+ -- This one is important for a tiresome reason:
+ -- we want to make sure that the bindings for data
+ -- constructors are eta-expanded. This is probably
+ -- a good thing anyway, but it seems fragile.
+
+ -- and the default no-optimisation options:
+ Opt_IgnoreInterfacePragmas,
+ Opt_OmitInterfacePragmas
+
+ ] ++ standardWarnings
}
{-
dopt :: DynFlag -> DynFlags -> Bool
dopt f dflags = f `elem` (flags dflags)
-dopt_CoreToDo :: DynFlags -> [CoreToDo]
+dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
dopt_CoreToDo = coreToDo
dopt_StgToDo :: DynFlags -> [StgToDo]
getVerbFlag = do
verb <- dynFlag verbosity
if verb >= 3 then return "-v" else return ""
-\end{code}
-----------------------------------------------------------------------------
+-- Setting the optimisation level
+
+setOptLevel :: Int -> IO ()
+setOptLevel n
+ = do dflags <- getDynFlags
+ if hscLang dflags == HscInterpreted && n > 0
+ then putStr "warning: -O conflicts with --interactive; -O ignored.\n"
+ else updDynFlags (setOptLevel' n)
+
+setOptLevel' n dfs
+ = if (n >= 1)
+ then dfs2{ hscLang = HscC, optLevel = n } -- turn on -fvia-C with -O
+ else dfs2{ optLevel = n }
+ where
+ dfs1 = foldr (flip dopt_unset) dfs remove_dopts
+ dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
+
+ extra_dopts
+ | n == 0 = opt_0_dopts
+ | otherwise = opt_1_dopts
+
+ remove_dopts
+ | n == 0 = opt_1_dopts
+ | otherwise = opt_0_dopts
+
+opt_0_dopts = [
+ Opt_IgnoreInterfacePragmas,
+ Opt_OmitInterfacePragmas
+ ]
+
+opt_1_dopts = [
+ Opt_IgnoreAsserts,
+ Opt_DoEtaReduction,
+ Opt_CaseMerge
+ ]
+
+-- Core-to-core phases:
+
+buildCoreToDo :: DynFlags -> [CoreToDo]
+buildCoreToDo dflags = core_todo
+ where
+ opt_level = optLevel dflags
+ max_iter = maxSimplIterations dflags
+ strictness = dopt Opt_Strictness dflags
+ full_laziness = dopt Opt_FullLaziness dflags
+ cse = dopt Opt_CSE dflags
+ rule_check = ruleCheck dflags
+
+ core_todo =
+ if opt_level == 0 then
+ [
+ CoreDoSimplify (SimplPhase 0) [
+ MaxSimplifierIterations max_iter
+ ]
+ ]
+
+ else {- opt_level >= 1 -} [
+
+ -- initial simplify: mk specialiser happy: minimum effort please
+ CoreDoSimplify SimplGently [
+ -- Simplify "gently"
+ -- 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
+ -- Similarly, don't apply any rules until after full
+ -- laziness. Notably, list fusion can prevent floating.
+
+ NoCaseOfCase,
+ -- Don't do case-of-case transformations.
+ -- This makes full laziness work better
+ MaxSimplifierIterations max_iter
+ ],
+
+ -- Specialisation is best done before full laziness
+ -- so that overloaded functions have all their dictionary lambdas manifest
+ CoreDoSpecialising,
+
+ if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
+ else CoreDoNothing,
+
+ CoreDoFloatInwards,
+
+ CoreDoSimplify (SimplPhase 2) [
+ -- Want to run with inline phase 2 after the specialiser to give
+ -- maximum chance for fusion to work before we inline build/augment
+ -- in phase 1. This made a difference in 'ansi' where an
+ -- overloaded function wasn't inlined till too late.
+ MaxSimplifierIterations max_iter
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
+
+ CoreDoSimplify (SimplPhase 1) [
+ -- 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
+ MaxSimplifierIterations max_iter
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
+
+ CoreDoSimplify (SimplPhase 0) [
+ -- Phase 0: allow all Ids to be inlined now
+ -- This gets foldr inlined before strictness analysis
+
+ MaxSimplifierIterations 3
+ -- At least 3 iterations because otherwise we land up with
+ -- huge dead expressions because of an infelicity in the
+ -- simpifier.
+ -- let k = BIG in foldr k z xs
+ -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
+ -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
+ -- Don't stop now!
+
+ ],
+ case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
+
+#ifdef OLD_STRICTNESS
+ CoreDoOldStrictness
+#endif
+ if strictness then CoreDoStrictness else CoreDoNothing,
+ CoreDoWorkerWrapper,
+ CoreDoGlomBinds,
+
+ CoreDoSimplify (SimplPhase 0) [
+ MaxSimplifierIterations max_iter
+ ],
+
+ if full_laziness then
+ CoreDoFloatOutwards (FloatOutSw False -- Not lambdas
+ True) -- Float constants
+ else CoreDoNothing,
+ -- 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)
+
+
+ -- We want CSE to follow the final full-laziness pass, because it may
+ -- succeed in commoning up things floated out by full laziness.
+ -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
+
+ if cse then CoreCSE else CoreDoNothing,
+
+ CoreDoFloatInwards,
+
+-- Case-liberation for -O2. This should be after
+-- strictness analysis and the simplification which follows it.
+
+ case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
+
+ if opt_level >= 2 then
+ CoreLiberateCase
+ else
+ CoreDoNothing,
+ if opt_level >= 2 then
+ CoreDoSpecConstr
+ else
+ CoreDoNothing,
+
+ -- Final clean-up simplification:
+ CoreDoSimplify (SimplPhase 0) [
+ MaxSimplifierIterations max_iter
+ ]
+ ]
+
+-- --------------------------------------------------------------------------
-- Mess about with the mutable variables holding the dynamic arguments
-- v_InitDynFlags
-- to the value of v_InitDynFlags before each compilation, then
-- updated by reading any OPTIONS pragma in the current module.
-\begin{code}
GLOBAL_VAR(v_InitDynFlags, defaultDynFlags, DynFlags)
GLOBAL_VAR(v_DynFlags, defaultDynFlags, DynFlags)
Opt_WarnUnusedMatches,
Opt_WarnUnusedImports,
Opt_WarnIncompletePatterns,
- Opt_WarnMisc
+ Opt_WarnDodgyImports
]
minusWallOpts
lookUp sw = sw `elem` packed_static_opts
-lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
+-- (lookup_str "foo") looks for the flag -foo=X or -fooX,
+-- and returns the string X
+lookup_str sw
+ = case firstJust (map (startsWith sw) unpacked_static_opts) of
+ Just ('=' : str) -> Just str
+ Just str -> Just str
+ Nothing -> Nothing
lookup_int sw = case (lookup_str sw) of
Nothing -> Nothing
- Just xx -> Just (read xx)
+ Just xx -> Just (try_read sw xx)
lookup_def_int sw def = case (lookup_str sw) of
Nothing -> def -- Use default
- Just xx -> read xx
+ Just xx -> try_read sw xx
lookup_def_float sw def = case (lookup_str sw) of
Nothing -> def -- Use default
- Just xx -> read xx
+ Just xx -> try_read sw xx
+
+
+try_read :: Read a => String -> String -> a
+-- (try_read sw str) tries to read s; if it fails, it
+-- bleats about flag sw
+try_read sw str
+ = case reads str of
+ ((x,_):_) -> x -- Be forgiving: ignore trailing goop, and alternative parses
+ [] -> ghcError (UsageError ("Malformed argument " ++ str ++ " for flag " ++ sw))
+ -- ToDo: hack alert. We should really parse the arugments
+ -- and announce errors in a more civilised way.
{-
\begin{code}
-- debugging opts
-opt_PprStyle_NoPrags = lookUp FSLIT("-dppr-noprags")
opt_PprStyle_Debug = lookUp FSLIT("-dppr-debug")
-opt_PprStyle_RawTypes = lookUp FSLIT("-dppr-rawtypes")
opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
-- profiling opts
opt_AutoSccsOnAllToplevs = lookUp FSLIT("-fauto-sccs-on-all-toplevs")
opt_AutoSccsOnExportedToplevs = lookUp FSLIT("-fauto-sccs-on-exported-toplevs")
opt_AutoSccsOnIndividualCafs = lookUp FSLIT("-fauto-sccs-on-individual-cafs")
-opt_AutoSccsOnDicts = lookUp FSLIT("-fauto-sccs-on-dicts")
opt_SccProfilingOn = lookUp FSLIT("-fscc-profiling")
opt_DoTickyProfiling = lookUp FSLIT("-fticky-ticky")
opt_DictsStrict = lookUp FSLIT("-fdicts-strict")
opt_IrrefutableTuples = lookUp FSLIT("-firrefutable-tuples")
opt_MaxContextReductionDepth = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
-opt_NumbersStrict = lookUp FSLIT("-fnumbers-strict")
opt_Parallel = lookUp FSLIT("-fparallel")
opt_SMP = lookUp FSLIT("-fsmp")
opt_Flatten = lookUp FSLIT("-fflatten")
-- optimisation opts
+opt_NoStateHack = lookUp FSLIT("-fno-state-hack")
opt_NoMethodSharing = lookUp FSLIT("-fno-method-sharing")
-opt_DoSemiTagging = lookUp FSLIT("-fsemi-tagging")
-opt_FoldrBuildOn = lookUp FSLIT("-ffoldr-build-on")
opt_CprOff = lookUp FSLIT("-fcpr-off")
+opt_RulesOff = lookUp FSLIT("-frules-off")
-- Switch off CPR analysis in the new demand analyser
opt_LiberateCaseThreshold = lookup_def_int "-fliberate-case-threshold" (10::Int)
-opt_StgDoLetNoEscapes = lookUp FSLIT("-flet-no-escape")
-opt_UnfoldCasms = lookUp FSLIT("-funfold-casms-in-hi-file")
-opt_UsageSPOn = lookUp FSLIT("-fusagesp-on")
-opt_UnboxStrictFields = lookUp FSLIT("-funbox-strict-fields")
opt_MaxWorkerArgs = lookup_def_int "-fmax-worker-args" (10::Int)
{-
opt_GranMacros = lookUp FSLIT("-fgransim")
opt_HiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
opt_HistorySize = lookup_def_int "-fhistory-size" 20
-opt_IgnoreAsserts = lookUp FSLIT("-fignore-asserts")
-opt_IgnoreIfacePragmas = lookUp FSLIT("-fignore-interface-pragmas")
-opt_NoHiCheck = lookUp FSLIT("-fno-hi-version-check")
opt_OmitBlackHoling = lookUp FSLIT("-dno-black-holing")
-opt_OmitInterfacePragmas = lookUp FSLIT("-fomit-interface-pragmas")
opt_RuntimeTypes = lookUp FSLIT("-fruntime-types")
-- Simplifier switches
opt_SimplNoPreInlining = lookUp FSLIT("-fno-pre-inlining")
-- NoPreInlining is there just to see how bad things
-- get if you don't do it!
-opt_SimplDoEtaReduction = lookUp FSLIT("-fdo-eta-reduction")
-opt_SimplDoLambdaEtaExpansion = lookUp FSLIT("-fdo-lambda-eta-expansion")
-opt_SimplCaseMerge = lookUp FSLIT("-fcase-merge")
opt_SimplExcessPrecision = lookUp FSLIT("-fexcess-precision")
-- Unfolding control
opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
opt_UF_UpdateInPlace = lookUp FSLIT("-funfolding-update-in-place")
-opt_UF_CheapOp = ( 1 :: Int) -- Only one instruction; and the args are charged for
opt_UF_DearOp = ( 4 :: Int)
-opt_NoPruneDecls = lookUp FSLIT("-fno-prune-decls")
-opt_NoPruneTyDecls = lookUp FSLIT("-fno-prune-tydecls")
opt_Static = lookUp FSLIT("-static")
opt_Unregisterised = lookUp FSLIT("-funregisterised")
opt_EmitExternalCore = lookUp FSLIT("-fext-core")
+
+-- Include full span info in error messages, instead of just the start position.
+opt_ErrorSpans = lookUp FSLIT("-ferror-spans")
+
+opt_PIC = lookUp FSLIT("-fPIC")
\end{code}
%************************************************************************
"fall-strict",
"fdicts-strict",
"firrefutable-tuples",
- "fnumbers-strict",
"fparallel",
"fsmp",
"fflatten",
"fsemi-tagging",
- "ffoldr-build-on",
"flet-no-escape",
- "funfold-casms-in-hi-file",
- "fusagesp-on",
- "funbox-strict-fields",
"femit-extern-decls",
"fglobalise-toplev-names",
"fgransim",
- "fignore-asserts",
- "fignore-interface-pragmas",
"fno-hi-version-check",
"dno-black-holing",
"fno-method-sharing",
- "fomit-interface-pragmas",
+ "fno-state-hack",
"fruntime-types",
"fno-pre-inlining",
- "fdo-eta-reduction",
- "fdo-lambda-eta-expansion",
- "fcase-merge",
"fexcess-precision",
"funfolding-update-in-place",
- "fno-prune-decls",
- "fno-prune-tydecls",
"static",
"funregisterised",
"fext-core",
"frule-check",
- "fcpr-off"
+ "frules-off",
+ "fcpr-off",
+ "ferror-spans",
+ "fPIC"
]
|| any (flip prefixMatch f) [
"fcontext-stack",