2 % (c) The University of Glasgow, 1996-2000
4 \section[CmdLineOpts]{Things to do with command-line options}
10 SimplifierSwitch(..), isAmongSimpl,
14 DynFlag(..), -- needed non-abstractly by DriverFlags
24 opt_PprStyle_RawTypes,
30 -- other dynamic flags
37 opt_AutoSccsOnAllToplevs,
38 opt_AutoSccsOnExportedToplevs,
39 opt_AutoSccsOnIndividualCafs,
47 opt_MaxContextReductionDepth,
48 opt_IrrefutableTuples,
56 opt_LiberateCaseThreshold,
57 opt_StgDoLetNoEscapes,
60 opt_UnboxStrictFields,
61 opt_SimplNoPreInlining,
62 opt_SimplDoEtaReduction,
63 opt_SimplDoLambdaEtaExpansion,
66 opt_SimplPedanticBottoms,
67 opt_SimplExcessPrecision,
70 opt_UF_HiFileThreshold,
71 opt_UF_CreationThreshold,
73 opt_UF_FunAppDiscount,
82 opt_EnsureSplittableC,
87 opt_IgnoreIfacePragmas,
90 opt_OmitInterfacePragmas,
98 #include "HsVersions.h"
100 import Array ( array, (//) )
102 import IOExts ( IORef, readIORef )
103 import Constants -- Default values for some flags
107 import Maybes ( firstJust )
108 import Panic ( panic )
110 #if __GLASGOW_HASKELL__ < 301
111 import ArrBase ( Array(..) )
113 import PrelArr ( Array(..) )
117 %************************************************************************
119 \subsection{Command-line options}
121 %************************************************************************
123 The hsc command-line options are split into two categories:
128 Static flags are represented by top-level values of type Bool or Int,
129 for example. They therefore have the same value throughout the
132 Dynamic flags are represented by an abstract type, DynFlags, which is
133 passed into hsc by the compilation manager for every compilation.
134 Dynamic flags are those that change on a per-compilation basis,
135 perhaps because they may be present in the OPTIONS pragma at the top
138 Other flag-related blurb:
140 A list of {\em ToDo}s is things to be done in a particular part of
141 processing. A (fictitious) example for the Core-to-Core simplifier
142 might be: run the simplifier, then run the strictness analyser, then
143 run the simplifier again (three ``todos'').
145 There are three ``to-do processing centers'' at the moment. In the
146 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
147 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
148 (\tr{simplStg/SimplStg.lhs}).
150 %************************************************************************
152 \subsection{Datatypes associated with command-line options}
154 %************************************************************************
158 = SwBool Bool -- on/off
159 | SwString FAST_STRING -- nothing or a String
160 | SwInt Int -- nothing or an Int
164 data CoreToDo -- These are diff core-to-core passes,
165 -- which may be invoked in any order,
166 -- as many times as you like.
168 = CoreDoSimplify -- The core-to-core simplifier.
169 (SimplifierSwitch -> SwitchResult)
170 -- Each run of the simplifier can take a different
171 -- set of simplifier-specific flags.
173 | CoreDoFloatOutwards Bool -- True <=> float lambdas to top level
178 | CoreDoWorkerWrapper
185 | CoreDoNothing -- useful when building up lists of these things
192 | StgDoMassageForProfiling -- should be (next to) last
193 -- There's also setStgVarInfo, but its absolute "lastness"
194 -- is so critical that it is hardwired in (no flag).
199 data SimplifierSwitch
200 = MaxSimplifierIterations Int
201 | SimplInlinePhase Int
207 %************************************************************************
209 \subsection{Dynamic command-line options}
211 %************************************************************************
226 | Opt_D_dump_inlinings
227 | Opt_D_dump_occur_anal
232 | Opt_D_dump_simpl_iterations
241 | Opt_D_dump_worker_wrapper
243 | Opt_D_dump_rn_trace
244 | Opt_D_dump_rn_stats
246 | Opt_D_dump_simpl_stats
248 | Opt_D_verbose_core2core
249 | Opt_D_verbose_stg2stg
250 | Opt_D_dump_hi_diffs
251 | Opt_D_dump_minimal_imports
256 | Opt_WarnDuplicateExports
258 | Opt_WarnIncompletePatterns
259 | Opt_WarnMissingFields
260 | Opt_WarnMissingMethods
261 | Opt_WarnMissingSigs
262 | Opt_WarnNameShadowing
263 | Opt_WarnOverlappingPatterns
264 | Opt_WarnSimplePatterns
265 | Opt_WarnTypeDefaults
266 | Opt_WarnUnusedBinds
267 | Opt_WarnUnusedImports
268 | Opt_WarnUnusedMatches
269 | Opt_WarnDeprecations
272 | Opt_AllowOverlappingInstances
273 | Opt_AllowUndecidableInstances
276 | Opt_NoImplicitPrelude
282 data DynFlags = DynFlags {
283 coreToDo :: [CoreToDo],
284 stgToDo :: [StgToDo],
286 hscOutName :: String, -- name of the file in which to place output
290 dopt :: DynFlag -> DynFlags -> Bool
291 dopt f dflags = f `elem` (flags dflags)
293 dopt_CoreToDo :: DynFlags -> [CoreToDo]
294 dopt_CoreToDo = coreToDo
296 dopt_StgToDo :: DynFlags -> [StgToDo]
297 dopt_StgToDo = stgToDo
299 dopt_OutName :: DynFlags -> String
300 dopt_OutName = hscOutName
309 dopt_HscLang :: DynFlags -> HscLang
310 dopt_HscLang = hscLang
313 %************************************************************************
315 \subsection{Classifying command-line options}
317 %************************************************************************
320 -- v_Statis_hsc_opts is here to avoid a circular dependency with
322 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
324 lookUp :: FAST_STRING -> Bool
325 lookup_int :: String -> Maybe Int
326 lookup_def_int :: String -> Int -> Int
327 lookup_def_float :: String -> Float -> Float
328 lookup_str :: String -> Maybe String
330 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
331 packed_static_opts = map _PK_ unpacked_static_opts
333 lookUp sw = sw `elem` packed_static_opts
335 lookup_str sw = firstJust (map (startsWith sw) unpacked_static_opts)
337 lookup_int sw = case (lookup_str sw) of
339 Just xx -> Just (read xx)
341 lookup_def_int sw def = case (lookup_str sw) of
342 Nothing -> def -- Use default
345 lookup_def_float sw def = case (lookup_str sw) of
346 Nothing -> def -- Use default
351 Putting the compiler options into temporary at-files
352 may turn out to be necessary later on if we turn hsc into
353 a pure Win32 application where I think there's a command-line
354 length limit of 255. unpacked_opts understands the @ option.
356 unpacked_opts :: [String]
360 map _UNPK_ argv -- NOT ARGV any more: v_Static_hsc_opts
362 expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
367 %************************************************************************
369 \subsection{Static options}
371 %************************************************************************
375 opt_PprStyle_NoPrags = lookUp SLIT("-dppr-noprags")
376 opt_PprStyle_Debug = lookUp SLIT("-dppr-debug")
377 opt_PprStyle_RawTypes = lookUp SLIT("-dppr-rawtypes")
378 opt_PprUserLength = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
381 opt_AutoSccsOnAllToplevs = lookUp SLIT("-fauto-sccs-on-all-toplevs")
382 opt_AutoSccsOnExportedToplevs = lookUp SLIT("-fauto-sccs-on-exported-toplevs")
383 opt_AutoSccsOnIndividualCafs = lookUp SLIT("-fauto-sccs-on-individual-cafs")
384 opt_AutoSccsOnDicts = lookUp SLIT("-fauto-sccs-on-dicts")
385 opt_SccProfilingOn = lookUp SLIT("-fscc-profiling")
386 opt_DoTickyProfiling = lookUp SLIT("-fticky-ticky")
389 opt_AllStrict = lookUp SLIT("-fall-strict")
390 opt_DictsStrict = lookUp SLIT("-fdicts-strict")
391 opt_IrrefutableTuples = lookUp SLIT("-firrefutable-tuples")
392 opt_MaxContextReductionDepth = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
393 opt_NumbersStrict = lookUp SLIT("-fnumbers-strict")
394 opt_Parallel = lookUp SLIT("-fparallel")
395 opt_SMP = lookUp SLIT("-fsmp")
398 opt_DoSemiTagging = lookUp SLIT("-fsemi-tagging")
399 opt_FoldrBuildOn = lookUp SLIT("-ffoldr-build-on")
400 opt_LiberateCaseThreshold = lookup_def_int "-fliberate-case-threshold" (10::Int)
401 opt_StgDoLetNoEscapes = lookUp SLIT("-flet-no-escape")
402 opt_UnfoldCasms = lookUp SLIT("-funfold-casms-in-hi-file")
403 opt_UsageSPOn = lookUp SLIT("-fusagesp-on")
404 opt_UnboxStrictFields = lookUp SLIT("-funbox-strict-fields")
407 The optional '-inpackage=P' flag tells what package
408 we are compiling this module for.
409 The Prelude, for example is compiled with '-package prelude'
411 opt_InPackage = case lookup_str "-inpackage=" of
413 Nothing -> SLIT("Main") -- The package name if none is specified
415 opt_EmitCExternDecls = lookUp SLIT("-femit-extern-decls")
416 opt_EnsureSplittableC = lookUp SLIT("-fglobalise-toplev-names")
417 opt_GranMacros = lookUp SLIT("-fgransim")
418 opt_HiVersion = lookup_def_int "-fhi-version=" 0 -- what version we're compiling.
419 opt_HistorySize = lookup_def_int "-fhistory-size" 20
420 opt_IgnoreAsserts = lookUp SLIT("-fignore-asserts")
421 opt_IgnoreIfacePragmas = lookUp SLIT("-fignore-interface-pragmas")
422 opt_NoHiCheck = lookUp SLIT("-fno-hi-version-check")
423 opt_OmitBlackHoling = lookUp SLIT("-dno-black-holing")
424 opt_OmitInterfacePragmas = lookUp SLIT("-fomit-interface-pragmas")
426 -- Simplifier switches
427 opt_SimplNoPreInlining = lookUp SLIT("-fno-pre-inlining")
428 -- NoPreInlining is there just to see how bad things
429 -- get if you don't do it!
430 opt_SimplDoEtaReduction = lookUp SLIT("-fdo-eta-reduction")
431 opt_SimplDoLambdaEtaExpansion = lookUp SLIT("-fdo-lambda-eta-expansion")
432 opt_SimplCaseOfCase = lookUp SLIT("-fcase-of-case")
433 opt_SimplCaseMerge = lookUp SLIT("-fcase-merge")
434 opt_SimplPedanticBottoms = lookUp SLIT("-fpedantic-bottoms")
435 opt_SimplExcessPrecision = lookUp SLIT("-fexcess-precision")
438 opt_UF_HiFileThreshold = lookup_def_int "-funfolding-interface-threshold" (45::Int)
439 opt_UF_CreationThreshold = lookup_def_int "-funfolding-creation-threshold" (45::Int)
440 opt_UF_UseThreshold = lookup_def_int "-funfolding-use-threshold" (8::Int) -- Discounts can be big
441 opt_UF_FunAppDiscount = lookup_def_int "-funfolding-fun-discount" (6::Int) -- It's great to inline a fn
442 opt_UF_KeenessFactor = lookup_def_float "-funfolding-keeness-factor" (1.5::Float)
443 opt_UF_UpdateInPlace = lookUp SLIT("-funfolding-update-in-place")
445 opt_UF_CheapOp = ( 1 :: Int) -- Only one instruction; and the args are charged for
446 opt_UF_DearOp = ( 4 :: Int)
448 opt_NoPruneDecls = lookUp SLIT("-fno-prune-decls")
449 opt_NoPruneTyDecls = lookUp SLIT("-fno-prune-tydecls")
450 opt_Static = lookUp SLIT("-static")
451 opt_Unregisterised = lookUp SLIT("-funregisterised")
452 opt_Verbose = lookUp SLIT("-v")
455 %************************************************************************
457 \subsection{List of static hsc flags}
459 %************************************************************************
464 "fauto-sccs-on-all-toplevs",
465 "fauto-sccs-on-exported-toplevs",
466 "fauto-sccs-on-individual-cafs",
467 "fauto-sccs-on-dicts",
472 "firrefutable-tuples",
479 "funfold-casms-in-hi-file",
481 "funbox-strict-fields",
482 "femit-extern-decls",
483 "fglobalise-toplev-names",
486 "fignore-interface-pragmas",
487 "fno-hi-version-check",
488 "fno-implicit-prelude",
490 "fomit-interface-pragmas",
493 "fdo-lambda-eta-expansion",
498 "funfolding-update-in-place",
505 || any (flip prefixMatch f) [
507 "fliberate-case-threshold",
510 "funfolding-interface-threshold",
511 "funfolding-creation-threshold",
512 "funfolding-use-threshold",
513 "funfolding-fun-discount",
514 "funfolding-keeness-factor"
518 %************************************************************************
520 \subsection{Switch ordering}
522 %************************************************************************
524 These things behave just like enumeration types.
527 instance Eq SimplifierSwitch where
528 a == b = tagOf_SimplSwitch a ==# tagOf_SimplSwitch b
530 instance Ord SimplifierSwitch where
531 a < b = tagOf_SimplSwitch a <# tagOf_SimplSwitch b
532 a <= b = tagOf_SimplSwitch a <=# tagOf_SimplSwitch b
535 tagOf_SimplSwitch (SimplInlinePhase _) = _ILIT(1)
536 tagOf_SimplSwitch (MaxSimplifierIterations _) = _ILIT(2)
537 tagOf_SimplSwitch DontApplyRules = _ILIT(3)
538 tagOf_SimplSwitch SimplLetToCase = _ILIT(4)
539 tagOf_SimplSwitch NoCaseOfCase = _ILIT(5)
541 -- If you add anything here, be sure to change lAST_SIMPL_SWITCH_TAG, too!
543 lAST_SIMPL_SWITCH_TAG = 5
546 %************************************************************************
548 \subsection{Switch lookup}
550 %************************************************************************
553 isAmongSimpl :: [SimplifierSwitch] -> SimplifierSwitch -> SwitchResult
554 isAmongSimpl on_switches -- Switches mentioned later occur *earlier*
555 -- in the list; defaults right at the end.
557 tidied_on_switches = foldl rm_dups [] on_switches
558 -- The fold*l* ensures that we keep the latest switches;
559 -- ie the ones that occur earliest in the list.
561 sw_tbl :: Array Int SwitchResult
562 sw_tbl = (array (0, lAST_SIMPL_SWITCH_TAG) -- bounds...
566 all_undefined = [ (i, SwBool False) | i <- [0 .. lAST_SIMPL_SWITCH_TAG ] ]
568 defined_elems = map mk_assoc_elem tidied_on_switches
570 -- (avoid some unboxing, bounds checking, and other horrible things:)
571 #if __GLASGOW_HASKELL__ < 405
572 case sw_tbl of { Array bounds_who_needs_'em stuff ->
574 case sw_tbl of { Array _ _ stuff ->
577 case (indexArray# stuff (tagOf_SimplSwitch switch)) of
578 #if __GLASGOW_HASKELL__ < 400
580 #elif __GLASGOW_HASKELL__ < 403
587 mk_assoc_elem k@(MaxSimplifierIterations lvl)
588 = (iBox (tagOf_SimplSwitch k), SwInt lvl)
589 mk_assoc_elem k@(SimplInlinePhase n)
590 = (iBox (tagOf_SimplSwitch k), SwInt n)
592 = (iBox (tagOf_SimplSwitch k), SwBool True) -- I'm here, Mom!
594 -- cannot have duplicates if we are going to use the array thing
595 rm_dups switches_so_far switch
596 = if switch `is_elem` switches_so_far
598 else switch : switches_so_far
600 sw `is_elem` [] = False
601 sw `is_elem` (s:ss) = (tagOf_SimplSwitch sw) ==# (tagOf_SimplSwitch s)
606 %************************************************************************
608 \subsection{Misc functions for command-line options}
610 %************************************************************************
614 switchIsOn :: (switch -> SwitchResult) -> switch -> Bool
616 switchIsOn lookup_fn switch
617 = case (lookup_fn switch) of
618 SwBool False -> False
621 intSwitchSet :: (switch -> SwitchResult)
625 intSwitchSet lookup_fn switch
626 = case (lookup_fn (switch (panic "intSwitchSet"))) of
627 SwInt int -> Just int
632 startsWith :: String -> String -> Maybe String
633 -- startsWith pfx (pfx++rest) = Just rest
635 startsWith [] str = Just str
636 startsWith (c:cs) (s:ss)
637 = if c /= s then Nothing else startsWith cs ss
638 startsWith _ [] = Nothing
640 endsWith :: String -> String -> Maybe String
642 = case (startsWith (reverse cs) (reverse ss)) of
644 Just rs -> Just (reverse rs)