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
249 | Opt_D_dump_if_trace
254 | Opt_D_verbose_core2core
255 | Opt_D_verbose_stg2stg
257 | Opt_D_dump_hi_diffs
258 | Opt_D_dump_minimal_imports
262 | Opt_WarnIsError -- -Werror; makes warnings fatal
263 | Opt_WarnDuplicateExports
265 | Opt_WarnIncompletePatterns
266 | Opt_WarnMissingFields
267 | Opt_WarnMissingMethods
268 | Opt_WarnMissingSigs
269 | Opt_WarnNameShadowing
270 | Opt_WarnOverlappingPatterns
271 | Opt_WarnSimplePatterns
272 | Opt_WarnTypeDefaults
273 | Opt_WarnUnusedBinds
274 | Opt_WarnUnusedImports
275 | Opt_WarnUnusedMatches
276 | Opt_WarnDeprecations
280 | Opt_AllowOverlappingInstances
281 | Opt_AllowUndecidableInstances
282 | Opt_AllowIncoherentInstances
283 | Opt_NoMonomorphismRestriction
286 | Opt_PArr -- syntactic support for parallel arrays
287 | Opt_Arrows -- Arrow-notation syntax
291 | Opt_NoImplicitPrelude
296 | Opt_IgnoreInterfacePragmas
297 | Opt_OmitInterfacePragmas
298 | Opt_DoLambdaEtaExpansion
302 | Opt_UnboxStrictFields
306 data DynFlags = DynFlags {
307 coreToDo :: Maybe [CoreToDo], -- reserved for use with -Ofile
308 stgToDo :: [StgToDo],
310 hscOutName :: String, -- name of the output file
311 hscStubHOutName :: String, -- name of the .stub_h output file
312 hscStubCOutName :: String, -- name of the .stub_c output file
313 extCoreName :: String, -- name of the .core output file
314 verbosity :: Int, -- verbosity level
315 optLevel :: Int, -- optimisation level
316 maxSimplIterations :: Int, -- max simplifier iterations
317 ruleCheck :: Maybe String,
318 cppFlag :: Bool, -- preprocess with cpp?
319 ppFlag :: Bool, -- preprocess with a Haskell Pp?
320 stolen_x86_regs :: Int,
321 cmdlineHcIncludes :: [String], -- -#includes
323 -- options for particular phases
349 | cGhcWithNativeCodeGen == "YES" &&
350 (prefixMatch "i386" cTARGETPLATFORM ||
351 prefixMatch "sparc" cTARGETPLATFORM ||
352 prefixMatch "powerpc" cTARGETPLATFORM) = HscAsm
355 defaultDynFlags = DynFlags {
356 coreToDo = Nothing, stgToDo = [],
357 hscLang = defaultHscLang,
359 hscStubHOutName = "", hscStubCOutName = "",
363 maxSimplIterations = 4,
368 cmdlineHcIncludes = [],
381 -- Generating the helper-functions for
382 -- generics is now on by default
384 -- strictness is on by default, but this only
387 -- similarly for CSE.
388 Opt_DoLambdaEtaExpansion,
389 -- This one is important for a tiresome reason:
390 -- we want to make sure that the bindings for data
391 -- constructors are eta-expanded. This is probably
392 -- a good thing anyway, but it seems fragile.
394 -- and the default no-optimisation options:
395 Opt_IgnoreInterfacePragmas,
396 Opt_OmitInterfacePragmas
398 ] ++ standardWarnings,
404 0 | print errors & warnings only
405 1 | minimal verbosity: print "compiling M ... done." for each module.
406 2 | equivalent to -dshow-passes
407 3 | equivalent to existing "ghc -v"
408 4 | "ghc -v -ddump-most"
409 5 | "ghc -v -ddump-all"
412 dopt :: DynFlag -> DynFlags -> Bool
413 dopt f dflags = f `elem` (flags dflags)
415 dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
416 dopt_CoreToDo = coreToDo
418 dopt_StgToDo :: DynFlags -> [StgToDo]
419 dopt_StgToDo = stgToDo
421 dopt_OutName :: DynFlags -> String
422 dopt_OutName = hscOutName
424 dopt_HscLang :: DynFlags -> HscLang
425 dopt_HscLang = hscLang
427 dopt_set :: DynFlags -> DynFlag -> DynFlags
428 dopt_set dfs f = dfs{ flags = f : flags dfs }
430 dopt_unset :: DynFlags -> DynFlag -> DynFlags
431 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
433 getOpts :: (DynFlags -> [a]) -> IO [a]
434 -- We add to the options from the front, so we need to reverse the list
435 getOpts opts = dynFlag opts >>= return . reverse
437 -- we can only switch between HscC, HscAsmm, and HscILX with dynamic flags
438 -- (-fvia-C, -fasm, -filx respectively).
439 setLang l = updDynFlags (\ dfs -> case hscLang dfs of
440 HscC -> dfs{ hscLang = l }
441 HscAsm -> dfs{ hscLang = l }
442 HscILX -> dfs{ hscLang = l }
446 verb <- dynFlag verbosity
447 if verb >= 3 then return "-v" else return ""
449 -----------------------------------------------------------------------------
450 -- Setting the optimisation level
452 setOptLevel :: Int -> IO ()
454 = do dflags <- getDynFlags
455 if hscLang dflags == HscInterpreted && n > 0
456 then putStr "warning: -O conflicts with --interactive; -O ignored.\n"
457 else updDynFlags (setOptLevel' n)
461 then dfs2{ hscLang = HscC, optLevel = n } -- turn on -fvia-C with -O
462 else dfs2{ optLevel = n }
464 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
465 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
468 | n == 0 = opt_0_dopts
469 | otherwise = opt_1_dopts
472 | n == 0 = opt_1_dopts
473 | otherwise = opt_0_dopts
476 Opt_IgnoreInterfacePragmas,
477 Opt_OmitInterfacePragmas
486 -- Core-to-core phases:
488 buildCoreToDo :: DynFlags -> [CoreToDo]
489 buildCoreToDo dflags = core_todo
491 opt_level = optLevel dflags
492 max_iter = maxSimplIterations dflags
493 strictness = dopt Opt_Strictness dflags
494 cse = dopt Opt_CSE dflags
495 rule_check = ruleCheck dflags
498 if opt_level == 0 then
500 CoreDoSimplify (SimplPhase 0) [
501 MaxSimplifierIterations max_iter
505 else {- opt_level >= 1 -} [
507 -- initial simplify: mk specialiser happy: minimum effort please
508 CoreDoSimplify SimplGently [
510 -- Don't inline anything till full laziness has bitten
511 -- In particular, inlining wrappers inhibits floating
512 -- e.g. ...(case f x of ...)...
513 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
514 -- ==> ...(case x of I# x# -> case fw x# of ...)...
515 -- and now the redex (f x) isn't floatable any more
516 -- Similarly, don't apply any rules until after full
517 -- laziness. Notably, list fusion can prevent floating.
520 -- Don't do case-of-case transformations.
521 -- This makes full laziness work better
522 MaxSimplifierIterations max_iter
525 -- Specialisation is best done before full laziness
526 -- so that overloaded functions have all their dictionary lambdas manifest
529 CoreDoFloatOutwards (FloatOutSw False False),
532 CoreDoSimplify (SimplPhase 2) [
533 -- Want to run with inline phase 2 after the specialiser to give
534 -- maximum chance for fusion to work before we inline build/augment
535 -- in phase 1. This made a difference in 'ansi' where an
536 -- overloaded function wasn't inlined till too late.
537 MaxSimplifierIterations max_iter
539 case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
541 CoreDoSimplify (SimplPhase 1) [
542 -- Need inline-phase2 here so that build/augment get
543 -- inlined. I found that spectral/hartel/genfft lost some useful
544 -- strictness in the function sumcode' if augment is not inlined
545 -- before strictness analysis runs
546 MaxSimplifierIterations max_iter
548 case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
550 CoreDoSimplify (SimplPhase 0) [
551 -- Phase 0: allow all Ids to be inlined now
552 -- This gets foldr inlined before strictness analysis
554 MaxSimplifierIterations 3
555 -- At least 3 iterations because otherwise we land up with
556 -- huge dead expressions because of an infelicity in the
558 -- let k = BIG in foldr k z xs
559 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
560 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
564 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
566 #ifdef OLD_STRICTNESS
569 if strictness then CoreDoStrictness else CoreDoNothing,
573 CoreDoSimplify (SimplPhase 0) [
574 MaxSimplifierIterations max_iter
577 CoreDoFloatOutwards (FloatOutSw False -- Not lambdas
578 True), -- Float constants
579 -- nofib/spectral/hartel/wang doubles in speed if you
580 -- do full laziness late in the day. It only happens
581 -- after fusion and other stuff, so the early pass doesn't
582 -- catch it. For the record, the redex is
583 -- f_el22 (f_el21 r_midblock)
586 -- We want CSE to follow the final full-laziness pass, because it may
587 -- succeed in commoning up things floated out by full laziness.
588 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
590 if cse then CoreCSE else CoreDoNothing,
594 -- Case-liberation for -O2. This should be after
595 -- strictness analysis and the simplification which follows it.
597 case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
599 if opt_level >= 2 then
603 if opt_level >= 2 then
608 -- Final clean-up simplification:
609 CoreDoSimplify (SimplPhase 0) [
610 MaxSimplifierIterations max_iter
614 -- --------------------------------------------------------------------------
615 -- Mess about with the mutable variables holding the dynamic arguments
618 -- is the "baseline" dynamic flags, initialised from
619 -- the defaults and command line options, and updated by the
620 -- ':s' command in GHCi.
623 -- is the dynamic flags for the current compilation. It is reset
624 -- to the value of v_InitDynFlags before each compilation, then
625 -- updated by reading any OPTIONS pragma in the current module.
627 GLOBAL_VAR(v_InitDynFlags, defaultDynFlags, DynFlags)
628 GLOBAL_VAR(v_DynFlags, defaultDynFlags, DynFlags)
630 setDynFlags :: DynFlags -> IO ()
631 setDynFlags dfs = writeIORef v_DynFlags dfs
633 saveDynFlags :: IO ()
634 saveDynFlags = do dfs <- readIORef v_DynFlags
635 writeIORef v_InitDynFlags dfs
637 restoreDynFlags :: IO DynFlags
638 restoreDynFlags = do dfs <- readIORef v_InitDynFlags
639 writeIORef v_DynFlags dfs
642 getDynFlags :: IO DynFlags
643 getDynFlags = readIORef v_DynFlags
645 updDynFlags :: (DynFlags -> DynFlags) -> IO ()
646 updDynFlags f = do dfs <- readIORef v_DynFlags
647 writeIORef v_DynFlags (f dfs)
649 dynFlag :: (DynFlags -> a) -> IO a
650 dynFlag f = do dflags <- readIORef v_DynFlags; return (f dflags)
652 setDynFlag, unSetDynFlag :: DynFlag -> IO ()
653 setDynFlag f = updDynFlags (\dfs -> dopt_set dfs f)
654 unSetDynFlag f = updDynFlags (\dfs -> dopt_unset dfs f)
658 %************************************************************************
660 \subsection{Warnings}
662 %************************************************************************
666 = [ Opt_WarnDeprecations,
667 Opt_WarnOverlappingPatterns,
668 Opt_WarnMissingFields,
669 Opt_WarnMissingMethods,
670 Opt_WarnDuplicateExports
674 = standardWarnings ++
675 [ Opt_WarnUnusedBinds,
676 Opt_WarnUnusedMatches,
677 Opt_WarnUnusedImports,
678 Opt_WarnIncompletePatterns,
684 [ Opt_WarnTypeDefaults,
685 Opt_WarnNameShadowing,
691 %************************************************************************
693 \subsection{Classifying command-line options}
695 %************************************************************************
698 -- v_Statis_hsc_opts is here to avoid a circular dependency with
700 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
702 lookUp :: FastString -> Bool
703 lookup_int :: String -> Maybe Int
704 lookup_def_int :: String -> Int -> Int
705 lookup_def_float :: String -> Float -> Float
706 lookup_str :: String -> Maybe String
708 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
709 packed_static_opts = map mkFastString unpacked_static_opts
711 lookUp sw = sw `elem` packed_static_opts
713 lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
715 lookup_int sw = case (lookup_str sw) of
717 Just xx -> Just (read xx)
719 lookup_def_int sw def = case (lookup_str sw) of
720 Nothing -> def -- Use default
723 lookup_def_float sw def = case (lookup_str sw) of
724 Nothing -> def -- Use default
729 Putting the compiler options into temporary at-files
730 may turn out to be necessary later on if we turn hsc into
731 a pure Win32 application where I think there's a command-line
732 length limit of 255. unpacked_opts understands the @ option.
734 unpacked_opts :: [String]
738 map unpackFS argv -- NOT ARGV any more: v_Static_hsc_opts
740 expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
745 %************************************************************************
747 \subsection{Static options}
749 %************************************************************************
753 opt_PprStyle_NoPrags = lookUp FSLIT("-dppr-noprags")
754 opt_PprStyle_Debug = lookUp FSLIT("-dppr-debug")
755 opt_PprStyle_RawTypes = lookUp FSLIT("-dppr-rawtypes")
756 opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
759 opt_AutoSccsOnAllToplevs = lookUp FSLIT("-fauto-sccs-on-all-toplevs")
760 opt_AutoSccsOnExportedToplevs = lookUp FSLIT("-fauto-sccs-on-exported-toplevs")
761 opt_AutoSccsOnIndividualCafs = lookUp FSLIT("-fauto-sccs-on-individual-cafs")
762 opt_AutoSccsOnDicts = lookUp FSLIT("-fauto-sccs-on-dicts")
763 opt_SccProfilingOn = lookUp FSLIT("-fscc-profiling")
764 opt_DoTickyProfiling = lookUp FSLIT("-fticky-ticky")
767 opt_AllStrict = lookUp FSLIT("-fall-strict")
768 opt_DictsStrict = lookUp FSLIT("-fdicts-strict")
769 opt_IrrefutableTuples = lookUp FSLIT("-firrefutable-tuples")
770 opt_MaxContextReductionDepth = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
771 opt_NumbersStrict = lookUp FSLIT("-fnumbers-strict")
772 opt_Parallel = lookUp FSLIT("-fparallel")
773 opt_SMP = lookUp FSLIT("-fsmp")
774 opt_Flatten = lookUp FSLIT("-fflatten")
777 opt_NoMethodSharing = lookUp FSLIT("-fno-method-sharing")
778 opt_DoSemiTagging = lookUp FSLIT("-fsemi-tagging")
779 opt_CprOff = lookUp FSLIT("-fcpr-off")
780 opt_RulesOff = lookUp FSLIT("-frules-off")
781 -- Switch off CPR analysis in the new demand analyser
782 opt_LiberateCaseThreshold = lookup_def_int "-fliberate-case-threshold" (10::Int)
783 opt_MaxWorkerArgs = lookup_def_int "-fmax-worker-args" (10::Int)
786 The optional '-inpackage=P' flag tells what package
787 we are compiling this module for.
788 The Prelude, for example is compiled with '-inpackage std'
790 opt_InPackage = case lookup_str "-inpackage=" of
791 Just p -> mkFastString p
792 Nothing -> FSLIT("Main") -- The package name if none is specified
794 opt_EmitCExternDecls = lookUp FSLIT("-femit-extern-decls")
795 opt_EnsureSplittableC = lookUp FSLIT("-fglobalise-toplev-names")
796 opt_GranMacros = lookUp FSLIT("-fgransim")
797 opt_HiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
798 opt_HistorySize = lookup_def_int "-fhistory-size" 20
799 opt_NoHiCheck = lookUp FSLIT("-fno-hi-version-check")
800 opt_OmitBlackHoling = lookUp FSLIT("-dno-black-holing")
801 opt_RuntimeTypes = lookUp FSLIT("-fruntime-types")
803 -- Simplifier switches
804 opt_SimplNoPreInlining = lookUp FSLIT("-fno-pre-inlining")
805 -- NoPreInlining is there just to see how bad things
806 -- get if you don't do it!
807 opt_SimplExcessPrecision = lookUp FSLIT("-fexcess-precision")
810 opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (45::Int)
811 opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (8::Int) -- Discounts can be big
812 opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (6::Int) -- It's great to inline a fn
813 opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
814 opt_UF_UpdateInPlace = lookUp FSLIT("-funfolding-update-in-place")
816 opt_UF_CheapOp = ( 1 :: Int) -- Only one instruction; and the args are charged for
817 opt_UF_DearOp = ( 4 :: Int)
819 opt_NoPruneDecls = lookUp FSLIT("-fno-prune-decls")
820 opt_Static = lookUp FSLIT("-static")
821 opt_Unregisterised = lookUp FSLIT("-funregisterised")
822 opt_EmitExternalCore = lookUp FSLIT("-fext-core")
825 %************************************************************************
827 \subsection{List of static hsc flags}
829 %************************************************************************
834 "fauto-sccs-on-all-toplevs",
835 "fauto-sccs-on-exported-toplevs",
836 "fauto-sccs-on-individual-cafs",
837 "fauto-sccs-on-dicts",
842 "firrefutable-tuples",
849 "femit-extern-decls",
850 "fglobalise-toplev-names",
852 "fno-hi-version-check",
854 "fno-method-sharing",
858 "funfolding-update-in-place",
867 || any (flip prefixMatch f) [
869 "fliberate-case-threshold",
872 "funfolding-creation-threshold",
873 "funfolding-use-threshold",
874 "funfolding-fun-discount",
875 "funfolding-keeness-factor"
879 %************************************************************************
881 \subsection{Misc functions for command-line options}
883 %************************************************************************
888 startsWith :: String -> String -> Maybe String
889 -- startsWith pfx (pfx++rest) = Just rest
891 startsWith [] str = Just str
892 startsWith (c:cs) (s:ss)
893 = if c /= s then Nothing else startsWith cs ss
894 startsWith _ [] = Nothing
896 endsWith :: String -> String -> Maybe String
898 = case (startsWith (reverse cs) (reverse ss)) of
900 Just rs -> Just (reverse rs)