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 dopt, -- DynFlag -> DynFlags -> Bool
24 dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
25 dopt_CoreToDo, -- DynFlags -> [CoreToDo]
26 dopt_StgToDo, -- DynFlags -> [StgToDo]
27 dopt_HscLang, -- DynFlags -> HscLang
28 dopt_OutName, -- DynFlags -> String
29 getOpts, -- (DynFlags -> [a]) -> IO [a]
34 -- Manipulating the DynFlags state
35 getDynFlags, -- IO DynFlags
36 setDynFlags, -- DynFlags -> IO ()
37 updDynFlags, -- (DynFlags -> DynFlags) -> IO ()
38 dynFlag, -- (DynFlags -> a) -> IO a
39 setDynFlag, unSetDynFlag, -- DynFlag -> IO ()
40 saveDynFlags, -- IO ()
41 restoreDynFlags, -- IO DynFlags
43 -- sets of warning opts
47 -- Output style options
52 opt_AutoSccsOnAllToplevs,
53 opt_AutoSccsOnExportedToplevs,
54 opt_AutoSccsOnIndividualCafs,
60 opt_MaxContextReductionDepth,
61 opt_IrrefutableTuples,
70 opt_LiberateCaseThreshold,
73 opt_SimplNoPreInlining,
74 opt_SimplExcessPrecision,
78 opt_UF_CreationThreshold,
80 opt_UF_FunAppDiscount,
89 opt_EnsureSplittableC,
99 #include "HsVersions.h"
101 import Constants -- Default values for some flags
103 import FastString ( FastString, mkFastString )
105 import Maybes ( firstJust )
108 import DATA_IOREF ( IORef, readIORef, writeIORef )
109 import UNSAFE_IO ( unsafePerformIO )
112 %************************************************************************
114 \subsection{Command-line options}
116 %************************************************************************
118 The hsc command-line options are split into two categories:
123 Static flags are represented by top-level values of type Bool or Int,
124 for example. They therefore have the same value throughout the
127 Dynamic flags are represented by an abstract type, DynFlags, which is
128 passed into hsc by the compilation manager for every compilation.
129 Dynamic flags are those that change on a per-compilation basis,
130 perhaps because they may be present in the OPTIONS pragma at the top
133 Other flag-related blurb:
135 A list of {\em ToDo}s is things to be done in a particular part of
136 processing. A (fictitious) example for the Core-to-Core simplifier
137 might be: run the simplifier, then run the strictness analyser, then
138 run the simplifier again (three ``todos'').
140 There are three ``to-do processing centers'' at the moment. In the
141 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
142 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
143 (\tr{simplStg/SimplStg.lhs}).
145 %************************************************************************
147 \subsection{Datatypes associated with command-line options}
149 %************************************************************************
152 data CoreToDo -- These are diff core-to-core passes,
153 -- which may be invoked in any order,
154 -- as many times as you like.
156 = CoreDoSimplify -- The core-to-core simplifier.
159 -- Each run of the simplifier can take a different
160 -- set of simplifier-specific flags.
162 | CoreDoFloatOutwards FloatOutSwitches
167 | CoreDoWorkerWrapper
170 | CoreDoOldStrictness
173 | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
174 -- matching this string
176 | CoreDoNothing -- useful when building up lists of these things
181 = StgDoMassageForProfiling -- should be (next to) last
182 -- There's also setStgVarInfo, but its absolute "lastness"
183 -- is so critical that it is hardwired in (no flag).
188 data SimplifierMode -- See comments in SimplMonad
192 data SimplifierSwitch
193 = MaxSimplifierIterations Int
196 data FloatOutSwitches
197 = FloatOutSw Bool -- True <=> float lambdas to top level
198 Bool -- True <=> float constants to top level,
199 -- even if they do not escape a lambda
202 %************************************************************************
204 \subsection{Dynamic command-line options}
206 %************************************************************************
219 | Opt_D_dump_inlinings
220 | Opt_D_dump_occur_anal
225 | Opt_D_dump_simpl_iterations
234 | Opt_D_dump_worker_wrapper
235 | Opt_D_dump_rn_trace
236 | Opt_D_dump_rn_stats
238 | Opt_D_dump_simpl_stats
239 | Opt_D_dump_tc_trace
240 | Opt_D_dump_if_trace
245 | Opt_D_verbose_core2core
246 | Opt_D_verbose_stg2stg
248 | Opt_D_dump_hi_diffs
249 | Opt_D_dump_minimal_imports
253 | Opt_WarnIsError -- -Werror; makes warnings fatal
254 | Opt_WarnDuplicateExports
256 | Opt_WarnIncompletePatterns
257 | Opt_WarnMissingFields
258 | Opt_WarnMissingMethods
259 | Opt_WarnMissingSigs
260 | Opt_WarnNameShadowing
261 | Opt_WarnOverlappingPatterns
262 | Opt_WarnSimplePatterns
263 | Opt_WarnTypeDefaults
264 | Opt_WarnUnusedBinds
265 | Opt_WarnUnusedImports
266 | Opt_WarnUnusedMatches
267 | Opt_WarnDeprecations
271 | Opt_AllowOverlappingInstances
272 | Opt_AllowUndecidableInstances
273 | Opt_AllowIncoherentInstances
274 | Opt_NoMonomorphismRestriction
277 | Opt_PArr -- syntactic support for parallel arrays
278 | Opt_Arrows -- Arrow-notation syntax
282 | Opt_NoImplicitPrelude
288 | Opt_IgnoreInterfacePragmas
289 | Opt_OmitInterfacePragmas
290 | Opt_DoLambdaEtaExpansion
294 | Opt_UnboxStrictFields
298 data DynFlags = DynFlags {
299 coreToDo :: Maybe [CoreToDo], -- reserved for use with -Ofile
300 stgToDo :: [StgToDo],
302 hscOutName :: String, -- name of the output file
303 hscStubHOutName :: String, -- name of the .stub_h output file
304 hscStubCOutName :: String, -- name of the .stub_c output file
305 extCoreName :: String, -- name of the .core output file
306 verbosity :: Int, -- verbosity level
307 optLevel :: Int, -- optimisation level
308 maxSimplIterations :: Int, -- max simplifier iterations
309 ruleCheck :: Maybe String,
310 cppFlag :: Bool, -- preprocess with cpp?
311 ppFlag :: Bool, -- preprocess with a Haskell Pp?
312 stolen_x86_regs :: Int,
313 cmdlineHcIncludes :: [String], -- -#includes
315 -- options for particular phases
341 | cGhcWithNativeCodeGen == "YES" &&
342 (prefixMatch "i386" cTARGETPLATFORM ||
343 prefixMatch "sparc" cTARGETPLATFORM ||
344 prefixMatch "powerpc" cTARGETPLATFORM) = HscAsm
347 defaultDynFlags = DynFlags {
348 coreToDo = Nothing, stgToDo = [],
349 hscLang = defaultHscLang,
351 hscStubHOutName = "", hscStubCOutName = "",
355 maxSimplIterations = 4,
360 cmdlineHcIncludes = [],
373 -- Generating the helper-functions for
374 -- generics is now on by default
376 -- strictness is on by default, but this only
378 Opt_CSE, -- similarly for CSE.
379 Opt_FullLaziness, -- ...and for full laziness
381 Opt_DoLambdaEtaExpansion,
382 -- This one is important for a tiresome reason:
383 -- we want to make sure that the bindings for data
384 -- constructors are eta-expanded. This is probably
385 -- a good thing anyway, but it seems fragile.
387 -- and the default no-optimisation options:
388 Opt_IgnoreInterfacePragmas,
389 Opt_OmitInterfacePragmas
391 ] ++ standardWarnings
397 0 | print errors & warnings only
398 1 | minimal verbosity: print "compiling M ... done." for each module.
399 2 | equivalent to -dshow-passes
400 3 | equivalent to existing "ghc -v"
401 4 | "ghc -v -ddump-most"
402 5 | "ghc -v -ddump-all"
405 dopt :: DynFlag -> DynFlags -> Bool
406 dopt f dflags = f `elem` (flags dflags)
408 dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
409 dopt_CoreToDo = coreToDo
411 dopt_StgToDo :: DynFlags -> [StgToDo]
412 dopt_StgToDo = stgToDo
414 dopt_OutName :: DynFlags -> String
415 dopt_OutName = hscOutName
417 dopt_HscLang :: DynFlags -> HscLang
418 dopt_HscLang = hscLang
420 dopt_set :: DynFlags -> DynFlag -> DynFlags
421 dopt_set dfs f = dfs{ flags = f : flags dfs }
423 dopt_unset :: DynFlags -> DynFlag -> DynFlags
424 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
426 getOpts :: (DynFlags -> [a]) -> IO [a]
427 -- We add to the options from the front, so we need to reverse the list
428 getOpts opts = dynFlag opts >>= return . reverse
430 -- we can only switch between HscC, HscAsmm, and HscILX with dynamic flags
431 -- (-fvia-C, -fasm, -filx respectively).
432 setLang l = updDynFlags (\ dfs -> case hscLang dfs of
433 HscC -> dfs{ hscLang = l }
434 HscAsm -> dfs{ hscLang = l }
435 HscILX -> dfs{ hscLang = l }
439 verb <- dynFlag verbosity
440 if verb >= 3 then return "-v" else return ""
442 -----------------------------------------------------------------------------
443 -- Setting the optimisation level
445 setOptLevel :: Int -> IO ()
447 = do dflags <- getDynFlags
448 if hscLang dflags == HscInterpreted && n > 0
449 then putStr "warning: -O conflicts with --interactive; -O ignored.\n"
450 else updDynFlags (setOptLevel' n)
454 then dfs2{ hscLang = HscC, optLevel = n } -- turn on -fvia-C with -O
455 else dfs2{ optLevel = n }
457 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
458 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
461 | n == 0 = opt_0_dopts
462 | otherwise = opt_1_dopts
465 | n == 0 = opt_1_dopts
466 | otherwise = opt_0_dopts
469 Opt_IgnoreInterfacePragmas,
470 Opt_OmitInterfacePragmas
479 -- Core-to-core phases:
481 buildCoreToDo :: DynFlags -> [CoreToDo]
482 buildCoreToDo dflags = core_todo
484 opt_level = optLevel dflags
485 max_iter = maxSimplIterations dflags
486 strictness = dopt Opt_Strictness dflags
487 full_laziness = dopt Opt_FullLaziness dflags
488 cse = dopt Opt_CSE dflags
489 rule_check = ruleCheck dflags
492 if opt_level == 0 then
494 CoreDoSimplify (SimplPhase 0) [
495 MaxSimplifierIterations max_iter
499 else {- opt_level >= 1 -} [
501 -- initial simplify: mk specialiser happy: minimum effort please
502 CoreDoSimplify SimplGently [
504 -- Don't inline anything till full laziness has bitten
505 -- In particular, inlining wrappers inhibits floating
506 -- e.g. ...(case f x of ...)...
507 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
508 -- ==> ...(case x of I# x# -> case fw x# of ...)...
509 -- and now the redex (f x) isn't floatable any more
510 -- Similarly, don't apply any rules until after full
511 -- laziness. Notably, list fusion can prevent floating.
514 -- Don't do case-of-case transformations.
515 -- This makes full laziness work better
516 MaxSimplifierIterations max_iter
519 -- Specialisation is best done before full laziness
520 -- so that overloaded functions have all their dictionary lambdas manifest
523 if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
528 CoreDoSimplify (SimplPhase 2) [
529 -- Want to run with inline phase 2 after the specialiser to give
530 -- maximum chance for fusion to work before we inline build/augment
531 -- in phase 1. This made a difference in 'ansi' where an
532 -- overloaded function wasn't inlined till too late.
533 MaxSimplifierIterations max_iter
535 case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
537 CoreDoSimplify (SimplPhase 1) [
538 -- Need inline-phase2 here so that build/augment get
539 -- inlined. I found that spectral/hartel/genfft lost some useful
540 -- strictness in the function sumcode' if augment is not inlined
541 -- before strictness analysis runs
542 MaxSimplifierIterations max_iter
544 case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
546 CoreDoSimplify (SimplPhase 0) [
547 -- Phase 0: allow all Ids to be inlined now
548 -- This gets foldr inlined before strictness analysis
550 MaxSimplifierIterations 3
551 -- At least 3 iterations because otherwise we land up with
552 -- huge dead expressions because of an infelicity in the
554 -- let k = BIG in foldr k z xs
555 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
556 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
560 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
562 #ifdef OLD_STRICTNESS
565 if strictness then CoreDoStrictness else CoreDoNothing,
569 CoreDoSimplify (SimplPhase 0) [
570 MaxSimplifierIterations max_iter
573 if full_laziness then
574 CoreDoFloatOutwards (FloatOutSw False -- Not lambdas
575 True) -- Float constants
577 -- nofib/spectral/hartel/wang doubles in speed if you
578 -- do full laziness late in the day. It only happens
579 -- after fusion and other stuff, so the early pass doesn't
580 -- catch it. For the record, the redex is
581 -- f_el22 (f_el21 r_midblock)
584 -- We want CSE to follow the final full-laziness pass, because it may
585 -- succeed in commoning up things floated out by full laziness.
586 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
588 if cse then CoreCSE else CoreDoNothing,
592 -- Case-liberation for -O2. This should be after
593 -- strictness analysis and the simplification which follows it.
595 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
597 if opt_level >= 2 then
601 if opt_level >= 2 then
606 -- Final clean-up simplification:
607 CoreDoSimplify (SimplPhase 0) [
608 MaxSimplifierIterations max_iter
612 -- --------------------------------------------------------------------------
613 -- Mess about with the mutable variables holding the dynamic arguments
616 -- is the "baseline" dynamic flags, initialised from
617 -- the defaults and command line options, and updated by the
618 -- ':s' command in GHCi.
621 -- is the dynamic flags for the current compilation. It is reset
622 -- to the value of v_InitDynFlags before each compilation, then
623 -- updated by reading any OPTIONS pragma in the current module.
625 GLOBAL_VAR(v_InitDynFlags, defaultDynFlags, DynFlags)
626 GLOBAL_VAR(v_DynFlags, defaultDynFlags, DynFlags)
628 setDynFlags :: DynFlags -> IO ()
629 setDynFlags dfs = writeIORef v_DynFlags dfs
631 saveDynFlags :: IO ()
632 saveDynFlags = do dfs <- readIORef v_DynFlags
633 writeIORef v_InitDynFlags dfs
635 restoreDynFlags :: IO DynFlags
636 restoreDynFlags = do dfs <- readIORef v_InitDynFlags
637 writeIORef v_DynFlags dfs
640 getDynFlags :: IO DynFlags
641 getDynFlags = readIORef v_DynFlags
643 updDynFlags :: (DynFlags -> DynFlags) -> IO ()
644 updDynFlags f = do dfs <- readIORef v_DynFlags
645 writeIORef v_DynFlags (f dfs)
647 dynFlag :: (DynFlags -> a) -> IO a
648 dynFlag f = do dflags <- readIORef v_DynFlags; return (f dflags)
650 setDynFlag, unSetDynFlag :: DynFlag -> IO ()
651 setDynFlag f = updDynFlags (\dfs -> dopt_set dfs f)
652 unSetDynFlag f = updDynFlags (\dfs -> dopt_unset dfs f)
656 %************************************************************************
658 \subsection{Warnings}
660 %************************************************************************
664 = [ Opt_WarnDeprecations,
665 Opt_WarnOverlappingPatterns,
666 Opt_WarnMissingFields,
667 Opt_WarnMissingMethods,
668 Opt_WarnDuplicateExports
672 = standardWarnings ++
673 [ Opt_WarnUnusedBinds,
674 Opt_WarnUnusedMatches,
675 Opt_WarnUnusedImports,
676 Opt_WarnIncompletePatterns,
682 [ Opt_WarnTypeDefaults,
683 Opt_WarnNameShadowing,
689 %************************************************************************
691 \subsection{Classifying command-line options}
693 %************************************************************************
696 -- v_Statis_hsc_opts is here to avoid a circular dependency with
698 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
700 lookUp :: FastString -> Bool
701 lookup_int :: String -> Maybe Int
702 lookup_def_int :: String -> Int -> Int
703 lookup_def_float :: String -> Float -> Float
704 lookup_str :: String -> Maybe String
706 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
707 packed_static_opts = map mkFastString unpacked_static_opts
709 lookUp sw = sw `elem` packed_static_opts
711 lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
713 lookup_int sw = case (lookup_str sw) of
715 Just xx -> Just (read xx)
717 lookup_def_int sw def = case (lookup_str sw) of
718 Nothing -> def -- Use default
721 lookup_def_float sw def = case (lookup_str sw) of
722 Nothing -> def -- Use default
727 Putting the compiler options into temporary at-files
728 may turn out to be necessary later on if we turn hsc into
729 a pure Win32 application where I think there's a command-line
730 length limit of 255. unpacked_opts understands the @ option.
732 unpacked_opts :: [String]
736 map unpackFS argv -- NOT ARGV any more: v_Static_hsc_opts
738 expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
743 %************************************************************************
745 \subsection{Static options}
747 %************************************************************************
751 opt_PprStyle_Debug = lookUp FSLIT("-dppr-debug")
752 opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
755 opt_AutoSccsOnAllToplevs = lookUp FSLIT("-fauto-sccs-on-all-toplevs")
756 opt_AutoSccsOnExportedToplevs = lookUp FSLIT("-fauto-sccs-on-exported-toplevs")
757 opt_AutoSccsOnIndividualCafs = lookUp FSLIT("-fauto-sccs-on-individual-cafs")
758 opt_SccProfilingOn = lookUp FSLIT("-fscc-profiling")
759 opt_DoTickyProfiling = lookUp FSLIT("-fticky-ticky")
762 opt_AllStrict = lookUp FSLIT("-fall-strict")
763 opt_DictsStrict = lookUp FSLIT("-fdicts-strict")
764 opt_IrrefutableTuples = lookUp FSLIT("-firrefutable-tuples")
765 opt_MaxContextReductionDepth = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
766 opt_Parallel = lookUp FSLIT("-fparallel")
767 opt_SMP = lookUp FSLIT("-fsmp")
768 opt_Flatten = lookUp FSLIT("-fflatten")
771 opt_NoStateHack = lookUp FSLIT("-fno-state-hack")
772 opt_NoMethodSharing = lookUp FSLIT("-fno-method-sharing")
773 opt_CprOff = lookUp FSLIT("-fcpr-off")
774 opt_RulesOff = lookUp FSLIT("-frules-off")
775 -- Switch off CPR analysis in the new demand analyser
776 opt_LiberateCaseThreshold = lookup_def_int "-fliberate-case-threshold" (10::Int)
777 opt_MaxWorkerArgs = lookup_def_int "-fmax-worker-args" (10::Int)
780 The optional '-inpackage=P' flag tells what package
781 we are compiling this module for.
782 The Prelude, for example is compiled with '-inpackage std'
784 opt_InPackage = case lookup_str "-inpackage=" of
785 Just p -> mkFastString p
786 Nothing -> FSLIT("Main") -- The package name if none is specified
788 opt_EmitCExternDecls = lookUp FSLIT("-femit-extern-decls")
789 opt_EnsureSplittableC = lookUp FSLIT("-fglobalise-toplev-names")
790 opt_GranMacros = lookUp FSLIT("-fgransim")
791 opt_HiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
792 opt_HistorySize = lookup_def_int "-fhistory-size" 20
793 opt_OmitBlackHoling = lookUp FSLIT("-dno-black-holing")
794 opt_RuntimeTypes = lookUp FSLIT("-fruntime-types")
796 -- Simplifier switches
797 opt_SimplNoPreInlining = lookUp FSLIT("-fno-pre-inlining")
798 -- NoPreInlining is there just to see how bad things
799 -- get if you don't do it!
800 opt_SimplExcessPrecision = lookUp FSLIT("-fexcess-precision")
803 opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (45::Int)
804 opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (8::Int) -- Discounts can be big
805 opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (6::Int) -- It's great to inline a fn
806 opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
807 opt_UF_UpdateInPlace = lookUp FSLIT("-funfolding-update-in-place")
809 opt_UF_DearOp = ( 4 :: Int)
811 opt_Static = lookUp FSLIT("-static")
812 opt_Unregisterised = lookUp FSLIT("-funregisterised")
813 opt_EmitExternalCore = lookUp FSLIT("-fext-core")
815 -- Include full span info in error messages, instead of just the start position.
816 opt_ErrorSpans = lookUp FSLIT("-ferror-spans")
819 %************************************************************************
821 \subsection{List of static hsc flags}
823 %************************************************************************
828 "fauto-sccs-on-all-toplevs",
829 "fauto-sccs-on-exported-toplevs",
830 "fauto-sccs-on-individual-cafs",
831 "fauto-sccs-on-dicts",
836 "firrefutable-tuples",
842 "femit-extern-decls",
843 "fglobalise-toplev-names",
845 "fno-hi-version-check",
847 "fno-method-sharing",
852 "funfolding-update-in-place",
861 || any (flip prefixMatch f) [
863 "fliberate-case-threshold",
866 "funfolding-creation-threshold",
867 "funfolding-use-threshold",
868 "funfolding-fun-discount",
869 "funfolding-keeness-factor"
873 %************************************************************************
875 \subsection{Misc functions for command-line options}
877 %************************************************************************
882 startsWith :: String -> String -> Maybe String
883 -- startsWith pfx (pfx++rest) = Just rest
885 startsWith [] str = Just str
886 startsWith (c:cs) (s:ss)
887 = if c /= s then Nothing else startsWith cs ss
888 startsWith _ [] = Nothing
890 endsWith :: String -> String -> Maybe String
892 = case (startsWith (reverse cs) (reverse ss)) of
894 Just rs -> Just (reverse rs)