5 -- (c) The University of Glasgow 2005
8 -- Most flags are dynamic flags, which means they can change from
9 -- compilation to compilation using @OPTIONS_GHC@ pragmas, and in a
10 -- multi-session GHC each session can be using different dynamic
11 -- flags. Dynamic flags can also be set at the prompt in GHCi.
13 -- * Dynamic flags and associated configuration types
16 HscTarget(..), isObjectTarget, defaultObjectTarget,
17 GhcMode(..), isOneShot,
18 GhcLink(..), isNoLink,
26 -- ** Manipulating DynFlags
27 defaultDynFlags, -- DynFlags
28 initDynFlags, -- DynFlags -> IO DynFlags
30 dopt, -- DynFlag -> DynFlags -> Bool
31 dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
32 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
39 -- ** Parsing DynFlags
41 parseDynamicNoPackageFlags,
44 supportedLanguages, languageOptions,
46 -- ** DynFlag C compiler options
47 machdepCCOpts, picCCOpts,
49 -- * Configuration of the core-to-core passes
56 -- * Configuration of the stg-to-stg passes
60 -- * Compiler configuration suitable for display to the user
65 #include "HsVersions.h"
67 #ifndef OMIT_NATIVE_CODEGEN
72 import PrelNames ( mAIN )
74 import {-# SOURCE #-} Packages (PackageState)
75 import DriverPhases ( Phase(..), phaseInputExt )
78 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
81 import Maybes ( orElse )
85 import BasicTypes ( CompilerPhase )
87 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
90 import Control.Monad ( when )
94 import System.FilePath
95 import System.IO ( stderr, hPutChar )
97 -- -----------------------------------------------------------------------------
100 -- | Enumerates the simple on-or-off dynamic flags
106 | Opt_D_dump_cmmz_pretty
110 | Opt_D_dump_asm_native
111 | Opt_D_dump_asm_liveness
112 | Opt_D_dump_asm_coalesce
113 | Opt_D_dump_asm_regalloc
114 | Opt_D_dump_asm_regalloc_stages
115 | Opt_D_dump_asm_conflicts
116 | Opt_D_dump_asm_stats
117 | Opt_D_dump_asm_expanded
123 | Opt_D_dump_inlinings
124 | Opt_D_dump_rule_firings
125 | Opt_D_dump_occur_anal
129 | Opt_D_dump_simpl_iterations
130 | Opt_D_dump_simpl_phases
139 | Opt_D_dump_worker_wrapper
140 | Opt_D_dump_rn_trace
141 | Opt_D_dump_rn_stats
143 | Opt_D_dump_simpl_stats
144 | Opt_D_dump_tc_trace
145 | Opt_D_dump_if_trace
152 | Opt_D_verbose_core2core
153 | Opt_D_verbose_stg2stg
155 | Opt_D_dump_hi_diffs
156 | Opt_D_dump_minimal_imports
157 | Opt_D_dump_mod_cycles
158 | Opt_D_dump_view_pattern_commoning
159 | Opt_D_faststring_stats
160 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
161 | Opt_D_no_debug_output
167 | Opt_WarnIsError -- -Werror; makes warnings fatal
168 | Opt_WarnDuplicateExports
170 | Opt_WarnImplicitPrelude
171 | Opt_WarnIncompletePatterns
172 | Opt_WarnIncompletePatternsRecUpd
173 | Opt_WarnMissingFields
174 | Opt_WarnMissingMethods
175 | Opt_WarnMissingSigs
176 | Opt_WarnNameShadowing
177 | Opt_WarnOverlappingPatterns
178 | Opt_WarnSimplePatterns
179 | Opt_WarnTypeDefaults
180 | Opt_WarnMonomorphism
181 | Opt_WarnUnusedBinds
182 | Opt_WarnUnusedImports
183 | Opt_WarnUnusedMatches
184 | Opt_WarnWarningsDeprecations
185 | Opt_WarnDeprecatedFlags
186 | Opt_WarnDodgyExports
187 | Opt_WarnDodgyImports
190 | Opt_WarnUnrecognisedPragmas
191 | Opt_WarnDodgyForeignImports
192 | Opt_WarnLazyUnliftedBindings
193 | Opt_WarnUnusedDoBind
194 | Opt_WarnWrongDoBind
198 | Opt_OverlappingInstances
199 | Opt_UndecidableInstances
200 | Opt_IncoherentInstances
201 | Opt_MonomorphismRestriction
204 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
205 | Opt_ForeignFunctionInterface
206 | Opt_UnliftedFFITypes
207 | Opt_GHCForeignImportPrim
208 | Opt_PArr -- Syntactic support for parallel arrays
209 | Opt_Arrows -- Arrow-notation syntax
210 | Opt_TemplateHaskell
213 | Opt_Generics -- "Derivable type classes"
214 | Opt_ImplicitPrelude
215 | Opt_ScopedTypeVariables
219 | Opt_OverloadedStrings
220 | Opt_DisambiguateRecordFields
221 | Opt_RecordWildCards
228 | Opt_StandaloneDeriving
229 | Opt_DeriveDataTypeable
231 | Opt_DeriveTraversable
234 | Opt_TypeSynonymInstances
235 | Opt_FlexibleContexts
236 | Opt_FlexibleInstances
237 | Opt_ConstrainedClassMethods
238 | Opt_MultiParamTypeClasses
239 | Opt_FunctionalDependencies
241 | Opt_PolymorphicComponents
242 | Opt_ExistentialQuantification
246 | Opt_ParallelListComp
247 | Opt_TransformListComp
248 | Opt_GeneralizedNewtypeDeriving
251 | Opt_PostfixOperators
254 | Opt_LiberalTypeSynonyms
257 | Opt_ImpredicativeTypes
260 | Opt_NewQualifiedOperators
262 | Opt_AlternativeLayoutRule
264 | Opt_PrintExplicitForalls
271 | Opt_StaticArgumentTransformation
275 | Opt_DoLambdaEtaExpansion
279 | Opt_UnboxStrictFields
282 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
284 | Opt_RegsGraph -- do graph coloring register allocation
285 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
288 | Opt_IgnoreInterfacePragmas
289 | Opt_OmitInterfacePragmas
290 | Opt_ExposeAllUnfoldings
293 | Opt_AutoSccsOnAllToplevs
294 | Opt_AutoSccsOnExportedToplevs
295 | Opt_AutoSccsOnIndividualCafs
303 | Opt_ExcessPrecision
304 | Opt_EagerBlackHoling
305 | Opt_ReadUserPackageConf
309 | Opt_HideAllPackages
310 | Opt_PrintBindResult
314 | Opt_BreakOnException
316 | Opt_PrintEvldWithShow
317 | Opt_PrintBindContents
320 | Opt_EmitExternalCore
322 | Opt_BuildingCabalPackage
327 | Opt_ConvertToZipCfgAndBack
328 | Opt_AutoLinkPackages
329 | Opt_ImplicitImportQualified
338 | Opt_KeepRawTokenStream
342 -- | Contains not only a collection of 'DynFlag's but also a plethora of
343 -- information relating to the compilation of a single file or GHC session
344 data DynFlags = DynFlags {
347 coreToDo :: Maybe [CoreToDo], -- reserved for -Ofile
348 stgToDo :: Maybe [StgToDo], -- similarly
349 hscTarget :: HscTarget,
350 hscOutName :: String, -- ^ Name of the output file
351 extCoreName :: String, -- ^ Name of the .hcr output file
352 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
353 optLevel :: Int, -- ^ Optimisation level
354 simplPhases :: Int, -- ^ Number of simplifier phases
355 maxSimplIterations :: Int, -- ^ Max simplifier iterations
356 shouldDumpSimplPhase :: SimplifierMode -> Bool,
357 ruleCheck :: Maybe String,
358 strictnessBefore :: [Int], -- ^ Additional demand analysis
360 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
361 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
362 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
364 #ifndef OMIT_NATIVE_CODEGEN
365 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
367 stolen_x86_regs :: Int,
368 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
369 importPaths :: [FilePath],
371 mainFunIs :: Maybe String,
372 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
374 dphBackend :: DPHBackend,
376 thisPackage :: PackageId, -- ^ name of package currently being compiled
379 ways :: [Way], -- ^ Way flags from the command line
380 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
381 rtsBuildTag :: String, -- ^ The RTS \"way\"
383 -- For object splitting
384 splitInfo :: Maybe (String,Int),
387 objectDir :: Maybe String,
388 dylibInstallName :: Maybe String,
389 hiDir :: Maybe String,
390 stubDir :: Maybe String,
396 outputFile :: Maybe String,
397 outputHi :: Maybe String,
398 dynLibLoader :: DynLibLoader,
400 -- | This is set by 'DriverPipeline.runPipeline' based on where
401 -- its output is going.
402 dumpPrefix :: Maybe FilePath,
404 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
405 -- Set by @-ddump-file-prefix@
406 dumpPrefixForce :: Maybe FilePath,
408 includePaths :: [String],
409 libraryPaths :: [String],
410 frameworkPaths :: [String], -- used on darwin only
411 cmdlineFrameworks :: [String], -- ditto
412 tmpDir :: String, -- no trailing '/'
414 ghcUsagePath :: FilePath, -- Filled in by SysTools
415 ghciUsagePath :: FilePath, -- ditto
417 hpcDir :: String, -- ^ Path to store the .mix files
419 -- options for particular phases
427 opt_windres :: [String],
429 -- commands for particular phases
431 pgm_P :: (String,[Option]),
433 pgm_c :: (String,[Option]),
434 pgm_m :: (String,[Option]),
435 pgm_s :: (String,[Option]),
436 pgm_a :: (String,[Option]),
437 pgm_l :: (String,[Option]),
438 pgm_dll :: (String,[Option]),
440 pgm_sysman :: String,
441 pgm_windres :: String,
444 depMakefile :: FilePath,
445 depIncludePkgDeps :: Bool,
446 depExcludeMods :: [ModuleName],
447 depSuffixes :: [String],
450 extraPkgConfs :: [FilePath],
451 topDir :: FilePath, -- filled in by SysTools
452 systemPackageConfig :: FilePath, -- ditto
453 -- ^ The @-package-conf@ flags given on the command line, in the order
456 packageFlags :: [PackageFlag],
457 -- ^ The @-package@ and @-hide-package@ flags from the command-line
460 -- NB. do not modify this field, it is calculated by
461 -- Packages.initPackages and Packages.updatePackages.
462 pkgDatabase :: Maybe [PackageConfig],
463 pkgState :: PackageState,
466 -- These have to be IORefs, because the defaultCleanupHandler needs to
467 -- know what to clean when an exception happens
468 filesToClean :: IORef [FilePath],
469 dirsToClean :: IORef (FiniteMap FilePath FilePath),
474 -- | Message output action: use "ErrUtils" instead of this if you can
475 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
477 haddockOptions :: Maybe String
480 wayNames :: DynFlags -> [WayName]
481 wayNames = map wayName . ways
483 -- | The target code type of the compilation (if any).
485 -- Whenever you change the target, also make sure to set 'ghcLink' to
486 -- something sensible.
488 -- 'HscNothing' can be used to avoid generating any output, however, note
491 -- * This will not run the desugaring step, thus no warnings generated in
492 -- this step will be output. In particular, this includes warnings related
493 -- to pattern matching. You can run the desugarer manually using
494 -- 'GHC.desugarModule'.
496 -- * If a program uses Template Haskell the typechecker may try to run code
497 -- from an imported module. This will fail if no code has been generated
498 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
499 -- whether this might be the case and choose to either switch to a
500 -- different target or avoid typechecking such modules. (The latter may
501 -- preferable for security reasons.)
504 = HscC -- ^ Generate C code.
505 | HscAsm -- ^ Generate assembly using the native code generator.
506 | HscJava -- ^ Generate Java bytecode.
507 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
508 | HscNothing -- ^ Don't generate any code. See notes above.
511 -- | Will this target result in an object file on the disk?
512 isObjectTarget :: HscTarget -> Bool
513 isObjectTarget HscC = True
514 isObjectTarget HscAsm = True
515 isObjectTarget _ = False
517 -- | The 'GhcMode' tells us whether we're doing multi-module
518 -- compilation (controlled via the "GHC" API) or one-shot
519 -- (single-module) compilation. This makes a difference primarily to
520 -- the "Finder": in one-shot mode we look for interface files for
521 -- imported modules, but in multi-module mode we look for source files
522 -- in order to check whether they need to be recompiled.
524 = CompManager -- ^ @\-\-make@, GHCi, etc.
525 | OneShot -- ^ @ghc -c Foo.hs@
526 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
529 instance Outputable GhcMode where
530 ppr CompManager = ptext (sLit "CompManager")
531 ppr OneShot = ptext (sLit "OneShot")
532 ppr MkDepend = ptext (sLit "MkDepend")
534 isOneShot :: GhcMode -> Bool
535 isOneShot OneShot = True
536 isOneShot _other = False
538 -- | What to do in the link step, if there is one.
540 = NoLink -- ^ Don't link at all
541 | LinkBinary -- ^ Link object code into a binary
542 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
543 -- bytecode and object code).
544 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
547 isNoLink :: GhcLink -> Bool
548 isNoLink NoLink = True
551 -- Is it worth evaluating this Bool and caching it in the DynFlags value
552 -- during initDynFlags?
553 doingTickyProfiling :: DynFlags -> Bool
554 doingTickyProfiling _ = opt_Ticky
555 -- XXX -ticky is a static flag, because it implies -debug which is also
556 -- static. If the way flags were made dynamic, we could fix this.
559 = ExposePackage String
560 | ExposePackageId String
562 | IgnorePackage String
565 defaultHscTarget :: HscTarget
566 defaultHscTarget = defaultObjectTarget
568 -- | The 'HscTarget' value corresponding to the default way to create
569 -- object files on the current platform.
570 defaultObjectTarget :: HscTarget
572 | cGhcWithNativeCodeGen == "YES" = HscAsm
577 | Wrapped (Maybe String)
581 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
582 initDynFlags :: DynFlags -> IO DynFlags
583 initDynFlags dflags = do
584 -- someday these will be dynamic flags
585 ways <- readIORef v_Ways
586 refFilesToClean <- newIORef []
587 refDirsToClean <- newIORef emptyFM
590 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
591 rtsBuildTag = mkBuildTag ways,
592 filesToClean = refFilesToClean,
593 dirsToClean = refDirsToClean
596 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
597 -- and must be fully initialized by 'GHC.newSession' first.
598 defaultDynFlags :: DynFlags
601 ghcMode = CompManager,
602 ghcLink = LinkBinary,
605 hscTarget = defaultHscTarget,
611 maxSimplIterations = 4,
612 shouldDumpSimplPhase = const False,
614 specConstrThreshold = Just 200,
615 specConstrCount = Just 3,
616 liberateCaseThreshold = Just 200,
617 strictnessBefore = [],
619 #ifndef OMIT_NATIVE_CODEGEN
620 targetPlatform = defaultTargetPlatform,
623 cmdlineHcIncludes = [],
627 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
631 thisPackage = mainPackageId,
634 dylibInstallName = Nothing,
638 objectSuf = phaseInputExt StopLn,
639 hcSuf = phaseInputExt HCc,
642 outputFile = Nothing,
644 dynLibLoader = SystemDependent,
645 dumpPrefix = Nothing,
646 dumpPrefixForce = Nothing,
650 cmdlineFrameworks = [],
651 tmpDir = cDEFAULT_TMPDIR,
657 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
668 pkgDatabase = Nothing,
669 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
670 ways = panic "defaultDynFlags: No ways",
671 buildTag = panic "defaultDynFlags: No buildTag",
672 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
674 -- initSysTools fills all these in
675 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
676 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
677 topDir = panic "defaultDynFlags: No topDir",
678 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
679 pgm_L = panic "defaultDynFlags: No pgm_L",
680 pgm_P = panic "defaultDynFlags: No pgm_P",
681 pgm_F = panic "defaultDynFlags: No pgm_F",
682 pgm_c = panic "defaultDynFlags: No pgm_c",
683 pgm_m = panic "defaultDynFlags: No pgm_m",
684 pgm_s = panic "defaultDynFlags: No pgm_s",
685 pgm_a = panic "defaultDynFlags: No pgm_a",
686 pgm_l = panic "defaultDynFlags: No pgm_l",
687 pgm_dll = panic "defaultDynFlags: No pgm_dll",
688 pgm_T = panic "defaultDynFlags: No pgm_T",
689 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
690 pgm_windres = panic "defaultDynFlags: No pgm_windres",
691 -- end of initSysTools values
693 depMakefile = "Makefile",
694 depIncludePkgDeps = False,
697 -- end of ghc -M values
698 filesToClean = panic "defaultDynFlags: No filesToClean",
699 dirsToClean = panic "defaultDynFlags: No dirsToClean",
700 haddockOptions = Nothing,
702 Opt_AutoLinkPackages,
703 Opt_ReadUserPackageConf,
705 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
706 -- behaviour the default, to see if anyone notices
710 Opt_MonomorphismRestriction,
721 Opt_PrintBindContents
723 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
724 -- The default -O0 options
727 log_action = \severity srcSpan style msg ->
729 SevInfo -> printErrs (msg style)
730 SevFatal -> printErrs (msg style)
733 printErrs ((mkLocMessage srcSpan msg) style)
734 -- careful (#2302): printErrs prints in UTF-8, whereas
735 -- converting to string first and using hPutStr would
736 -- just emit the low 8 bits of each unicode char.
740 Note [Verbosity levels]
741 ~~~~~~~~~~~~~~~~~~~~~~~
742 0 | print errors & warnings only
743 1 | minimal verbosity: print "compiling M ... done." for each module.
744 2 | equivalent to -dshow-passes
745 3 | equivalent to existing "ghc -v"
746 4 | "ghc -v -ddump-most"
747 5 | "ghc -v -ddump-all"
750 -- | Test whether a 'DynFlag' is set
751 dopt :: DynFlag -> DynFlags -> Bool
752 dopt f dflags = f `elem` (flags dflags)
755 dopt_set :: DynFlags -> DynFlag -> DynFlags
756 dopt_set dfs f = dfs{ flags = f : flags dfs }
758 -- | Unset a 'DynFlag'
759 dopt_unset :: DynFlags -> DynFlag -> DynFlags
760 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
762 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
763 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
764 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
765 -> [a] -- ^ Correctly ordered extracted options
766 getOpts dflags opts = reverse (opts dflags)
767 -- We add to the options from the front, so we need to reverse the list
769 -- | Gets the verbosity flag for the current verbosity level. This is fed to
770 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
771 getVerbFlag :: DynFlags -> String
773 | verbosity dflags >= 3 = "-v"
776 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
777 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
778 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
779 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
780 addCmdlineFramework, addHaddockOpts
781 :: String -> DynFlags -> DynFlags
782 setOutputFile, setOutputHi, setDumpPrefixForce
783 :: Maybe String -> DynFlags -> DynFlags
785 setObjectDir f d = d{ objectDir = Just f}
786 setHiDir f d = d{ hiDir = Just f}
787 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
788 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
789 -- \#included from the .hc file when compiling with -fvia-C.
790 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
791 setDylibInstallName f d = d{ dylibInstallName = Just f}
793 setObjectSuf f d = d{ objectSuf = f}
794 setHiSuf f d = d{ hiSuf = f}
795 setHcSuf f d = d{ hcSuf = f}
797 setOutputFile f d = d{ outputFile = f}
798 setOutputHi f d = d{ outputHi = f}
800 parseDynLibLoaderMode f d =
802 ("deploy", "") -> d{ dynLibLoader = Deployable }
803 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
804 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
805 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
806 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
807 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
809 setDumpPrefixForce f d = d { dumpPrefixForce = f}
811 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
812 -- Config.hs should really use Option.
813 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
815 setPgmL f d = d{ pgm_L = f}
816 setPgmF f d = d{ pgm_F = f}
817 setPgmc f d = d{ pgm_c = (f,[])}
818 setPgmm f d = d{ pgm_m = (f,[])}
819 setPgms f d = d{ pgm_s = (f,[])}
820 setPgma f d = d{ pgm_a = (f,[])}
821 setPgml f d = d{ pgm_l = (f,[])}
822 setPgmdll f d = d{ pgm_dll = (f,[])}
823 setPgmwindres f d = d{ pgm_windres = f}
825 addOptL f d = d{ opt_L = f : opt_L d}
826 addOptP f d = d{ opt_P = f : opt_P d}
827 addOptF f d = d{ opt_F = f : opt_F d}
828 addOptc f d = d{ opt_c = f : opt_c d}
829 addOptm f d = d{ opt_m = f : opt_m d}
830 addOpta f d = d{ opt_a = f : opt_a d}
831 addOptl f d = d{ opt_l = f : opt_l d}
832 addOptwindres f d = d{ opt_windres = f : opt_windres d}
834 setDepMakefile :: FilePath -> DynFlags -> DynFlags
835 setDepMakefile f d = d { depMakefile = deOptDep f }
837 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
838 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
840 addDepExcludeMod :: String -> DynFlags -> DynFlags
842 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
844 addDepSuffix :: FilePath -> DynFlags -> DynFlags
845 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
848 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
849 -- we need to strip the "-optdep" off of the arg
850 deOptDep :: String -> String
851 deOptDep x = case stripPrefix "-optdep" x of
855 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
857 addHaddockOpts f d = d{ haddockOptions = Just f}
859 -- -----------------------------------------------------------------------------
860 -- Command-line options
862 -- | When invoking external tools as part of the compilation pipeline, we
863 -- pass these a sequence of options on the command-line. Rather than
864 -- just using a list of Strings, we use a type that allows us to distinguish
865 -- between filepaths and 'other stuff'. The reason for this is that
866 -- this type gives us a handle on transforming filenames, and filenames only,
867 -- to whatever format they're expected to be on a particular platform.
869 = FileOption -- an entry that _contains_ filename(s) / filepaths.
870 String -- a non-filepath prefix that shouldn't be
871 -- transformed (e.g., "/out=")
872 String -- the filepath/filename portion
875 showOpt :: Option -> String
876 showOpt (FileOption pre f) = pre ++ f
877 showOpt (Option s) = s
879 -----------------------------------------------------------------------------
880 -- Setting the optimisation level
882 updOptLevel :: Int -> DynFlags -> DynFlags
883 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
885 = dfs2{ optLevel = final_n }
887 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
888 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
889 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
891 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
892 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
894 optLevelFlags :: [([Int], DynFlag)]
896 = [ ([0], Opt_IgnoreInterfacePragmas)
897 , ([0], Opt_OmitInterfacePragmas)
899 , ([1,2], Opt_IgnoreAsserts)
900 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
902 , ([1,2], Opt_DoEtaReduction)
903 , ([1,2], Opt_CaseMerge)
904 , ([1,2], Opt_Strictness)
906 , ([1,2], Opt_FullLaziness)
907 , ([1,2], Opt_Specialise)
908 , ([1,2], Opt_FloatIn)
910 , ([2], Opt_LiberateCase)
911 , ([2], Opt_SpecConstr)
913 -- , ([2], Opt_StaticArgumentTransformation)
914 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
915 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
916 -- several improvements to the heuristics, and I'm concerned that without
917 -- those changes SAT will interfere with some attempts to write "high
918 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
919 -- this year. In particular, the version in HEAD lacks the tail call
920 -- criterion, so many things that look like reasonable loops will be
921 -- turned into functions with extra (unneccesary) thunk creation.
923 , ([0,1,2], Opt_DoLambdaEtaExpansion)
924 -- This one is important for a tiresome reason:
925 -- we want to make sure that the bindings for data
926 -- constructors are eta-expanded. This is probably
927 -- a good thing anyway, but it seems fragile.
930 -- -----------------------------------------------------------------------------
931 -- Standard sets of warning options
933 standardWarnings :: [DynFlag]
935 = [ Opt_WarnWarningsDeprecations,
936 Opt_WarnDeprecatedFlags,
937 Opt_WarnUnrecognisedPragmas,
938 Opt_WarnOverlappingPatterns,
939 Opt_WarnMissingFields,
940 Opt_WarnMissingMethods,
941 Opt_WarnDuplicateExports,
942 Opt_WarnLazyUnliftedBindings,
943 Opt_WarnDodgyForeignImports,
947 minusWOpts :: [DynFlag]
949 = standardWarnings ++
950 [ Opt_WarnUnusedBinds,
951 Opt_WarnUnusedMatches,
952 Opt_WarnUnusedImports,
953 Opt_WarnIncompletePatterns,
954 Opt_WarnDodgyExports,
958 minusWallOpts :: [DynFlag]
961 [ Opt_WarnTypeDefaults,
962 Opt_WarnNameShadowing,
969 -- minuswRemovesOpts should be every warning option
970 minuswRemovesOpts :: [DynFlag]
973 [Opt_WarnImplicitPrelude,
974 Opt_WarnIncompletePatternsRecUpd,
975 Opt_WarnSimplePatterns,
976 Opt_WarnMonomorphism,
977 Opt_WarnUnrecognisedPragmas,
981 -- -----------------------------------------------------------------------------
982 -- CoreToDo: abstraction of core-to-core passes to run.
984 data CoreToDo -- These are diff core-to-core passes,
985 -- which may be invoked in any order,
986 -- as many times as you like.
988 = CoreDoSimplify -- The core-to-core simplifier.
991 -- Each run of the simplifier can take a different
992 -- set of simplifier-specific flags.
994 | CoreDoFloatOutwards FloatOutSwitches
999 | CoreDoWorkerWrapper
1000 | CoreDoSpecialising
1002 | CoreDoOldStrictness
1005 | CoreDoRuleCheck CompilerPhase String -- Check for non-application of rules
1006 -- matching this string
1007 | CoreDoVectorisation PackageId
1008 | CoreDoNothing -- Useful when building up
1009 | CoreDoPasses [CoreToDo] -- lists of these things
1012 data SimplifierMode -- See comments in SimplMonad
1014 { sm_rules :: Bool -- Whether RULES are enabled
1015 , sm_inline :: Bool } -- Whether inlining is enabled
1018 { sm_num :: Int -- Phase number; counts downward so 0 is last phase
1019 , sm_names :: [String] } -- Name(s) of the phase
1021 instance Outputable SimplifierMode where
1022 ppr (SimplPhase { sm_num = n, sm_names = ss })
1023 = int n <+> brackets (text (concat $ intersperse "," ss))
1024 ppr (SimplGently { sm_rules = r, sm_inline = i })
1025 = ptext (sLit "gentle") <>
1026 brackets (pp_flag r (sLit "rules") <> comma <>
1027 pp_flag i (sLit "inline"))
1029 pp_flag f s = ppUnless f (ptext (sLit "no")) <+> ptext s
1031 data SimplifierSwitch
1032 = MaxSimplifierIterations Int
1035 data FloatOutSwitches = FloatOutSwitches {
1036 floatOutLambdas :: Bool, -- ^ True <=> float lambdas to top level
1037 floatOutConstants :: Bool -- ^ True <=> float constants to top level,
1038 -- even if they do not escape a lambda
1041 instance Outputable FloatOutSwitches where
1042 ppr = pprFloatOutSwitches
1044 pprFloatOutSwitches :: FloatOutSwitches -> SDoc
1045 pprFloatOutSwitches sw = pp_not (floatOutLambdas sw) <+> text "lambdas" <> comma
1046 <+> pp_not (floatOutConstants sw) <+> text "constants"
1049 pp_not False = text "not"
1051 -- | Switches that specify the minimum amount of floating out
1052 -- gentleFloatOutSwitches :: FloatOutSwitches
1053 -- gentleFloatOutSwitches = FloatOutSwitches False False
1055 -- | Switches that do not specify floating out of lambdas, just of constants
1056 constantsOnlyFloatOutSwitches :: FloatOutSwitches
1057 constantsOnlyFloatOutSwitches = FloatOutSwitches False True
1060 -- The core-to-core pass ordering is derived from the DynFlags:
1061 runWhen :: Bool -> CoreToDo -> CoreToDo
1062 runWhen True do_this = do_this
1063 runWhen False _ = CoreDoNothing
1065 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
1066 runMaybe (Just x) f = f x
1067 runMaybe Nothing _ = CoreDoNothing
1069 getCoreToDo :: DynFlags -> [CoreToDo]
1071 | Just todo <- coreToDo dflags = todo -- set explicitly by user
1072 | otherwise = core_todo
1074 opt_level = optLevel dflags
1075 phases = simplPhases dflags
1076 max_iter = maxSimplIterations dflags
1077 strictness = dopt Opt_Strictness dflags
1078 full_laziness = dopt Opt_FullLaziness dflags
1079 do_specialise = dopt Opt_Specialise dflags
1080 do_float_in = dopt Opt_FloatIn dflags
1081 cse = dopt Opt_CSE dflags
1082 spec_constr = dopt Opt_SpecConstr dflags
1083 liberate_case = dopt Opt_LiberateCase dflags
1084 rule_check = ruleCheck dflags
1085 static_args = dopt Opt_StaticArgumentTransformation dflags
1087 maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
1089 maybe_strictness_before phase
1090 = runWhen (phase `elem` strictnessBefore dflags) CoreDoStrictness
1092 simpl_phase phase names iter
1094 [ maybe_strictness_before phase,
1095 CoreDoSimplify (SimplPhase phase names) [
1096 MaxSimplifierIterations iter
1098 maybe_rule_check phase
1102 = runWhen (dopt Opt_Vectorise dflags)
1103 $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
1106 -- By default, we have 2 phases before phase 0.
1108 -- Want to run with inline phase 2 after the specialiser to give
1109 -- maximum chance for fusion to work before we inline build/augment
1110 -- in phase 1. This made a difference in 'ansi' where an
1111 -- overloaded function wasn't inlined till too late.
1113 -- Need phase 1 so that build/augment get
1114 -- inlined. I found that spectral/hartel/genfft lost some useful
1115 -- strictness in the function sumcode' if augment is not inlined
1116 -- before strictness analysis runs
1117 simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
1118 | phase <- [phases, phases-1 .. 1] ]
1121 -- initial simplify: mk specialiser happy: minimum effort please
1122 simpl_gently = CoreDoSimplify
1123 (SimplGently { sm_rules = True, sm_inline = False })
1125 -- Simplify "gently"
1126 -- Don't inline anything till full laziness has bitten
1127 -- In particular, inlining wrappers inhibits floating
1128 -- e.g. ...(case f x of ...)...
1129 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
1130 -- ==> ...(case x of I# x# -> case fw x# of ...)...
1131 -- and now the redex (f x) isn't floatable any more
1132 -- Similarly, don't apply any rules until after full
1133 -- laziness. Notably, list fusion can prevent floating.
1135 NoCaseOfCase, -- Don't do case-of-case transformations.
1136 -- This makes full laziness work better
1137 MaxSimplifierIterations max_iter
1141 if opt_level == 0 then
1143 simpl_phase 0 ["final"] max_iter]
1144 else {- opt_level >= 1 -} [
1146 -- We want to do the static argument transform before full laziness as it
1147 -- may expose extra opportunities to float things outwards. However, to fix
1148 -- up the output of the transformation we need at do at least one simplify
1149 -- after this before anything else
1150 runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1152 -- We run vectorisation here for now, but we might also try to run
1156 -- initial simplify: mk specialiser happy: minimum effort please
1159 -- Specialisation is best done before full laziness
1160 -- so that overloaded functions have all their dictionary lambdas manifest
1161 runWhen do_specialise CoreDoSpecialising,
1163 runWhen full_laziness (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1164 -- Was: gentleFloatOutSwitches
1165 -- I have no idea why, but not floating constants to top level is
1166 -- very bad in some cases.
1167 -- Notably: p_ident in spectral/rewrite
1168 -- Changing from "gentle" to "constantsOnly" improved
1169 -- rewrite's allocation by 19%, and made 0.0% difference
1170 -- to any other nofib benchmark
1172 runWhen do_float_in CoreDoFloatInwards,
1176 -- Phase 0: allow all Ids to be inlined now
1177 -- This gets foldr inlined before strictness analysis
1179 -- At least 3 iterations because otherwise we land up with
1180 -- huge dead expressions because of an infelicity in the
1182 -- let k = BIG in foldr k z xs
1183 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1184 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1186 simpl_phase 0 ["main"] (max max_iter 3),
1188 runWhen strictness (CoreDoPasses [
1190 CoreDoWorkerWrapper,
1192 simpl_phase 0 ["post-worker-wrapper"] max_iter
1195 runWhen full_laziness
1196 (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1197 -- nofib/spectral/hartel/wang doubles in speed if you
1198 -- do full laziness late in the day. It only happens
1199 -- after fusion and other stuff, so the early pass doesn't
1200 -- catch it. For the record, the redex is
1201 -- f_el22 (f_el21 r_midblock)
1204 runWhen cse CoreCSE,
1205 -- We want CSE to follow the final full-laziness pass, because it may
1206 -- succeed in commoning up things floated out by full laziness.
1207 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1209 runWhen do_float_in CoreDoFloatInwards,
1213 -- Case-liberation for -O2. This should be after
1214 -- strictness analysis and the simplification which follows it.
1215 runWhen liberate_case (CoreDoPasses [
1217 simpl_phase 0 ["post-liberate-case"] max_iter
1218 ]), -- Run the simplifier after LiberateCase to vastly
1219 -- reduce the possiblility of shadowing
1220 -- Reason: see Note [Shadowing] in SpecConstr.lhs
1222 runWhen spec_constr CoreDoSpecConstr,
1226 -- Final clean-up simplification:
1227 simpl_phase 0 ["final"] max_iter
1230 -- -----------------------------------------------------------------------------
1231 -- StgToDo: abstraction of stg-to-stg passes to run.
1234 = StgDoMassageForProfiling -- should be (next to) last
1235 -- There's also setStgVarInfo, but its absolute "lastness"
1236 -- is so critical that it is hardwired in (no flag).
1239 getStgToDo :: DynFlags -> [StgToDo]
1241 | Just todo <- stgToDo dflags = todo -- set explicitly by user
1244 stg_stats = dopt Opt_StgStats dflags
1246 todo1 = if stg_stats then [D_stg_stats] else []
1248 todo2 | WayProf `elem` wayNames dflags
1249 = StgDoMassageForProfiling : todo1
1253 -- -----------------------------------------------------------------------------
1256 allFlags :: [String]
1257 allFlags = map ('-':) $
1258 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1259 map ("fno-"++) flags ++
1260 map ("f"++) flags ++
1261 map ("X"++) supportedLanguages ++
1262 map ("XNo"++) supportedLanguages
1263 where ok (PrefixPred _ _) = False
1265 flags = [ name | (name, _, _) <- fFlags ]
1267 dynamic_flags :: [Flag DynP]
1269 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1270 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1271 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1272 , Flag "#include" (HasArg (addCmdlineHCInclude))
1273 (Deprecated "No longer has any effect")
1274 , Flag "v" (OptIntSuffix setVerbosity) Supported
1276 ------- Specific phases --------------------------------------------
1277 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1278 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1279 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1280 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1281 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1282 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1283 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1284 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1285 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1286 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1288 , Flag "optL" (HasArg (upd . addOptL)) Supported
1289 , Flag "optP" (HasArg (upd . addOptP)) Supported
1290 , Flag "optF" (HasArg (upd . addOptF)) Supported
1291 , Flag "optc" (HasArg (upd . addOptc)) Supported
1292 , Flag "optm" (HasArg (upd . addOptm)) Supported
1293 , Flag "opta" (HasArg (upd . addOpta)) Supported
1294 , Flag "optl" (HasArg (upd . addOptl)) Supported
1295 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1298 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1301 -------- ghc -M -----------------------------------------------------
1302 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1303 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1304 (Deprecated "Use -dep-suffix instead")
1305 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1306 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1307 (Deprecated "Use -dep-makefile instead")
1308 , Flag "optdep-w" (NoArg (return ()))
1309 (Deprecated "-optdep-w doesn't do anything")
1310 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1311 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1312 (Deprecated "Use -include-pkg-deps instead")
1313 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1314 (Deprecated "Use -include-pkg-deps instead")
1315 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1316 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1317 (Deprecated "Use -exclude-module instead")
1318 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1319 (Deprecated "Use -exclude-module instead")
1321 -------- Linking ----------------------------------------------------
1322 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1324 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1325 (Deprecated "Use -c instead")
1326 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1328 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1330 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1332 ------- Libraries ---------------------------------------------------
1333 , Flag "L" (Prefix addLibraryPath ) Supported
1334 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1336 ------- Frameworks --------------------------------------------------
1337 -- -framework-path should really be -F ...
1338 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1339 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1341 ------- Output Redirection ------------------------------------------
1342 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1343 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1344 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1345 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1346 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1347 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1348 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1349 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1350 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1351 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1352 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1355 ------- Keeping temporary files -------------------------------------
1356 -- These can be singular (think ghc -c) or plural (think ghc --make)
1357 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1358 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1359 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1360 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1361 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1362 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1363 -- This only makes sense as plural
1364 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1366 ------- Miscellaneous ----------------------------------------------
1367 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1368 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1369 , Flag "main-is" (SepArg setMainIs ) Supported
1370 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1371 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1372 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1374 ------- recompilation checker --------------------------------------
1375 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1376 (Deprecated "Use -fno-force-recomp instead")
1377 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1378 (Deprecated "Use -fforce-recomp instead")
1380 ------ HsCpp opts ---------------------------------------------------
1381 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1382 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1384 ------- Include/Import Paths ----------------------------------------
1385 , Flag "I" (Prefix addIncludePath) Supported
1386 , Flag "i" (OptPrefix addImportPath ) Supported
1388 ------ Debugging ----------------------------------------------------
1389 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1391 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1393 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1395 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1397 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1399 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1401 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1403 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1405 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1407 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1409 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1411 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1413 , Flag "ddump-asm-regalloc-stages"
1414 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1416 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1418 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1420 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1422 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1424 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1426 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1428 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1430 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1432 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1434 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1436 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1438 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1440 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1442 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1444 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1446 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1448 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1450 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1452 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1454 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1456 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1458 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1460 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1462 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1464 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1466 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1468 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1470 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1472 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1474 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1476 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1478 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1480 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1482 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1483 ; setVerboseCore2Core }))
1485 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1487 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1489 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1491 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1493 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1495 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1497 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1499 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1501 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1503 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1506 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1508 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1510 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1512 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1514 , Flag "dshow-passes"
1515 (NoArg (do forceRecompile
1516 setVerbosity (Just 2)))
1518 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1521 ------ Machine dependant (-m<blah>) stuff ---------------------------
1523 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1525 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1527 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1530 ------ Warning opts -------------------------------------------------
1531 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1533 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1535 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1537 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1539 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1540 (Deprecated "Use -w instead")
1541 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1544 ------ Optimisation flags ------------------------------------------
1545 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1546 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1547 (Deprecated "Use -O0 instead")
1548 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1549 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1551 -- If the number is missing, use 1
1553 , Flag "fsimplifier-phases"
1554 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1556 , Flag "fmax-simplifier-iterations"
1557 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1560 , Flag "fspec-constr-threshold"
1561 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1563 , Flag "fno-spec-constr-threshold"
1564 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1566 , Flag "fspec-constr-count"
1567 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1569 , Flag "fno-spec-constr-count"
1570 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1572 , Flag "fliberate-case-threshold"
1573 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1575 , Flag "fno-liberate-case-threshold"
1576 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1579 , Flag "frule-check"
1580 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1582 , Flag "fcontext-stack"
1583 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1586 , Flag "fstrictness-before"
1587 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1590 ------ Profiling ----------------------------------------------------
1592 -- XXX Should the -f* flags be deprecated?
1593 -- They don't seem to be documented
1594 , Flag "fauto-sccs-on-all-toplevs"
1595 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1598 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1600 , Flag "no-auto-all"
1601 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1603 , Flag "fauto-sccs-on-exported-toplevs"
1604 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1607 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1610 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1612 , Flag "fauto-sccs-on-individual-cafs"
1613 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1616 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1619 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1622 ------ DPH flags ----------------------------------------------------
1625 (NoArg (setDPHBackend DPHSeq))
1628 (NoArg (setDPHBackend DPHPar))
1631 (NoArg (setDPHBackend DPHThis))
1634 ------ Compiler flags -----------------------------------------------
1636 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1637 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1638 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1640 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1641 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1642 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1644 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1646 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1649 ++ map (mkFlag True "f" setDynFlag ) fFlags
1650 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1651 ++ map (mkFlag True "X" setDynFlag ) xFlags
1652 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1654 package_flags :: [Flag DynP]
1656 ------- Packages ----------------------------------------------------
1657 Flag "package-conf" (HasArg extraPkgConf_) Supported
1658 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1660 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1661 , Flag "package-id" (HasArg exposePackageId) Supported
1662 , Flag "package" (HasArg exposePackage) Supported
1663 , Flag "hide-package" (HasArg hidePackage) Supported
1664 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1666 , Flag "ignore-package" (HasArg ignorePackage)
1668 , Flag "syslib" (HasArg exposePackage)
1669 (Deprecated "Use -package instead")
1672 mkFlag :: Bool -- ^ True <=> it should be turned on
1673 -> String -- ^ The flag prefix
1674 -> (DynFlag -> DynP ())
1675 -> (String, DynFlag, Bool -> Deprecated)
1677 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1678 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1680 deprecatedForLanguage :: String -> Bool -> Deprecated
1681 deprecatedForLanguage lang turn_on
1682 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1684 flag | turn_on = lang
1685 | otherwise = "No"++lang
1687 useInstead :: String -> Bool -> Deprecated
1688 useInstead flag turn_on
1689 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1691 no = if turn_on then "" else "no-"
1693 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1694 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1696 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1697 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1698 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1699 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1700 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1701 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1702 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1703 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1704 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1705 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1706 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1707 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1708 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1709 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1710 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1711 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1712 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1713 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1714 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1715 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1716 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1717 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1718 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1719 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1720 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1721 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1722 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1723 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1724 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1725 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1726 ( "strictness", Opt_Strictness, const Supported ),
1727 ( "specialise", Opt_Specialise, const Supported ),
1728 ( "float-in", Opt_FloatIn, const Supported ),
1729 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1730 ( "full-laziness", Opt_FullLaziness, const Supported ),
1731 ( "liberate-case", Opt_LiberateCase, const Supported ),
1732 ( "spec-constr", Opt_SpecConstr, const Supported ),
1733 ( "cse", Opt_CSE, const Supported ),
1734 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1735 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1736 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1737 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1738 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1739 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1740 ( "case-merge", Opt_CaseMerge, const Supported ),
1741 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1742 ( "method-sharing", Opt_MethodSharing, const Supported ),
1743 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1744 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1745 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1746 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1747 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1748 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1749 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1750 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1751 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1752 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1753 ( "break-on-error", Opt_BreakOnError, const Supported ),
1754 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1755 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1756 ( "run-cps", Opt_RunCPS, const Supported ),
1757 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1758 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1759 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1760 ( "vectorise", Opt_Vectorise, const Supported ),
1761 ( "regs-graph", Opt_RegsGraph, const Supported ),
1762 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1763 ( "th", Opt_TemplateHaskell,
1764 deprecatedForLanguage "TemplateHaskell" ),
1765 ( "fi", Opt_ForeignFunctionInterface,
1766 deprecatedForLanguage "ForeignFunctionInterface" ),
1767 ( "ffi", Opt_ForeignFunctionInterface,
1768 deprecatedForLanguage "ForeignFunctionInterface" ),
1769 ( "arrows", Opt_Arrows,
1770 deprecatedForLanguage "Arrows" ),
1771 ( "generics", Opt_Generics,
1772 deprecatedForLanguage "Generics" ),
1773 ( "implicit-prelude", Opt_ImplicitPrelude,
1774 deprecatedForLanguage "ImplicitPrelude" ),
1775 ( "bang-patterns", Opt_BangPatterns,
1776 deprecatedForLanguage "BangPatterns" ),
1777 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1778 deprecatedForLanguage "MonomorphismRestriction" ),
1779 ( "mono-pat-binds", Opt_MonoPatBinds,
1780 deprecatedForLanguage "MonoPatBinds" ),
1781 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1782 deprecatedForLanguage "ExtendedDefaultRules" ),
1783 ( "implicit-params", Opt_ImplicitParams,
1784 deprecatedForLanguage "ImplicitParams" ),
1785 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1786 deprecatedForLanguage "ScopedTypeVariables" ),
1788 deprecatedForLanguage "PArr" ),
1789 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1790 deprecatedForLanguage "OverlappingInstances" ),
1791 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1792 deprecatedForLanguage "UndecidableInstances" ),
1793 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1794 deprecatedForLanguage "IncoherentInstances" ),
1795 ( "gen-manifest", Opt_GenManifest, const Supported ),
1796 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1797 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1798 ( "shared-implib", Opt_SharedImplib, const Supported ),
1799 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1800 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1803 supportedLanguages :: [String]
1804 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1806 -- This may contain duplicates
1807 languageOptions :: [DynFlag]
1808 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1810 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1811 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1813 ( "CPP", Opt_Cpp, const Supported ),
1814 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1815 ( "TupleSections", Opt_TupleSections, const Supported ),
1816 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1817 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1818 ( "MagicHash", Opt_MagicHash, const Supported ),
1819 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1820 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1821 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1822 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1823 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1824 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1825 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1826 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1827 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1828 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1829 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1830 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1831 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1832 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1833 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1834 ( "RecursiveDo", Opt_RecursiveDo,
1835 deprecatedForLanguage "DoRec"),
1836 ( "DoRec", Opt_DoRec, const Supported ),
1837 ( "Arrows", Opt_Arrows, const Supported ),
1838 ( "PArr", Opt_PArr, const Supported ),
1839 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1840 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1841 ( "Generics", Opt_Generics, const Supported ),
1843 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1844 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1845 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1846 ( "RecordPuns", Opt_RecordPuns,
1847 deprecatedForLanguage "NamedFieldPuns" ),
1848 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1849 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1850 ( "GADTs", Opt_GADTs, const Supported ),
1851 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1852 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1853 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1855 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1857 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1858 -- On by default (which is not strictly H98):
1859 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1860 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1861 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1862 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1863 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1864 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1865 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1866 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1868 ( "PatternSignatures", Opt_ScopedTypeVariables,
1869 deprecatedForLanguage "ScopedTypeVariables" ),
1871 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1872 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1873 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1874 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1875 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1876 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1877 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1878 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1879 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1880 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1881 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1882 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1883 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1884 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1885 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1886 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1887 ( "PackageImports", Opt_PackageImports, const Supported ),
1888 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1891 impliedFlags :: [(DynFlag, DynFlag)]
1893 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1894 , (Opt_Rank2Types, Opt_ExplicitForAll)
1895 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1896 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1897 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1898 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1900 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1901 -- be completely rigid for GADTs
1903 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1904 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1905 -- all over the place
1907 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1908 -- Note [Scoped tyvars] in TcBinds
1909 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1911 -- Record wild-cards implies field disambiguation
1912 -- Otherwise if you write (C {..}) you may well get
1913 -- stuff like " 'a' not in scope ", which is a bit silly
1914 -- if the compiler has just filled in field 'a' of constructor 'C'
1915 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1918 glasgowExtsFlags :: [DynFlag]
1919 glasgowExtsFlags = [
1920 Opt_PrintExplicitForalls
1921 , Opt_ForeignFunctionInterface
1922 , Opt_UnliftedFFITypes
1924 , Opt_ImplicitParams
1925 , Opt_ScopedTypeVariables
1927 , Opt_TypeSynonymInstances
1928 , Opt_StandaloneDeriving
1929 , Opt_DeriveDataTypeable
1931 , Opt_DeriveFoldable
1932 , Opt_DeriveTraversable
1933 , Opt_FlexibleContexts
1934 , Opt_FlexibleInstances
1935 , Opt_ConstrainedClassMethods
1936 , Opt_MultiParamTypeClasses
1937 , Opt_FunctionalDependencies
1939 , Opt_PolymorphicComponents
1940 , Opt_ExistentialQuantification
1942 , Opt_PostfixOperators
1944 , Opt_LiberalTypeSynonyms
1948 , Opt_ParallelListComp
1949 , Opt_EmptyDataDecls
1950 , Opt_KindSignatures
1951 , Opt_GeneralizedNewtypeDeriving
1952 , Opt_TypeFamilies ]
1954 -- -----------------------------------------------------------------------------
1955 -- Parsing the dynamic flags.
1957 -- | Parse dynamic flags from a list of command line arguments. Returns the
1958 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1959 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1960 -- flags or missing arguments).
1961 parseDynamicFlags :: Monad m =>
1962 DynFlags -> [Located String]
1963 -> m (DynFlags, [Located String], [Located String])
1964 -- ^ Updated 'DynFlags', left-over arguments, and
1965 -- list of warnings.
1966 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1968 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1969 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1970 parseDynamicNoPackageFlags :: Monad m =>
1971 DynFlags -> [Located String]
1972 -> m (DynFlags, [Located String], [Located String])
1973 -- ^ Updated 'DynFlags', left-over arguments, and
1974 -- list of warnings.
1975 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1977 parseDynamicFlags_ :: Monad m =>
1978 DynFlags -> [Located String] -> Bool
1979 -> m (DynFlags, [Located String], [Located String])
1980 parseDynamicFlags_ dflags0 args pkg_flags = do
1981 -- XXX Legacy support code
1982 -- We used to accept things like
1983 -- optdep-f -optdepdepend
1984 -- optdep-f -optdep depend
1985 -- optdep -f -optdepdepend
1986 -- optdep -f -optdep depend
1987 -- but the spaces trip up proper argument handling. So get rid of them.
1988 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1989 f (x : xs) = x : f xs
1993 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1994 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1995 | otherwise = dynamic_flags
1997 let ((leftover, errs, warns), dflags1)
1998 = runCmdLine (processArgs flag_spec args') dflags0
1999 when (not (null errs)) $ ghcError $ errorsToGhcException errs
2001 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
2002 -- isn't up to the job. We know that if hscTarget == HscC, then the
2003 -- user has explicitly used -fvia-C, because -fasm is the default,
2004 -- unless there is no NCG on this platform. The latter case is
2005 -- checked when the -fPIC flag is parsed.
2007 let (pic_warns, dflags2) =
2008 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
2009 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
2010 dflags1{ hscTarget = HscAsm })
2013 return (dflags2, leftover, pic_warns ++ warns)
2015 type DynP = CmdLineP DynFlags
2017 upd :: (DynFlags -> DynFlags) -> DynP ()
2019 dfs <- getCmdLineState
2020 putCmdLineState $! (f dfs)
2022 --------------------------
2023 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2024 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
2025 ; mapM_ setDynFlag deps }
2027 deps = [ d | (f', d) <- impliedFlags, f' == f ]
2028 -- When you set f, set the ones it implies
2029 -- NB: use setDynFlag recursively, in case the implied flags
2030 -- implies further flags
2031 -- When you un-set f, however, we don't un-set the things it implies
2032 -- (except for -fno-glasgow-exts, which is treated specially)
2034 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2036 --------------------------
2037 setDumpFlag :: DynFlag -> OptKind DynP
2038 setDumpFlag dump_flag
2039 = NoArg (do { setDynFlag dump_flag
2040 ; when want_recomp forceRecompile })
2042 -- Certain dumpy-things are really interested in what's going
2043 -- on during recompilation checking, so in those cases we
2044 -- don't want to turn it off.
2045 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2046 Opt_D_dump_hi_diffs]
2048 forceRecompile :: DynP ()
2049 -- Whenver we -ddump, force recompilation (by switching off the
2050 -- recompilation checker), else you don't see the dump! However,
2051 -- don't switch it off in --make mode, else *everything* gets
2052 -- recompiled which probably isn't what you want
2053 forceRecompile = do { dfs <- getCmdLineState
2054 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2056 force_recomp dfs = isOneShot (ghcMode dfs)
2058 setVerboseCore2Core :: DynP ()
2059 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
2061 upd (\s -> s { shouldDumpSimplPhase = const True })
2063 setDumpSimplPhases :: String -> DynP ()
2064 setDumpSimplPhases s = do forceRecompile
2065 upd (\s -> s { shouldDumpSimplPhase = spec })
2067 spec :: SimplifierMode -> Bool
2069 . map (join (&&) . map match . split ':')
2075 join :: (Bool -> Bool -> Bool)
2076 -> [SimplifierMode -> Bool]
2077 -> SimplifierMode -> Bool
2078 join _ [] = const True
2079 join op ss = foldr1 (\f g x -> f x `op` g x) ss
2081 match :: String -> SimplifierMode -> Bool
2082 match "" = const True
2083 match s = case reads s of
2084 [(n,"")] -> phase_num n
2087 phase_num :: Int -> SimplifierMode -> Bool
2088 phase_num n (SimplPhase k _) = n == k
2089 phase_num _ _ = False
2091 phase_name :: String -> SimplifierMode -> Bool
2092 phase_name s (SimplGently {}) = s == "gentle"
2093 phase_name s (SimplPhase { sm_names = ss }) = s `elem` ss
2095 setVerbosity :: Maybe Int -> DynP ()
2096 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2098 addCmdlineHCInclude :: String -> DynP ()
2099 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2101 extraPkgConf_ :: FilePath -> DynP ()
2102 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2104 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2106 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2108 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2110 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2112 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2114 setPackageName :: String -> DynFlags -> DynFlags
2115 setPackageName p s = s{ thisPackage = stringToPackageId p }
2117 -- If we're linking a binary, then only targets that produce object
2118 -- code are allowed (requests for other target types are ignored).
2119 setTarget :: HscTarget -> DynP ()
2120 setTarget l = upd set
2123 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2126 -- Changes the target only if we're compiling object code. This is
2127 -- used by -fasm and -fvia-C, which switch from one to the other, but
2128 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
2129 -- can be safely used in an OPTIONS_GHC pragma.
2130 setObjTarget :: HscTarget -> DynP ()
2131 setObjTarget l = upd set
2134 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2137 setOptLevel :: Int -> DynFlags -> DynFlags
2138 setOptLevel n dflags
2139 | hscTarget dflags == HscInterpreted && n > 0
2141 -- not in IO any more, oh well:
2142 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2144 = updOptLevel n dflags
2147 -- -Odph is equivalent to
2149 -- -O2 optimise as much as possible
2150 -- -fno-method-sharing sharing specialisation defeats fusion
2152 -- -fdicts-cheap always inline dictionaries
2153 -- -fmax-simplifier-iterations20 this is necessary sometimes
2154 -- -fsimplifier-phases=3 we use an additional simplifier phase
2156 -- -fno-spec-constr-threshold run SpecConstr even for big loops
2157 -- -fno-spec-constr-count SpecConstr as much as possible
2158 -- -finline-enough-args hack to prevent excessive inlining
2160 setDPHOpt :: DynFlags -> DynFlags
2161 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2163 , specConstrThreshold = Nothing
2164 , specConstrCount = Nothing
2166 `dopt_set` Opt_DictsCheap
2167 `dopt_unset` Opt_MethodSharing
2169 data DPHBackend = DPHPar
2172 deriving(Eq, Ord, Enum, Show)
2174 setDPHBackend :: DPHBackend -> DynP ()
2175 setDPHBackend backend
2177 upd $ \dflags -> dflags { dphBackend = backend }
2178 mapM_ exposePackage (dph_packages backend)
2180 dph_packages DPHThis = []
2181 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
2182 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
2184 dphPackage :: DynFlags -> PackageId
2185 dphPackage dflags = case dphBackend dflags of
2186 DPHPar -> dphParPackageId
2187 DPHSeq -> dphSeqPackageId
2188 DPHThis -> thisPackage dflags
2190 setMainIs :: String -> DynP ()
2192 | not (null main_fn) && isLower (head main_fn)
2193 -- The arg looked like "Foo.Bar.baz"
2194 = upd $ \d -> d{ mainFunIs = Just main_fn,
2195 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2197 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2198 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2200 | otherwise -- The arg looked like "baz"
2201 = upd $ \d -> d{ mainFunIs = Just arg }
2203 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2205 -----------------------------------------------------------------------------
2206 -- Paths & Libraries
2208 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2210 -- -i on its own deletes the import paths
2211 addImportPath "" = upd (\s -> s{importPaths = []})
2212 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2216 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2219 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2221 addFrameworkPath p =
2222 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2224 #ifndef mingw32_TARGET_OS
2225 split_marker :: Char
2226 split_marker = ':' -- not configurable (ToDo)
2229 splitPathList :: String -> [String]
2230 splitPathList s = filter notNull (splitUp s)
2231 -- empty paths are ignored: there might be a trailing
2232 -- ':' in the initial list, for example. Empty paths can
2233 -- cause confusion when they are translated into -I options
2234 -- for passing to gcc.
2236 #ifndef mingw32_TARGET_OS
2237 splitUp xs = split split_marker xs
2239 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2241 -- That is, if "foo:bar:baz" is used, this interpreted as
2242 -- consisting of three entries, 'foo', 'bar', 'baz'.
2243 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2244 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2246 -- Notice that no attempt is made to fully replace the 'standard'
2247 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2248 -- that this will cause too much breakage for users & ':' will
2249 -- work fine even with DOS paths, if you're not insisting on being silly.
2252 splitUp (x:':':div:xs) | div `elem` dir_markers
2253 = ((x:':':div:p): splitUp rs)
2255 (p,rs) = findNextPath xs
2256 -- we used to check for existence of the path here, but that
2257 -- required the IO monad to be threaded through the command-line
2258 -- parser which is quite inconvenient. The
2259 splitUp xs = cons p (splitUp rs)
2261 (p,rs) = findNextPath xs
2266 -- will be called either when we've consumed nought or the
2267 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2268 -- finding the next split marker.
2270 case break (`elem` split_markers) xs of
2271 (p, _:ds) -> (p, ds)
2274 split_markers :: [Char]
2275 split_markers = [':', ';']
2277 dir_markers :: [Char]
2278 dir_markers = ['/', '\\']
2281 -- -----------------------------------------------------------------------------
2282 -- tmpDir, where we store temporary files.
2284 setTmpDir :: FilePath -> DynFlags -> DynFlags
2285 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2286 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2287 -- seem necessary now --SDM 7/2/2008
2289 -----------------------------------------------------------------------------
2292 setOptHpcDir :: String -> DynP ()
2293 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2295 -----------------------------------------------------------------------------
2296 -- Via-C compilation stuff
2298 -- There are some options that we need to pass to gcc when compiling
2299 -- Haskell code via C, but are only supported by recent versions of
2300 -- gcc. The configure script decides which of these options we need,
2301 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2302 -- read before each via-C compilation. The advantage of having these
2303 -- in a separate file is that the file can be created at install-time
2304 -- depending on the available gcc version, and even re-generated later
2305 -- if gcc is upgraded.
2307 -- The options below are not dependent on the version of gcc, only the
2310 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2311 [String]) -- for registerised HC compilations
2312 machdepCCOpts _dflags
2313 #if alpha_TARGET_ARCH
2315 #ifdef HAVE_THREADED_RTS_SUPPORT
2319 -- For now, to suppress the gcc warning "call-clobbered
2320 -- register used for global register variable", we simply
2321 -- disable all warnings altogether using the -w flag. Oh well.
2323 #elif hppa_TARGET_ARCH
2324 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2325 -- (very nice, but too bad the HP /usr/include files don't agree.)
2326 = ( ["-D_HPUX_SOURCE"], [] )
2328 #elif m68k_TARGET_ARCH
2329 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2330 -- popping of args to routines to be explicit; if we let things
2331 -- be deferred 'til after an STGJUMP, imminent death is certain!
2333 -- -fomit-frame-pointer : *don't*
2334 -- It's better to have a6 completely tied up being a frame pointer
2335 -- rather than let GCC pick random things to do with it.
2336 -- (If we want to steal a6, then we would try to do things
2337 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2338 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2340 #elif i386_TARGET_ARCH
2341 -- -fno-defer-pop : basically the same game as for m68k
2343 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2344 -- the fp (%ebp) for our register maps.
2345 = let n_regs = stolen_x86_regs _dflags
2348 #if darwin_TARGET_OS
2349 -- By default, gcc on OS X will generate SSE
2350 -- instructions, which need things 16-byte aligned,
2351 -- but we don't 16-byte align things. Thus drop
2352 -- back to generic i686 compatibility. Trac #2983.
2354 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2355 ["-march=i686", "-m32"],
2357 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2361 "-fomit-frame-pointer",
2362 -- we want -fno-builtin, because when gcc inlines
2363 -- built-in functions like memcpy() it tends to
2364 -- run out of registers, requiring -monly-n-regs
2366 "-DSTOLEN_X86_REGS="++show n_regs ]
2369 #elif ia64_TARGET_ARCH
2370 = ( [], ["-fomit-frame-pointer", "-G0"] )
2372 #elif x86_64_TARGET_ARCH
2374 #if darwin_TARGET_OS
2379 ["-fomit-frame-pointer",
2380 "-fno-asynchronous-unwind-tables",
2381 -- the unwind tables are unnecessary for HC code,
2382 -- and get in the way of -split-objs. Another option
2383 -- would be to throw them away in the mangler, but this
2386 -- calling builtins like strlen() using the FFI can
2387 -- cause gcc to run out of regs, so use the external
2391 #elif sparc_TARGET_ARCH
2393 -- For now, to suppress the gcc warning "call-clobbered
2394 -- register used for global register variable", we simply
2395 -- disable all warnings altogether using the -w flag. Oh well.
2397 #elif powerpc_apple_darwin_TARGET
2399 -- Disable Apple's precompiling preprocessor. It's a great thing
2400 -- for "normal" programs, but it doesn't support register variable
2402 = ( [], ["-no-cpp-precomp"] )
2407 picCCOpts :: DynFlags -> [String]
2409 #if darwin_TARGET_OS
2410 -- Apple prefers to do things the other way round.
2411 -- PIC is on by default.
2412 -- -mdynamic-no-pic:
2413 -- Turn off PIC code generation.
2415 -- Don't generate "common" symbols - these are unwanted
2416 -- in dynamic libraries.
2419 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2421 = ["-mdynamic-no-pic"]
2422 #elif mingw32_TARGET_OS
2423 -- no -fPIC for Windows
2425 = ["-U __PIC__","-D__PIC__"]
2429 | opt_PIC || not opt_Static
2430 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2435 -- -----------------------------------------------------------------------------
2439 can_split = cSplitObjs == "YES"
2441 -- -----------------------------------------------------------------------------
2444 data Printable = String String
2445 | FromDynFlags (DynFlags -> String)
2447 compilerInfo :: [(String, Printable)]
2448 compilerInfo = [("Project name", String cProjectName),
2449 ("Project version", String cProjectVersion),
2450 ("Booter version", String cBooterVersion),
2451 ("Stage", String cStage),
2452 ("Have interpreter", String cGhcWithInterpreter),
2453 ("Object splitting", String cSplitObjs),
2454 ("Have native code generator", String cGhcWithNativeCodeGen),
2455 ("Support SMP", String cGhcWithSMP),
2456 ("Unregisterised", String cGhcUnregisterised),
2457 ("Tables next to code", String cGhcEnableTablesNextToCode),
2458 ("Win32 DLLs", String cEnableWin32DLLs),
2459 ("RTS ways", String cGhcRTSWays),
2460 ("Leading underscore", String cLeadingUnderscore),
2461 ("Debug on", String (show debugIsOn)),
2462 ("LibDir", FromDynFlags topDir)