2 % (c) The University of Glasgow, 1996-2000
4 \section[CmdLineOpts]{Things to do with command-line options}
9 CoreToDo(..), buildCoreToDo, StgToDo(..),
11 SimplifierMode(..), FloatOutSwitches(..),
14 DynFlag(..), -- needed non-abstractly by DriverFlags
21 -- Manipulating DynFlags
22 defaultDynFlags, -- DynFlags
23 defaultHscLang, -- HscLang
24 dopt, -- DynFlag -> DynFlags -> Bool
25 dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
26 dopt_CoreToDo, -- DynFlags -> [CoreToDo]
27 dopt_StgToDo, -- DynFlags -> [StgToDo]
28 dopt_HscLang, -- DynFlags -> HscLang
29 dopt_OutName, -- DynFlags -> String
30 getOpts, -- (DynFlags -> [a]) -> IO [a]
35 -- Manipulating the DynFlags state
36 getDynFlags, -- IO DynFlags
37 setDynFlags, -- DynFlags -> IO ()
38 updDynFlags, -- (DynFlags -> DynFlags) -> IO ()
39 dynFlag, -- (DynFlags -> a) -> IO a
40 setDynFlag, unSetDynFlag, -- DynFlag -> IO ()
41 saveDynFlags, -- IO ()
42 restoreDynFlags, -- IO DynFlags
44 -- sets of warning opts
49 -- Output style options
51 opt_PprStyle_RawTypes,
56 opt_AutoSccsOnAllToplevs,
57 opt_AutoSccsOnExportedToplevs,
58 opt_AutoSccsOnIndividualCafs,
66 opt_MaxContextReductionDepth,
67 opt_IrrefutableTuples,
77 opt_LiberateCaseThreshold,
80 opt_SimplNoPreInlining,
81 opt_SimplExcessPrecision,
85 opt_UF_CreationThreshold,
87 opt_UF_FunAppDiscount,
96 opt_EnsureSplittableC,
108 #include "HsVersions.h"
110 import Constants -- Default values for some flags
112 import FastString ( FastString, mkFastString )
114 import Maybes ( firstJust )
117 import DATA_IOREF ( IORef, readIORef, writeIORef )
118 import UNSAFE_IO ( unsafePerformIO )
121 %************************************************************************
123 \subsection{Command-line options}
125 %************************************************************************
127 The hsc command-line options are split into two categories:
132 Static flags are represented by top-level values of type Bool or Int,
133 for example. They therefore have the same value throughout the
136 Dynamic flags are represented by an abstract type, DynFlags, which is
137 passed into hsc by the compilation manager for every compilation.
138 Dynamic flags are those that change on a per-compilation basis,
139 perhaps because they may be present in the OPTIONS pragma at the top
142 Other flag-related blurb:
144 A list of {\em ToDo}s is things to be done in a particular part of
145 processing. A (fictitious) example for the Core-to-Core simplifier
146 might be: run the simplifier, then run the strictness analyser, then
147 run the simplifier again (three ``todos'').
149 There are three ``to-do processing centers'' at the moment. In the
150 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
151 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
152 (\tr{simplStg/SimplStg.lhs}).
154 %************************************************************************
156 \subsection{Datatypes associated with command-line options}
158 %************************************************************************
161 data CoreToDo -- These are diff core-to-core passes,
162 -- which may be invoked in any order,
163 -- as many times as you like.
165 = CoreDoSimplify -- The core-to-core simplifier.
168 -- Each run of the simplifier can take a different
169 -- set of simplifier-specific flags.
171 | CoreDoFloatOutwards FloatOutSwitches
176 | CoreDoWorkerWrapper
179 | CoreDoOldStrictness
182 | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
183 -- matching this string
185 | CoreDoNothing -- useful when building up lists of these things
190 = StgDoMassageForProfiling -- should be (next to) last
191 -- There's also setStgVarInfo, but its absolute "lastness"
192 -- is so critical that it is hardwired in (no flag).
197 data SimplifierMode -- See comments in SimplMonad
201 data SimplifierSwitch
202 = MaxSimplifierIterations Int
205 data FloatOutSwitches
206 = FloatOutSw Bool -- True <=> float lambdas to top level
207 Bool -- True <=> float constants to top level,
208 -- even if they do not escape a lambda
211 %************************************************************************
213 \subsection{Dynamic command-line options}
215 %************************************************************************
228 | Opt_D_dump_inlinings
229 | Opt_D_dump_occur_anal
234 | Opt_D_dump_simpl_iterations
243 | Opt_D_dump_worker_wrapper
244 | Opt_D_dump_rn_trace
245 | Opt_D_dump_rn_stats
247 | Opt_D_dump_simpl_stats
248 | Opt_D_dump_tc_trace
253 | Opt_D_verbose_core2core
254 | Opt_D_verbose_stg2stg
256 | Opt_D_dump_hi_diffs
257 | Opt_D_dump_minimal_imports
261 | Opt_WarnIsError -- -Werror; makes warnings fatal
262 | Opt_WarnDuplicateExports
264 | Opt_WarnIncompletePatterns
265 | Opt_WarnMissingFields
266 | Opt_WarnMissingMethods
267 | Opt_WarnMissingSigs
268 | Opt_WarnNameShadowing
269 | Opt_WarnOverlappingPatterns
270 | Opt_WarnSimplePatterns
271 | Opt_WarnTypeDefaults
272 | Opt_WarnUnusedBinds
273 | Opt_WarnUnusedImports
274 | Opt_WarnUnusedMatches
275 | Opt_WarnDeprecations
279 | Opt_AllowOverlappingInstances
280 | Opt_AllowUndecidableInstances
281 | Opt_AllowIncoherentInstances
282 | Opt_NoMonomorphismRestriction
285 | Opt_PArr -- syntactic support for parallel arrays
286 | Opt_Arrows -- Arrow-notation syntax
290 | Opt_NoImplicitPrelude
295 | Opt_IgnoreInterfacePragmas
296 | Opt_OmitInterfacePragmas
297 | Opt_DoLambdaEtaExpansion
301 | Opt_UnboxStrictFields
305 data DynFlags = DynFlags {
306 coreToDo :: Maybe [CoreToDo], -- reserved for use with -Ofile
307 stgToDo :: [StgToDo],
309 hscOutName :: String, -- name of the output file
310 hscStubHOutName :: String, -- name of the .stub_h output file
311 hscStubCOutName :: String, -- name of the .stub_c output file
312 extCoreName :: String, -- name of the .core output file
313 verbosity :: Int, -- verbosity level
314 optLevel :: Int, -- optimisation level
315 maxSimplIterations :: Int, -- max simplifier iterations
316 ruleCheck :: Maybe String,
317 cppFlag :: Bool, -- preprocess with cpp?
318 ppFlag :: Bool, -- preprocess with a Haskell Pp?
319 stolen_x86_regs :: Int,
320 cmdlineHcIncludes :: [String], -- -#includes
322 -- options for particular phases
348 | cGhcWithNativeCodeGen == "YES" &&
349 (prefixMatch "i386" cTARGETPLATFORM ||
350 prefixMatch "sparc" cTARGETPLATFORM ||
351 prefixMatch "powerpc" cTARGETPLATFORM) = HscAsm
354 defaultDynFlags = DynFlags {
355 coreToDo = Nothing, stgToDo = [],
356 hscLang = defaultHscLang,
358 hscStubHOutName = "", hscStubCOutName = "",
362 maxSimplIterations = 4,
367 cmdlineHcIncludes = [],
380 -- Generating the helper-functions for
381 -- generics is now on by default
383 -- strictness is on by default, but this only
386 -- similarly for CSE.
387 Opt_DoLambdaEtaExpansion,
388 -- This one is important for a tiresome reason:
389 -- we want to make sure that the bindings for data
390 -- constructors are eta-expanded. This is probably
391 -- a good thing anyway, but it seems fragile.
393 -- and the default no-optimisation options:
394 Opt_IgnoreInterfacePragmas,
395 Opt_OmitInterfacePragmas
397 ] ++ standardWarnings,
403 0 | print errors & warnings only
404 1 | minimal verbosity: print "compiling M ... done." for each module.
405 2 | equivalent to -dshow-passes
406 3 | equivalent to existing "ghc -v"
407 4 | "ghc -v -ddump-most"
408 5 | "ghc -v -ddump-all"
411 dopt :: DynFlag -> DynFlags -> Bool
412 dopt f dflags = f `elem` (flags dflags)
414 dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
415 dopt_CoreToDo = coreToDo
417 dopt_StgToDo :: DynFlags -> [StgToDo]
418 dopt_StgToDo = stgToDo
420 dopt_OutName :: DynFlags -> String
421 dopt_OutName = hscOutName
423 dopt_HscLang :: DynFlags -> HscLang
424 dopt_HscLang = hscLang
426 dopt_set :: DynFlags -> DynFlag -> DynFlags
427 dopt_set dfs f = dfs{ flags = f : flags dfs }
429 dopt_unset :: DynFlags -> DynFlag -> DynFlags
430 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
432 getOpts :: (DynFlags -> [a]) -> IO [a]
433 -- We add to the options from the front, so we need to reverse the list
434 getOpts opts = dynFlag opts >>= return . reverse
436 -- we can only switch between HscC, HscAsmm, and HscILX with dynamic flags
437 -- (-fvia-C, -fasm, -filx respectively).
438 setLang l = updDynFlags (\ dfs -> case hscLang dfs of
439 HscC -> dfs{ hscLang = l }
440 HscAsm -> dfs{ hscLang = l }
441 HscILX -> dfs{ hscLang = l }
445 verb <- dynFlag verbosity
446 if verb >= 3 then return "-v" else return ""
448 -----------------------------------------------------------------------------
449 -- Setting the optimisation level
451 setOptLevel :: Int -> IO ()
453 = do dflags <- getDynFlags
454 if hscLang dflags == HscInterpreted && n > 0
455 then putStr "warning: -O conflicts with --interactive; -O ignored.\n"
456 else updDynFlags (setOptLevel' n)
460 then dfs2{ hscLang = HscC, optLevel = n } -- turn on -fvia-C with -O
461 else dfs2{ optLevel = n }
463 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
464 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
467 | n == 0 = opt_0_dopts
468 | otherwise = opt_1_dopts
471 | n == 0 = opt_1_dopts
472 | otherwise = opt_0_dopts
475 Opt_IgnoreInterfacePragmas,
476 Opt_OmitInterfacePragmas
485 -- Core-to-core phases:
487 buildCoreToDo :: DynFlags -> [CoreToDo]
488 buildCoreToDo dflags = core_todo
490 opt_level = optLevel dflags
491 max_iter = maxSimplIterations dflags
492 strictness = dopt Opt_Strictness dflags
493 cse = dopt Opt_CSE dflags
494 rule_check = ruleCheck dflags
497 if opt_level == 0 then
499 CoreDoSimplify (SimplPhase 0) [
500 MaxSimplifierIterations max_iter
504 else {- opt_level >= 1 -} [
506 -- initial simplify: mk specialiser happy: minimum effort please
507 CoreDoSimplify SimplGently [
509 -- Don't inline anything till full laziness has bitten
510 -- In particular, inlining wrappers inhibits floating
511 -- e.g. ...(case f x of ...)...
512 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
513 -- ==> ...(case x of I# x# -> case fw x# of ...)...
514 -- and now the redex (f x) isn't floatable any more
515 -- Similarly, don't apply any rules until after full
516 -- laziness. Notably, list fusion can prevent floating.
519 -- Don't do case-of-case transformations.
520 -- This makes full laziness work better
521 MaxSimplifierIterations max_iter
524 -- Specialisation is best done before full laziness
525 -- so that overloaded functions have all their dictionary lambdas manifest
528 CoreDoFloatOutwards (FloatOutSw False False),
531 CoreDoSimplify (SimplPhase 2) [
532 -- Want to run with inline phase 2 after the specialiser to give
533 -- maximum chance for fusion to work before we inline build/augment
534 -- in phase 1. This made a difference in 'ansi' where an
535 -- overloaded function wasn't inlined till too late.
536 MaxSimplifierIterations max_iter
538 case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
540 CoreDoSimplify (SimplPhase 1) [
541 -- Need inline-phase2 here so that build/augment get
542 -- inlined. I found that spectral/hartel/genfft lost some useful
543 -- strictness in the function sumcode' if augment is not inlined
544 -- before strictness analysis runs
545 MaxSimplifierIterations max_iter
547 case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
549 CoreDoSimplify (SimplPhase 0) [
550 -- Phase 0: allow all Ids to be inlined now
551 -- This gets foldr inlined before strictness analysis
553 MaxSimplifierIterations 3
554 -- At least 3 iterations because otherwise we land up with
555 -- huge dead expressions because of an infelicity in the
557 -- let k = BIG in foldr k z xs
558 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
559 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
563 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
565 #ifdef OLD_STRICTNESS
568 if strictness then CoreDoStrictness else CoreDoNothing,
572 CoreDoSimplify (SimplPhase 0) [
573 MaxSimplifierIterations max_iter
576 CoreDoFloatOutwards (FloatOutSw False -- Not lambdas
577 True), -- Float constants
578 -- nofib/spectral/hartel/wang doubles in speed if you
579 -- do full laziness late in the day. It only happens
580 -- after fusion and other stuff, so the early pass doesn't
581 -- catch it. For the record, the redex is
582 -- f_el22 (f_el21 r_midblock)
585 -- We want CSE to follow the final full-laziness pass, because it may
586 -- succeed in commoning up things floated out by full laziness.
587 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
589 if cse then CoreCSE else CoreDoNothing,
593 -- Case-liberation for -O2. This should be after
594 -- strictness analysis and the simplification which follows it.
596 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
598 if opt_level >= 2 then
602 if opt_level >= 2 then
607 -- Final clean-up simplification:
608 CoreDoSimplify (SimplPhase 0) [
609 MaxSimplifierIterations max_iter
613 -- --------------------------------------------------------------------------
614 -- Mess about with the mutable variables holding the dynamic arguments
617 -- is the "baseline" dynamic flags, initialised from
618 -- the defaults and command line options, and updated by the
619 -- ':s' command in GHCi.
622 -- is the dynamic flags for the current compilation. It is reset
623 -- to the value of v_InitDynFlags before each compilation, then
624 -- updated by reading any OPTIONS pragma in the current module.
626 GLOBAL_VAR(v_InitDynFlags, defaultDynFlags, DynFlags)
627 GLOBAL_VAR(v_DynFlags, defaultDynFlags, DynFlags)
629 setDynFlags :: DynFlags -> IO ()
630 setDynFlags dfs = writeIORef v_DynFlags dfs
632 saveDynFlags :: IO ()
633 saveDynFlags = do dfs <- readIORef v_DynFlags
634 writeIORef v_InitDynFlags dfs
636 restoreDynFlags :: IO DynFlags
637 restoreDynFlags = do dfs <- readIORef v_InitDynFlags
638 writeIORef v_DynFlags dfs
641 getDynFlags :: IO DynFlags
642 getDynFlags = readIORef v_DynFlags
644 updDynFlags :: (DynFlags -> DynFlags) -> IO ()
645 updDynFlags f = do dfs <- readIORef v_DynFlags
646 writeIORef v_DynFlags (f dfs)
648 dynFlag :: (DynFlags -> a) -> IO a
649 dynFlag f = do dflags <- readIORef v_DynFlags; return (f dflags)
651 setDynFlag, unSetDynFlag :: DynFlag -> IO ()
652 setDynFlag f = updDynFlags (\dfs -> dopt_set dfs f)
653 unSetDynFlag f = updDynFlags (\dfs -> dopt_unset dfs f)
657 %************************************************************************
659 \subsection{Warnings}
661 %************************************************************************
665 = [ Opt_WarnDeprecations,
666 Opt_WarnOverlappingPatterns,
667 Opt_WarnMissingFields,
668 Opt_WarnMissingMethods,
669 Opt_WarnDuplicateExports
673 = standardWarnings ++
674 [ Opt_WarnUnusedBinds,
675 Opt_WarnUnusedMatches,
676 Opt_WarnUnusedImports,
677 Opt_WarnIncompletePatterns,
683 [ Opt_WarnTypeDefaults,
684 Opt_WarnNameShadowing,
690 %************************************************************************
692 \subsection{Classifying command-line options}
694 %************************************************************************
697 -- v_Statis_hsc_opts is here to avoid a circular dependency with
699 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
701 lookUp :: FastString -> Bool
702 lookup_int :: String -> Maybe Int
703 lookup_def_int :: String -> Int -> Int
704 lookup_def_float :: String -> Float -> Float
705 lookup_str :: String -> Maybe String
707 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
708 packed_static_opts = map mkFastString unpacked_static_opts
710 lookUp sw = sw `elem` packed_static_opts
712 lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
714 lookup_int sw = case (lookup_str sw) of
716 Just xx -> Just (read xx)
718 lookup_def_int sw def = case (lookup_str sw) of
719 Nothing -> def -- Use default
722 lookup_def_float sw def = case (lookup_str sw) of
723 Nothing -> def -- Use default
728 Putting the compiler options into temporary at-files
729 may turn out to be necessary later on if we turn hsc into
730 a pure Win32 application where I think there's a command-line
731 length limit of 255. unpacked_opts understands the @ option.
733 unpacked_opts :: [String]
737 map unpackFS argv -- NOT ARGV any more: v_Static_hsc_opts
739 expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
744 %************************************************************************
746 \subsection{Static options}
748 %************************************************************************
752 opt_PprStyle_NoPrags = lookUp FSLIT("-dppr-noprags")
753 opt_PprStyle_Debug = lookUp FSLIT("-dppr-debug")
754 opt_PprStyle_RawTypes = lookUp FSLIT("-dppr-rawtypes")
755 opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
758 opt_AutoSccsOnAllToplevs = lookUp FSLIT("-fauto-sccs-on-all-toplevs")
759 opt_AutoSccsOnExportedToplevs = lookUp FSLIT("-fauto-sccs-on-exported-toplevs")
760 opt_AutoSccsOnIndividualCafs = lookUp FSLIT("-fauto-sccs-on-individual-cafs")
761 opt_AutoSccsOnDicts = lookUp FSLIT("-fauto-sccs-on-dicts")
762 opt_SccProfilingOn = lookUp FSLIT("-fscc-profiling")
763 opt_DoTickyProfiling = lookUp FSLIT("-fticky-ticky")
766 opt_AllStrict = lookUp FSLIT("-fall-strict")
767 opt_DictsStrict = lookUp FSLIT("-fdicts-strict")
768 opt_IrrefutableTuples = lookUp FSLIT("-firrefutable-tuples")
769 opt_MaxContextReductionDepth = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
770 opt_NumbersStrict = lookUp FSLIT("-fnumbers-strict")
771 opt_Parallel = lookUp FSLIT("-fparallel")
772 opt_SMP = lookUp FSLIT("-fsmp")
773 opt_Flatten = lookUp FSLIT("-fflatten")
776 opt_NoMethodSharing = lookUp FSLIT("-fno-method-sharing")
777 opt_DoSemiTagging = lookUp FSLIT("-fsemi-tagging")
778 opt_CprOff = lookUp FSLIT("-fcpr-off")
779 opt_RulesOff = lookUp FSLIT("-frules-off")
780 -- Switch off CPR analysis in the new demand analyser
781 opt_LiberateCaseThreshold = lookup_def_int "-fliberate-case-threshold" (10::Int)
782 opt_MaxWorkerArgs = lookup_def_int "-fmax-worker-args" (10::Int)
785 The optional '-inpackage=P' flag tells what package
786 we are compiling this module for.
787 The Prelude, for example is compiled with '-inpackage std'
789 opt_InPackage = case lookup_str "-inpackage=" of
790 Just p -> mkFastString p
791 Nothing -> FSLIT("Main") -- The package name if none is specified
793 opt_EmitCExternDecls = lookUp FSLIT("-femit-extern-decls")
794 opt_EnsureSplittableC = lookUp FSLIT("-fglobalise-toplev-names")
795 opt_GranMacros = lookUp FSLIT("-fgransim")
796 opt_HiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
797 opt_HistorySize = lookup_def_int "-fhistory-size" 20
798 opt_NoHiCheck = lookUp FSLIT("-fno-hi-version-check")
799 opt_OmitBlackHoling = lookUp FSLIT("-dno-black-holing")
800 opt_RuntimeTypes = lookUp FSLIT("-fruntime-types")
802 -- Simplifier switches
803 opt_SimplNoPreInlining = lookUp FSLIT("-fno-pre-inlining")
804 -- NoPreInlining is there just to see how bad things
805 -- get if you don't do it!
806 opt_SimplExcessPrecision = lookUp FSLIT("-fexcess-precision")
809 opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (45::Int)
810 opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (8::Int) -- Discounts can be big
811 opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (6::Int) -- It's great to inline a fn
812 opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
813 opt_UF_UpdateInPlace = lookUp FSLIT("-funfolding-update-in-place")
815 opt_UF_CheapOp = ( 1 :: Int) -- Only one instruction; and the args are charged for
816 opt_UF_DearOp = ( 4 :: Int)
818 opt_NoPruneDecls = lookUp FSLIT("-fno-prune-decls")
819 opt_Static = lookUp FSLIT("-static")
820 opt_Unregisterised = lookUp FSLIT("-funregisterised")
821 opt_EmitExternalCore = lookUp FSLIT("-fext-core")
824 %************************************************************************
826 \subsection{List of static hsc flags}
828 %************************************************************************
833 "fauto-sccs-on-all-toplevs",
834 "fauto-sccs-on-exported-toplevs",
835 "fauto-sccs-on-individual-cafs",
836 "fauto-sccs-on-dicts",
841 "firrefutable-tuples",
848 "femit-extern-decls",
849 "fglobalise-toplev-names",
851 "fno-hi-version-check",
853 "fno-method-sharing",
857 "funfolding-update-in-place",
866 || any (flip prefixMatch f) [
868 "fliberate-case-threshold",
871 "funfolding-creation-threshold",
872 "funfolding-use-threshold",
873 "funfolding-fun-discount",
874 "funfolding-keeness-factor"
878 %************************************************************************
880 \subsection{Misc functions for command-line options}
882 %************************************************************************
887 startsWith :: String -> String -> Maybe String
888 -- startsWith pfx (pfx++rest) = Just rest
890 startsWith [] str = Just str
891 startsWith (c:cs) (s:ss)
892 = if c /= s then Nothing else startsWith cs ss
893 startsWith _ [] = Nothing
895 endsWith :: String -> String -> Maybe String
897 = case (startsWith (reverse cs) (reverse ss)) of
899 Just rs -> Just (reverse rs)