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 hiDir :: Maybe String,
389 stubDir :: Maybe String,
395 outputFile :: Maybe String,
396 outputHi :: Maybe String,
397 dynLibLoader :: DynLibLoader,
399 -- | This is set by 'DriverPipeline.runPipeline' based on where
400 -- its output is going.
401 dumpPrefix :: Maybe FilePath,
403 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
404 -- Set by @-ddump-file-prefix@
405 dumpPrefixForce :: Maybe FilePath,
407 includePaths :: [String],
408 libraryPaths :: [String],
409 frameworkPaths :: [String], -- used on darwin only
410 cmdlineFrameworks :: [String], -- ditto
411 tmpDir :: String, -- no trailing '/'
413 ghcUsagePath :: FilePath, -- Filled in by SysTools
414 ghciUsagePath :: FilePath, -- ditto
416 hpcDir :: String, -- ^ Path to store the .mix files
418 -- options for particular phases
426 opt_windres :: [String],
428 -- commands for particular phases
430 pgm_P :: (String,[Option]),
432 pgm_c :: (String,[Option]),
433 pgm_m :: (String,[Option]),
434 pgm_s :: (String,[Option]),
435 pgm_a :: (String,[Option]),
436 pgm_l :: (String,[Option]),
437 pgm_dll :: (String,[Option]),
439 pgm_sysman :: String,
440 pgm_windres :: String,
443 depMakefile :: FilePath,
444 depIncludePkgDeps :: Bool,
445 depExcludeMods :: [ModuleName],
446 depSuffixes :: [String],
449 extraPkgConfs :: [FilePath],
450 topDir :: FilePath, -- filled in by SysTools
451 systemPackageConfig :: FilePath, -- ditto
452 -- ^ The @-package-conf@ flags given on the command line, in the order
455 packageFlags :: [PackageFlag],
456 -- ^ The @-package@ and @-hide-package@ flags from the command-line
459 -- NB. do not modify this field, it is calculated by
460 -- Packages.initPackages and Packages.updatePackages.
461 pkgDatabase :: Maybe [PackageConfig],
462 pkgState :: PackageState,
465 -- These have to be IORefs, because the defaultCleanupHandler needs to
466 -- know what to clean when an exception happens
467 filesToClean :: IORef [FilePath],
468 dirsToClean :: IORef (FiniteMap FilePath FilePath),
473 -- | Message output action: use "ErrUtils" instead of this if you can
474 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
476 haddockOptions :: Maybe String
479 wayNames :: DynFlags -> [WayName]
480 wayNames = map wayName . ways
482 -- | The target code type of the compilation (if any).
484 -- Whenever you change the target, also make sure to set 'ghcLink' to
485 -- something sensible.
487 -- 'HscNothing' can be used to avoid generating any output, however, note
490 -- * This will not run the desugaring step, thus no warnings generated in
491 -- this step will be output. In particular, this includes warnings related
492 -- to pattern matching. You can run the desugarer manually using
493 -- 'GHC.desugarModule'.
495 -- * If a program uses Template Haskell the typechecker may try to run code
496 -- from an imported module. This will fail if no code has been generated
497 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
498 -- whether this might be the case and choose to either switch to a
499 -- different target or avoid typechecking such modules. (The latter may
500 -- preferable for security reasons.)
503 = HscC -- ^ Generate C code.
504 | HscAsm -- ^ Generate assembly using the native code generator.
505 | HscJava -- ^ Generate Java bytecode.
506 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
507 | HscNothing -- ^ Don't generate any code. See notes above.
510 -- | Will this target result in an object file on the disk?
511 isObjectTarget :: HscTarget -> Bool
512 isObjectTarget HscC = True
513 isObjectTarget HscAsm = True
514 isObjectTarget _ = False
516 -- | The 'GhcMode' tells us whether we're doing multi-module
517 -- compilation (controlled via the "GHC" API) or one-shot
518 -- (single-module) compilation. This makes a difference primarily to
519 -- the "Finder": in one-shot mode we look for interface files for
520 -- imported modules, but in multi-module mode we look for source files
521 -- in order to check whether they need to be recompiled.
523 = CompManager -- ^ @\-\-make@, GHCi, etc.
524 | OneShot -- ^ @ghc -c Foo.hs@
525 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
528 instance Outputable GhcMode where
529 ppr CompManager = ptext (sLit "CompManager")
530 ppr OneShot = ptext (sLit "OneShot")
531 ppr MkDepend = ptext (sLit "MkDepend")
533 isOneShot :: GhcMode -> Bool
534 isOneShot OneShot = True
535 isOneShot _other = False
537 -- | What to do in the link step, if there is one.
539 = NoLink -- ^ Don't link at all
540 | LinkBinary -- ^ Link object code into a binary
541 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
542 -- bytecode and object code).
543 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
546 isNoLink :: GhcLink -> Bool
547 isNoLink NoLink = True
550 -- Is it worth evaluating this Bool and caching it in the DynFlags value
551 -- during initDynFlags?
552 doingTickyProfiling :: DynFlags -> Bool
553 doingTickyProfiling _ = opt_Ticky
554 -- XXX -ticky is a static flag, because it implies -debug which is also
555 -- static. If the way flags were made dynamic, we could fix this.
558 = ExposePackage String
559 | ExposePackageId String
561 | IgnorePackage String
564 defaultHscTarget :: HscTarget
565 defaultHscTarget = defaultObjectTarget
567 -- | The 'HscTarget' value corresponding to the default way to create
568 -- object files on the current platform.
569 defaultObjectTarget :: HscTarget
571 | cGhcWithNativeCodeGen == "YES" = HscAsm
576 | Wrapped (Maybe String)
580 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
581 initDynFlags :: DynFlags -> IO DynFlags
582 initDynFlags dflags = do
583 -- someday these will be dynamic flags
584 ways <- readIORef v_Ways
585 refFilesToClean <- newIORef []
586 refDirsToClean <- newIORef emptyFM
589 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
590 rtsBuildTag = mkBuildTag ways,
591 filesToClean = refFilesToClean,
592 dirsToClean = refDirsToClean
595 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
596 -- and must be fully initialized by 'GHC.newSession' first.
597 defaultDynFlags :: DynFlags
600 ghcMode = CompManager,
601 ghcLink = LinkBinary,
604 hscTarget = defaultHscTarget,
610 maxSimplIterations = 4,
611 shouldDumpSimplPhase = const False,
613 specConstrThreshold = Just 200,
614 specConstrCount = Just 3,
615 liberateCaseThreshold = Just 200,
616 strictnessBefore = [],
618 #ifndef OMIT_NATIVE_CODEGEN
619 targetPlatform = defaultTargetPlatform,
622 cmdlineHcIncludes = [],
626 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
630 thisPackage = mainPackageId,
636 objectSuf = phaseInputExt StopLn,
637 hcSuf = phaseInputExt HCc,
640 outputFile = Nothing,
642 dynLibLoader = SystemDependent,
643 dumpPrefix = Nothing,
644 dumpPrefixForce = Nothing,
648 cmdlineFrameworks = [],
649 tmpDir = cDEFAULT_TMPDIR,
655 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
666 pkgDatabase = Nothing,
667 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
668 ways = panic "defaultDynFlags: No ways",
669 buildTag = panic "defaultDynFlags: No buildTag",
670 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
672 -- initSysTools fills all these in
673 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
674 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
675 topDir = panic "defaultDynFlags: No topDir",
676 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
677 pgm_L = panic "defaultDynFlags: No pgm_L",
678 pgm_P = panic "defaultDynFlags: No pgm_P",
679 pgm_F = panic "defaultDynFlags: No pgm_F",
680 pgm_c = panic "defaultDynFlags: No pgm_c",
681 pgm_m = panic "defaultDynFlags: No pgm_m",
682 pgm_s = panic "defaultDynFlags: No pgm_s",
683 pgm_a = panic "defaultDynFlags: No pgm_a",
684 pgm_l = panic "defaultDynFlags: No pgm_l",
685 pgm_dll = panic "defaultDynFlags: No pgm_dll",
686 pgm_T = panic "defaultDynFlags: No pgm_T",
687 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
688 pgm_windres = panic "defaultDynFlags: No pgm_windres",
689 -- end of initSysTools values
691 depMakefile = "Makefile",
692 depIncludePkgDeps = False,
695 -- end of ghc -M values
696 filesToClean = panic "defaultDynFlags: No filesToClean",
697 dirsToClean = panic "defaultDynFlags: No dirsToClean",
698 haddockOptions = Nothing,
700 Opt_AutoLinkPackages,
701 Opt_ReadUserPackageConf,
703 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
704 -- behaviour the default, to see if anyone notices
708 Opt_MonomorphismRestriction,
719 Opt_PrintBindContents
721 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
722 -- The default -O0 options
725 log_action = \severity srcSpan style msg ->
727 SevInfo -> printErrs (msg style)
728 SevFatal -> printErrs (msg style)
731 printErrs ((mkLocMessage srcSpan msg) style)
732 -- careful (#2302): printErrs prints in UTF-8, whereas
733 -- converting to string first and using hPutStr would
734 -- just emit the low 8 bits of each unicode char.
738 Note [Verbosity levels]
739 ~~~~~~~~~~~~~~~~~~~~~~~
740 0 | print errors & warnings only
741 1 | minimal verbosity: print "compiling M ... done." for each module.
742 2 | equivalent to -dshow-passes
743 3 | equivalent to existing "ghc -v"
744 4 | "ghc -v -ddump-most"
745 5 | "ghc -v -ddump-all"
748 -- | Test whether a 'DynFlag' is set
749 dopt :: DynFlag -> DynFlags -> Bool
750 dopt f dflags = f `elem` (flags dflags)
753 dopt_set :: DynFlags -> DynFlag -> DynFlags
754 dopt_set dfs f = dfs{ flags = f : flags dfs }
756 -- | Unset a 'DynFlag'
757 dopt_unset :: DynFlags -> DynFlag -> DynFlags
758 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
760 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
761 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
762 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
763 -> [a] -- ^ Correctly ordered extracted options
764 getOpts dflags opts = reverse (opts dflags)
765 -- We add to the options from the front, so we need to reverse the list
767 -- | Gets the verbosity flag for the current verbosity level. This is fed to
768 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
769 getVerbFlag :: DynFlags -> String
771 | verbosity dflags >= 3 = "-v"
774 setObjectDir, setHiDir, setStubDir, setOutputDir,
775 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
776 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
777 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
778 addCmdlineFramework, addHaddockOpts
779 :: String -> DynFlags -> DynFlags
780 setOutputFile, setOutputHi, setDumpPrefixForce
781 :: Maybe String -> DynFlags -> DynFlags
783 setObjectDir f d = d{ objectDir = Just f}
784 setHiDir f d = d{ hiDir = Just f}
785 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
786 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
787 -- \#included from the .hc file when compiling with -fvia-C.
788 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
790 setObjectSuf f d = d{ objectSuf = f}
791 setHiSuf f d = d{ hiSuf = f}
792 setHcSuf f d = d{ hcSuf = f}
794 setOutputFile f d = d{ outputFile = f}
795 setOutputHi f d = d{ outputHi = f}
797 parseDynLibLoaderMode f d =
799 ("deploy", "") -> d{ dynLibLoader = Deployable }
800 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
801 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
802 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
803 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
804 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
806 setDumpPrefixForce f d = d { dumpPrefixForce = f}
808 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
809 -- Config.hs should really use Option.
810 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
812 setPgmL f d = d{ pgm_L = f}
813 setPgmF f d = d{ pgm_F = f}
814 setPgmc f d = d{ pgm_c = (f,[])}
815 setPgmm f d = d{ pgm_m = (f,[])}
816 setPgms f d = d{ pgm_s = (f,[])}
817 setPgma f d = d{ pgm_a = (f,[])}
818 setPgml f d = d{ pgm_l = (f,[])}
819 setPgmdll f d = d{ pgm_dll = (f,[])}
820 setPgmwindres f d = d{ pgm_windres = f}
822 addOptL f d = d{ opt_L = f : opt_L d}
823 addOptP f d = d{ opt_P = f : opt_P d}
824 addOptF f d = d{ opt_F = f : opt_F d}
825 addOptc f d = d{ opt_c = f : opt_c d}
826 addOptm f d = d{ opt_m = f : opt_m d}
827 addOpta f d = d{ opt_a = f : opt_a d}
828 addOptl f d = d{ opt_l = f : opt_l d}
829 addOptwindres f d = d{ opt_windres = f : opt_windres d}
831 setDepMakefile :: FilePath -> DynFlags -> DynFlags
832 setDepMakefile f d = d { depMakefile = deOptDep f }
834 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
835 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
837 addDepExcludeMod :: String -> DynFlags -> DynFlags
839 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
841 addDepSuffix :: FilePath -> DynFlags -> DynFlags
842 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
845 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
846 -- we need to strip the "-optdep" off of the arg
847 deOptDep :: String -> String
848 deOptDep x = case stripPrefix "-optdep" x of
852 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
854 addHaddockOpts f d = d{ haddockOptions = Just f}
856 -- -----------------------------------------------------------------------------
857 -- Command-line options
859 -- | When invoking external tools as part of the compilation pipeline, we
860 -- pass these a sequence of options on the command-line. Rather than
861 -- just using a list of Strings, we use a type that allows us to distinguish
862 -- between filepaths and 'other stuff'. The reason for this is that
863 -- this type gives us a handle on transforming filenames, and filenames only,
864 -- to whatever format they're expected to be on a particular platform.
866 = FileOption -- an entry that _contains_ filename(s) / filepaths.
867 String -- a non-filepath prefix that shouldn't be
868 -- transformed (e.g., "/out=")
869 String -- the filepath/filename portion
872 showOpt :: Option -> String
873 showOpt (FileOption pre f) = pre ++ f
874 showOpt (Option s) = s
876 -----------------------------------------------------------------------------
877 -- Setting the optimisation level
879 updOptLevel :: Int -> DynFlags -> DynFlags
880 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
882 = dfs2{ optLevel = final_n }
884 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
885 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
886 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
888 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
889 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
891 optLevelFlags :: [([Int], DynFlag)]
893 = [ ([0], Opt_IgnoreInterfacePragmas)
894 , ([0], Opt_OmitInterfacePragmas)
896 , ([1,2], Opt_IgnoreAsserts)
897 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
899 , ([1,2], Opt_DoEtaReduction)
900 , ([1,2], Opt_CaseMerge)
901 , ([1,2], Opt_Strictness)
903 , ([1,2], Opt_FullLaziness)
904 , ([1,2], Opt_Specialise)
905 , ([1,2], Opt_FloatIn)
907 , ([2], Opt_LiberateCase)
908 , ([2], Opt_SpecConstr)
910 -- , ([2], Opt_StaticArgumentTransformation)
911 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
912 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
913 -- several improvements to the heuristics, and I'm concerned that without
914 -- those changes SAT will interfere with some attempts to write "high
915 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
916 -- this year. In particular, the version in HEAD lacks the tail call
917 -- criterion, so many things that look like reasonable loops will be
918 -- turned into functions with extra (unneccesary) thunk creation.
920 , ([0,1,2], Opt_DoLambdaEtaExpansion)
921 -- This one is important for a tiresome reason:
922 -- we want to make sure that the bindings for data
923 -- constructors are eta-expanded. This is probably
924 -- a good thing anyway, but it seems fragile.
927 -- -----------------------------------------------------------------------------
928 -- Standard sets of warning options
930 standardWarnings :: [DynFlag]
932 = [ Opt_WarnWarningsDeprecations,
933 Opt_WarnDeprecatedFlags,
934 Opt_WarnUnrecognisedPragmas,
935 Opt_WarnOverlappingPatterns,
936 Opt_WarnMissingFields,
937 Opt_WarnMissingMethods,
938 Opt_WarnDuplicateExports,
939 Opt_WarnLazyUnliftedBindings,
940 Opt_WarnDodgyForeignImports,
944 minusWOpts :: [DynFlag]
946 = standardWarnings ++
947 [ Opt_WarnUnusedBinds,
948 Opt_WarnUnusedMatches,
949 Opt_WarnUnusedImports,
950 Opt_WarnIncompletePatterns,
951 Opt_WarnDodgyExports,
955 minusWallOpts :: [DynFlag]
958 [ Opt_WarnTypeDefaults,
959 Opt_WarnNameShadowing,
966 -- minuswRemovesOpts should be every warning option
967 minuswRemovesOpts :: [DynFlag]
970 [Opt_WarnImplicitPrelude,
971 Opt_WarnIncompletePatternsRecUpd,
972 Opt_WarnSimplePatterns,
973 Opt_WarnMonomorphism,
974 Opt_WarnUnrecognisedPragmas,
978 -- -----------------------------------------------------------------------------
979 -- CoreToDo: abstraction of core-to-core passes to run.
981 data CoreToDo -- These are diff core-to-core passes,
982 -- which may be invoked in any order,
983 -- as many times as you like.
985 = CoreDoSimplify -- The core-to-core simplifier.
988 -- Each run of the simplifier can take a different
989 -- set of simplifier-specific flags.
991 | CoreDoFloatOutwards FloatOutSwitches
996 | CoreDoWorkerWrapper
999 | CoreDoOldStrictness
1002 | CoreDoRuleCheck CompilerPhase String -- Check for non-application of rules
1003 -- matching this string
1004 | CoreDoVectorisation PackageId
1005 | CoreDoNothing -- Useful when building up
1006 | CoreDoPasses [CoreToDo] -- lists of these things
1009 data SimplifierMode -- See comments in SimplMonad
1011 { sm_rules :: Bool -- Whether RULES are enabled
1012 , sm_inline :: Bool } -- Whether inlining is enabled
1015 { sm_num :: Int -- Phase number; counts downward so 0 is last phase
1016 , sm_names :: [String] } -- Name(s) of the phase
1018 instance Outputable SimplifierMode where
1019 ppr (SimplPhase { sm_num = n, sm_names = ss })
1020 = int n <+> brackets (text (concat $ intersperse "," ss))
1021 ppr (SimplGently { sm_rules = r, sm_inline = i })
1022 = ptext (sLit "gentle") <>
1023 brackets (pp_flag r (sLit "rules") <> comma <>
1024 pp_flag i (sLit "inline"))
1026 pp_flag f s = ppUnless f (ptext (sLit "no")) <+> ptext s
1028 data SimplifierSwitch
1029 = MaxSimplifierIterations Int
1032 data FloatOutSwitches = FloatOutSwitches {
1033 floatOutLambdas :: Bool, -- ^ True <=> float lambdas to top level
1034 floatOutConstants :: Bool -- ^ True <=> float constants to top level,
1035 -- even if they do not escape a lambda
1038 instance Outputable FloatOutSwitches where
1039 ppr = pprFloatOutSwitches
1041 pprFloatOutSwitches :: FloatOutSwitches -> SDoc
1042 pprFloatOutSwitches sw = pp_not (floatOutLambdas sw) <+> text "lambdas" <> comma
1043 <+> pp_not (floatOutConstants sw) <+> text "constants"
1046 pp_not False = text "not"
1048 -- | Switches that specify the minimum amount of floating out
1049 -- gentleFloatOutSwitches :: FloatOutSwitches
1050 -- gentleFloatOutSwitches = FloatOutSwitches False False
1052 -- | Switches that do not specify floating out of lambdas, just of constants
1053 constantsOnlyFloatOutSwitches :: FloatOutSwitches
1054 constantsOnlyFloatOutSwitches = FloatOutSwitches False True
1057 -- The core-to-core pass ordering is derived from the DynFlags:
1058 runWhen :: Bool -> CoreToDo -> CoreToDo
1059 runWhen True do_this = do_this
1060 runWhen False _ = CoreDoNothing
1062 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
1063 runMaybe (Just x) f = f x
1064 runMaybe Nothing _ = CoreDoNothing
1066 getCoreToDo :: DynFlags -> [CoreToDo]
1068 | Just todo <- coreToDo dflags = todo -- set explicitly by user
1069 | otherwise = core_todo
1071 opt_level = optLevel dflags
1072 phases = simplPhases dflags
1073 max_iter = maxSimplIterations dflags
1074 strictness = dopt Opt_Strictness dflags
1075 full_laziness = dopt Opt_FullLaziness dflags
1076 do_specialise = dopt Opt_Specialise dflags
1077 do_float_in = dopt Opt_FloatIn dflags
1078 cse = dopt Opt_CSE dflags
1079 spec_constr = dopt Opt_SpecConstr dflags
1080 liberate_case = dopt Opt_LiberateCase dflags
1081 rule_check = ruleCheck dflags
1082 static_args = dopt Opt_StaticArgumentTransformation dflags
1084 maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
1086 maybe_strictness_before phase
1087 = runWhen (phase `elem` strictnessBefore dflags) CoreDoStrictness
1089 simpl_phase phase names iter
1091 [ maybe_strictness_before phase,
1092 CoreDoSimplify (SimplPhase phase names) [
1093 MaxSimplifierIterations iter
1095 maybe_rule_check phase
1099 = runWhen (dopt Opt_Vectorise dflags)
1100 $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
1103 -- By default, we have 2 phases before phase 0.
1105 -- Want to run with inline phase 2 after the specialiser to give
1106 -- maximum chance for fusion to work before we inline build/augment
1107 -- in phase 1. This made a difference in 'ansi' where an
1108 -- overloaded function wasn't inlined till too late.
1110 -- Need phase 1 so that build/augment get
1111 -- inlined. I found that spectral/hartel/genfft lost some useful
1112 -- strictness in the function sumcode' if augment is not inlined
1113 -- before strictness analysis runs
1114 simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
1115 | phase <- [phases, phases-1 .. 1] ]
1118 -- initial simplify: mk specialiser happy: minimum effort please
1119 simpl_gently = CoreDoSimplify
1120 (SimplGently { sm_rules = True, sm_inline = False })
1122 -- Simplify "gently"
1123 -- Don't inline anything till full laziness has bitten
1124 -- In particular, inlining wrappers inhibits floating
1125 -- e.g. ...(case f x of ...)...
1126 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
1127 -- ==> ...(case x of I# x# -> case fw x# of ...)...
1128 -- and now the redex (f x) isn't floatable any more
1129 -- Similarly, don't apply any rules until after full
1130 -- laziness. Notably, list fusion can prevent floating.
1132 NoCaseOfCase, -- Don't do case-of-case transformations.
1133 -- This makes full laziness work better
1134 MaxSimplifierIterations max_iter
1138 if opt_level == 0 then
1140 simpl_phase 0 ["final"] max_iter]
1141 else {- opt_level >= 1 -} [
1143 -- We want to do the static argument transform before full laziness as it
1144 -- may expose extra opportunities to float things outwards. However, to fix
1145 -- up the output of the transformation we need at do at least one simplify
1146 -- after this before anything else
1147 runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1149 -- We run vectorisation here for now, but we might also try to run
1153 -- initial simplify: mk specialiser happy: minimum effort please
1156 -- Specialisation is best done before full laziness
1157 -- so that overloaded functions have all their dictionary lambdas manifest
1158 runWhen do_specialise CoreDoSpecialising,
1160 runWhen full_laziness (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1161 -- Was: gentleFloatOutSwitches
1162 -- I have no idea why, but not floating constants to top level is
1163 -- very bad in some cases.
1164 -- Notably: p_ident in spectral/rewrite
1165 -- Changing from "gentle" to "constantsOnly" improved
1166 -- rewrite's allocation by 19%, and made 0.0% difference
1167 -- to any other nofib benchmark
1169 runWhen do_float_in CoreDoFloatInwards,
1173 -- Phase 0: allow all Ids to be inlined now
1174 -- This gets foldr inlined before strictness analysis
1176 -- At least 3 iterations because otherwise we land up with
1177 -- huge dead expressions because of an infelicity in the
1179 -- let k = BIG in foldr k z xs
1180 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1181 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1183 simpl_phase 0 ["main"] (max max_iter 3),
1185 runWhen strictness (CoreDoPasses [
1187 CoreDoWorkerWrapper,
1189 simpl_phase 0 ["post-worker-wrapper"] max_iter
1192 runWhen full_laziness
1193 (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1194 -- nofib/spectral/hartel/wang doubles in speed if you
1195 -- do full laziness late in the day. It only happens
1196 -- after fusion and other stuff, so the early pass doesn't
1197 -- catch it. For the record, the redex is
1198 -- f_el22 (f_el21 r_midblock)
1201 runWhen cse CoreCSE,
1202 -- We want CSE to follow the final full-laziness pass, because it may
1203 -- succeed in commoning up things floated out by full laziness.
1204 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1206 runWhen do_float_in CoreDoFloatInwards,
1210 -- Case-liberation for -O2. This should be after
1211 -- strictness analysis and the simplification which follows it.
1212 runWhen liberate_case (CoreDoPasses [
1214 simpl_phase 0 ["post-liberate-case"] max_iter
1215 ]), -- Run the simplifier after LiberateCase to vastly
1216 -- reduce the possiblility of shadowing
1217 -- Reason: see Note [Shadowing] in SpecConstr.lhs
1219 runWhen spec_constr CoreDoSpecConstr,
1223 -- Final clean-up simplification:
1224 simpl_phase 0 ["final"] max_iter
1227 -- -----------------------------------------------------------------------------
1228 -- StgToDo: abstraction of stg-to-stg passes to run.
1231 = StgDoMassageForProfiling -- should be (next to) last
1232 -- There's also setStgVarInfo, but its absolute "lastness"
1233 -- is so critical that it is hardwired in (no flag).
1236 getStgToDo :: DynFlags -> [StgToDo]
1238 | Just todo <- stgToDo dflags = todo -- set explicitly by user
1241 stg_stats = dopt Opt_StgStats dflags
1243 todo1 = if stg_stats then [D_stg_stats] else []
1245 todo2 | WayProf `elem` wayNames dflags
1246 = StgDoMassageForProfiling : todo1
1250 -- -----------------------------------------------------------------------------
1253 allFlags :: [String]
1254 allFlags = map ('-':) $
1255 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1256 map ("fno-"++) flags ++
1257 map ("f"++) flags ++
1258 map ("X"++) supportedLanguages ++
1259 map ("XNo"++) supportedLanguages
1260 where ok (PrefixPred _ _) = False
1262 flags = [ name | (name, _, _) <- fFlags ]
1264 dynamic_flags :: [Flag DynP]
1266 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1267 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1268 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1269 , Flag "#include" (HasArg (addCmdlineHCInclude))
1270 (Deprecated "No longer has any effect")
1271 , Flag "v" (OptIntSuffix setVerbosity) Supported
1273 ------- Specific phases --------------------------------------------
1274 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1275 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1276 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1277 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1278 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1279 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1280 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1281 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1282 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1283 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1285 , Flag "optL" (HasArg (upd . addOptL)) Supported
1286 , Flag "optP" (HasArg (upd . addOptP)) Supported
1287 , Flag "optF" (HasArg (upd . addOptF)) Supported
1288 , Flag "optc" (HasArg (upd . addOptc)) Supported
1289 , Flag "optm" (HasArg (upd . addOptm)) Supported
1290 , Flag "opta" (HasArg (upd . addOpta)) Supported
1291 , Flag "optl" (HasArg (upd . addOptl)) Supported
1292 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1295 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1298 -------- ghc -M -----------------------------------------------------
1299 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1300 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1301 (Deprecated "Use -dep-suffix instead")
1302 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1303 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1304 (Deprecated "Use -dep-makefile instead")
1305 , Flag "optdep-w" (NoArg (return ()))
1306 (Deprecated "-optdep-w doesn't do anything")
1307 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1308 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1309 (Deprecated "Use -include-pkg-deps instead")
1310 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1311 (Deprecated "Use -include-pkg-deps instead")
1312 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1313 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1314 (Deprecated "Use -exclude-module instead")
1315 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1316 (Deprecated "Use -exclude-module instead")
1318 -------- Linking ----------------------------------------------------
1319 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1321 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1322 (Deprecated "Use -c instead")
1323 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1325 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1328 ------- Libraries ---------------------------------------------------
1329 , Flag "L" (Prefix addLibraryPath ) Supported
1330 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1332 ------- Frameworks --------------------------------------------------
1333 -- -framework-path should really be -F ...
1334 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1335 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1337 ------- Output Redirection ------------------------------------------
1338 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1339 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1340 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1341 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1342 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1343 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1344 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1345 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1346 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1347 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1348 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1351 ------- Keeping temporary files -------------------------------------
1352 -- These can be singular (think ghc -c) or plural (think ghc --make)
1353 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1354 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1355 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1356 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1357 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1358 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1359 -- This only makes sense as plural
1360 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1362 ------- Miscellaneous ----------------------------------------------
1363 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1364 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1365 , Flag "main-is" (SepArg setMainIs ) Supported
1366 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1367 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1368 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1370 ------- recompilation checker --------------------------------------
1371 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1372 (Deprecated "Use -fno-force-recomp instead")
1373 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1374 (Deprecated "Use -fforce-recomp instead")
1376 ------ HsCpp opts ---------------------------------------------------
1377 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1378 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1380 ------- Include/Import Paths ----------------------------------------
1381 , Flag "I" (Prefix addIncludePath) Supported
1382 , Flag "i" (OptPrefix addImportPath ) Supported
1384 ------ Debugging ----------------------------------------------------
1385 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1387 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1389 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1391 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1393 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1395 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1397 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1399 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1401 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1403 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1405 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1407 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1409 , Flag "ddump-asm-regalloc-stages"
1410 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1412 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1414 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1416 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1418 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1420 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1422 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1424 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1426 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1428 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1430 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1432 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1434 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1436 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1438 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1440 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1442 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1444 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1446 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1448 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1450 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1452 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1454 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1456 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1458 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1460 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1462 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1464 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1466 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1468 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1470 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1472 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1474 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1476 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1478 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1479 ; setVerboseCore2Core }))
1481 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1483 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1485 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1487 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1489 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1491 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1493 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1495 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1497 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1499 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1502 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1504 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1506 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1508 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1510 , Flag "dshow-passes"
1511 (NoArg (do forceRecompile
1512 setVerbosity (Just 2)))
1514 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1517 ------ Machine dependant (-m<blah>) stuff ---------------------------
1519 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1521 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1523 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1526 ------ Warning opts -------------------------------------------------
1527 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1529 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1531 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1533 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1535 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1536 (Deprecated "Use -w instead")
1537 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1540 ------ Optimisation flags ------------------------------------------
1541 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1542 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1543 (Deprecated "Use -O0 instead")
1544 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1545 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1547 -- If the number is missing, use 1
1549 , Flag "fsimplifier-phases"
1550 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1552 , Flag "fmax-simplifier-iterations"
1553 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1556 , Flag "fspec-constr-threshold"
1557 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1559 , Flag "fno-spec-constr-threshold"
1560 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1562 , Flag "fspec-constr-count"
1563 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1565 , Flag "fno-spec-constr-count"
1566 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1568 , Flag "fliberate-case-threshold"
1569 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1571 , Flag "fno-liberate-case-threshold"
1572 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1575 , Flag "frule-check"
1576 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1578 , Flag "fcontext-stack"
1579 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1582 , Flag "fstrictness-before"
1583 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1586 ------ Profiling ----------------------------------------------------
1588 -- XXX Should the -f* flags be deprecated?
1589 -- They don't seem to be documented
1590 , Flag "fauto-sccs-on-all-toplevs"
1591 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1594 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1596 , Flag "no-auto-all"
1597 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1599 , Flag "fauto-sccs-on-exported-toplevs"
1600 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1603 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1606 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1608 , Flag "fauto-sccs-on-individual-cafs"
1609 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1612 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1615 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1618 ------ DPH flags ----------------------------------------------------
1621 (NoArg (setDPHBackend DPHSeq))
1624 (NoArg (setDPHBackend DPHPar))
1627 (NoArg (setDPHBackend DPHThis))
1630 ------ Compiler flags -----------------------------------------------
1632 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1633 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1634 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1636 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1637 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1638 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1640 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1642 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1645 ++ map (mkFlag True "f" setDynFlag ) fFlags
1646 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1647 ++ map (mkFlag True "X" setDynFlag ) xFlags
1648 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1650 package_flags :: [Flag DynP]
1652 ------- Packages ----------------------------------------------------
1653 Flag "package-conf" (HasArg extraPkgConf_) Supported
1654 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1656 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1657 , Flag "package-id" (HasArg exposePackageId) Supported
1658 , Flag "package" (HasArg exposePackage) Supported
1659 , Flag "hide-package" (HasArg hidePackage) Supported
1660 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1662 , Flag "ignore-package" (HasArg ignorePackage)
1664 , Flag "syslib" (HasArg exposePackage)
1665 (Deprecated "Use -package instead")
1668 mkFlag :: Bool -- ^ True <=> it should be turned on
1669 -> String -- ^ The flag prefix
1670 -> (DynFlag -> DynP ())
1671 -> (String, DynFlag, Bool -> Deprecated)
1673 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1674 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1676 deprecatedForLanguage :: String -> Bool -> Deprecated
1677 deprecatedForLanguage lang turn_on
1678 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1680 flag | turn_on = lang
1681 | otherwise = "No"++lang
1683 useInstead :: String -> Bool -> Deprecated
1684 useInstead flag turn_on
1685 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1687 no = if turn_on then "" else "no-"
1689 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1690 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1692 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1693 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1694 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1695 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1696 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1697 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1698 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1699 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1700 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1701 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1702 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1703 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1704 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1705 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1706 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1707 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1708 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1709 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1710 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1711 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1712 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1713 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1714 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1715 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1716 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1717 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1718 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1719 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1720 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1721 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1722 ( "strictness", Opt_Strictness, const Supported ),
1723 ( "specialise", Opt_Specialise, const Supported ),
1724 ( "float-in", Opt_FloatIn, const Supported ),
1725 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1726 ( "full-laziness", Opt_FullLaziness, const Supported ),
1727 ( "liberate-case", Opt_LiberateCase, const Supported ),
1728 ( "spec-constr", Opt_SpecConstr, const Supported ),
1729 ( "cse", Opt_CSE, const Supported ),
1730 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1731 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1732 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1733 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1734 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1735 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1736 ( "case-merge", Opt_CaseMerge, const Supported ),
1737 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1738 ( "method-sharing", Opt_MethodSharing, const Supported ),
1739 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1740 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1741 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1742 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1743 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1744 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1745 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1746 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1747 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1748 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1749 ( "break-on-error", Opt_BreakOnError, const Supported ),
1750 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1751 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1752 ( "run-cps", Opt_RunCPS, const Supported ),
1753 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1754 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1755 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1756 ( "vectorise", Opt_Vectorise, const Supported ),
1757 ( "regs-graph", Opt_RegsGraph, const Supported ),
1758 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1759 ( "th", Opt_TemplateHaskell,
1760 deprecatedForLanguage "TemplateHaskell" ),
1761 ( "fi", Opt_ForeignFunctionInterface,
1762 deprecatedForLanguage "ForeignFunctionInterface" ),
1763 ( "ffi", Opt_ForeignFunctionInterface,
1764 deprecatedForLanguage "ForeignFunctionInterface" ),
1765 ( "arrows", Opt_Arrows,
1766 deprecatedForLanguage "Arrows" ),
1767 ( "generics", Opt_Generics,
1768 deprecatedForLanguage "Generics" ),
1769 ( "implicit-prelude", Opt_ImplicitPrelude,
1770 deprecatedForLanguage "ImplicitPrelude" ),
1771 ( "bang-patterns", Opt_BangPatterns,
1772 deprecatedForLanguage "BangPatterns" ),
1773 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1774 deprecatedForLanguage "MonomorphismRestriction" ),
1775 ( "mono-pat-binds", Opt_MonoPatBinds,
1776 deprecatedForLanguage "MonoPatBinds" ),
1777 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1778 deprecatedForLanguage "ExtendedDefaultRules" ),
1779 ( "implicit-params", Opt_ImplicitParams,
1780 deprecatedForLanguage "ImplicitParams" ),
1781 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1782 deprecatedForLanguage "ScopedTypeVariables" ),
1784 deprecatedForLanguage "PArr" ),
1785 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1786 deprecatedForLanguage "OverlappingInstances" ),
1787 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1788 deprecatedForLanguage "UndecidableInstances" ),
1789 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1790 deprecatedForLanguage "IncoherentInstances" ),
1791 ( "gen-manifest", Opt_GenManifest, const Supported ),
1792 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1793 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1794 ( "shared-implib", Opt_SharedImplib, const Supported ),
1795 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1796 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1799 supportedLanguages :: [String]
1800 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1802 -- This may contain duplicates
1803 languageOptions :: [DynFlag]
1804 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1806 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1807 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1809 ( "CPP", Opt_Cpp, const Supported ),
1810 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1811 ( "TupleSections", Opt_TupleSections, const Supported ),
1812 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1813 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1814 ( "MagicHash", Opt_MagicHash, const Supported ),
1815 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1816 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1817 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1818 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1819 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1820 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1821 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1822 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1823 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1824 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1825 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1826 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1827 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1828 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1829 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1830 ( "RecursiveDo", Opt_RecursiveDo,
1831 deprecatedForLanguage "DoRec"),
1832 ( "DoRec", Opt_DoRec, const Supported ),
1833 ( "Arrows", Opt_Arrows, const Supported ),
1834 ( "PArr", Opt_PArr, const Supported ),
1835 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1836 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1837 ( "Generics", Opt_Generics, const Supported ),
1839 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1840 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1841 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1842 ( "RecordPuns", Opt_RecordPuns,
1843 deprecatedForLanguage "NamedFieldPuns" ),
1844 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1845 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1846 ( "GADTs", Opt_GADTs, const Supported ),
1847 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1848 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1849 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1851 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1853 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1854 -- On by default (which is not strictly H98):
1855 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1856 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1857 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1858 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1859 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1860 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1861 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1862 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1864 ( "PatternSignatures", Opt_ScopedTypeVariables,
1865 deprecatedForLanguage "ScopedTypeVariables" ),
1867 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1868 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1869 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1870 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1871 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1872 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1873 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1874 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1875 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1876 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1877 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1878 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1879 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1880 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1881 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1882 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1883 ( "PackageImports", Opt_PackageImports, const Supported ),
1884 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1887 impliedFlags :: [(DynFlag, DynFlag)]
1889 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1890 , (Opt_Rank2Types, Opt_ExplicitForAll)
1891 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1892 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1893 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1894 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1896 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1897 -- be completely rigid for GADTs
1899 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1900 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1901 -- all over the place
1903 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1904 -- Note [Scoped tyvars] in TcBinds
1905 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1907 -- Record wild-cards implies field disambiguation
1908 -- Otherwise if you write (C {..}) you may well get
1909 -- stuff like " 'a' not in scope ", which is a bit silly
1910 -- if the compiler has just filled in field 'a' of constructor 'C'
1911 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1914 glasgowExtsFlags :: [DynFlag]
1915 glasgowExtsFlags = [
1916 Opt_PrintExplicitForalls
1917 , Opt_ForeignFunctionInterface
1918 , Opt_UnliftedFFITypes
1920 , Opt_ImplicitParams
1921 , Opt_ScopedTypeVariables
1923 , Opt_TypeSynonymInstances
1924 , Opt_StandaloneDeriving
1925 , Opt_DeriveDataTypeable
1927 , Opt_DeriveFoldable
1928 , Opt_DeriveTraversable
1929 , Opt_FlexibleContexts
1930 , Opt_FlexibleInstances
1931 , Opt_ConstrainedClassMethods
1932 , Opt_MultiParamTypeClasses
1933 , Opt_FunctionalDependencies
1935 , Opt_PolymorphicComponents
1936 , Opt_ExistentialQuantification
1938 , Opt_PostfixOperators
1940 , Opt_LiberalTypeSynonyms
1944 , Opt_ParallelListComp
1945 , Opt_EmptyDataDecls
1946 , Opt_KindSignatures
1947 , Opt_GeneralizedNewtypeDeriving
1948 , Opt_TypeFamilies ]
1950 -- -----------------------------------------------------------------------------
1951 -- Parsing the dynamic flags.
1953 -- | Parse dynamic flags from a list of command line arguments. Returns the
1954 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1955 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1956 -- flags or missing arguments).
1957 parseDynamicFlags :: Monad m =>
1958 DynFlags -> [Located String]
1959 -> m (DynFlags, [Located String], [Located String])
1960 -- ^ Updated 'DynFlags', left-over arguments, and
1961 -- list of warnings.
1962 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1964 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1965 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1966 parseDynamicNoPackageFlags :: Monad m =>
1967 DynFlags -> [Located String]
1968 -> m (DynFlags, [Located String], [Located String])
1969 -- ^ Updated 'DynFlags', left-over arguments, and
1970 -- list of warnings.
1971 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1973 parseDynamicFlags_ :: Monad m =>
1974 DynFlags -> [Located String] -> Bool
1975 -> m (DynFlags, [Located String], [Located String])
1976 parseDynamicFlags_ dflags0 args pkg_flags = do
1977 -- XXX Legacy support code
1978 -- We used to accept things like
1979 -- optdep-f -optdepdepend
1980 -- optdep-f -optdep depend
1981 -- optdep -f -optdepdepend
1982 -- optdep -f -optdep depend
1983 -- but the spaces trip up proper argument handling. So get rid of them.
1984 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1985 f (x : xs) = x : f xs
1989 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1990 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1991 | otherwise = dynamic_flags
1993 let ((leftover, errs, warns), dflags1)
1994 = runCmdLine (processArgs flag_spec args') dflags0
1995 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1997 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1998 -- isn't up to the job. We know that if hscTarget == HscC, then the
1999 -- user has explicitly used -fvia-C, because -fasm is the default,
2000 -- unless there is no NCG on this platform. The latter case is
2001 -- checked when the -fPIC flag is parsed.
2003 let (pic_warns, dflags2) =
2004 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
2005 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
2006 dflags1{ hscTarget = HscAsm })
2009 return (dflags2, leftover, pic_warns ++ warns)
2011 type DynP = CmdLineP DynFlags
2013 upd :: (DynFlags -> DynFlags) -> DynP ()
2015 dfs <- getCmdLineState
2016 putCmdLineState $! (f dfs)
2018 --------------------------
2019 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2020 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
2021 ; mapM_ setDynFlag deps }
2023 deps = [ d | (f', d) <- impliedFlags, f' == f ]
2024 -- When you set f, set the ones it implies
2025 -- NB: use setDynFlag recursively, in case the implied flags
2026 -- implies further flags
2027 -- When you un-set f, however, we don't un-set the things it implies
2028 -- (except for -fno-glasgow-exts, which is treated specially)
2030 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2032 --------------------------
2033 setDumpFlag :: DynFlag -> OptKind DynP
2034 setDumpFlag dump_flag
2035 = NoArg (do { setDynFlag dump_flag
2036 ; when want_recomp forceRecompile })
2038 -- Certain dumpy-things are really interested in what's going
2039 -- on during recompilation checking, so in those cases we
2040 -- don't want to turn it off.
2041 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2042 Opt_D_dump_hi_diffs]
2044 forceRecompile :: DynP ()
2045 -- Whenver we -ddump, force recompilation (by switching off the
2046 -- recompilation checker), else you don't see the dump! However,
2047 -- don't switch it off in --make mode, else *everything* gets
2048 -- recompiled which probably isn't what you want
2049 forceRecompile = do { dfs <- getCmdLineState
2050 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2052 force_recomp dfs = isOneShot (ghcMode dfs)
2054 setVerboseCore2Core :: DynP ()
2055 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
2057 upd (\s -> s { shouldDumpSimplPhase = const True })
2059 setDumpSimplPhases :: String -> DynP ()
2060 setDumpSimplPhases s = do forceRecompile
2061 upd (\s -> s { shouldDumpSimplPhase = spec })
2063 spec :: SimplifierMode -> Bool
2065 . map (join (&&) . map match . split ':')
2071 join :: (Bool -> Bool -> Bool)
2072 -> [SimplifierMode -> Bool]
2073 -> SimplifierMode -> Bool
2074 join _ [] = const True
2075 join op ss = foldr1 (\f g x -> f x `op` g x) ss
2077 match :: String -> SimplifierMode -> Bool
2078 match "" = const True
2079 match s = case reads s of
2080 [(n,"")] -> phase_num n
2083 phase_num :: Int -> SimplifierMode -> Bool
2084 phase_num n (SimplPhase k _) = n == k
2085 phase_num _ _ = False
2087 phase_name :: String -> SimplifierMode -> Bool
2088 phase_name s (SimplGently {}) = s == "gentle"
2089 phase_name s (SimplPhase { sm_names = ss }) = s `elem` ss
2091 setVerbosity :: Maybe Int -> DynP ()
2092 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2094 addCmdlineHCInclude :: String -> DynP ()
2095 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2097 extraPkgConf_ :: FilePath -> DynP ()
2098 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2100 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2102 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2104 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2106 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2108 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2110 setPackageName :: String -> DynFlags -> DynFlags
2111 setPackageName p s = s{ thisPackage = stringToPackageId p }
2113 -- If we're linking a binary, then only targets that produce object
2114 -- code are allowed (requests for other target types are ignored).
2115 setTarget :: HscTarget -> DynP ()
2116 setTarget l = upd set
2119 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2122 -- Changes the target only if we're compiling object code. This is
2123 -- used by -fasm and -fvia-C, which switch from one to the other, but
2124 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
2125 -- can be safely used in an OPTIONS_GHC pragma.
2126 setObjTarget :: HscTarget -> DynP ()
2127 setObjTarget l = upd set
2130 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2133 setOptLevel :: Int -> DynFlags -> DynFlags
2134 setOptLevel n dflags
2135 | hscTarget dflags == HscInterpreted && n > 0
2137 -- not in IO any more, oh well:
2138 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2140 = updOptLevel n dflags
2143 -- -Odph is equivalent to
2145 -- -O2 optimise as much as possible
2146 -- -fno-method-sharing sharing specialisation defeats fusion
2148 -- -fdicts-cheap always inline dictionaries
2149 -- -fmax-simplifier-iterations20 this is necessary sometimes
2150 -- -fsimplifier-phases=3 we use an additional simplifier phase
2152 -- -fno-spec-constr-threshold run SpecConstr even for big loops
2153 -- -fno-spec-constr-count SpecConstr as much as possible
2154 -- -finline-enough-args hack to prevent excessive inlining
2156 setDPHOpt :: DynFlags -> DynFlags
2157 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2159 , specConstrThreshold = Nothing
2160 , specConstrCount = Nothing
2162 `dopt_set` Opt_DictsCheap
2163 `dopt_unset` Opt_MethodSharing
2165 data DPHBackend = DPHPar
2168 deriving(Eq, Ord, Enum, Show)
2170 setDPHBackend :: DPHBackend -> DynP ()
2171 setDPHBackend backend
2173 upd $ \dflags -> dflags { dphBackend = backend }
2174 mapM_ exposePackage (dph_packages backend)
2176 dph_packages DPHThis = []
2177 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
2178 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
2180 dphPackage :: DynFlags -> PackageId
2181 dphPackage dflags = case dphBackend dflags of
2182 DPHPar -> dphParPackageId
2183 DPHSeq -> dphSeqPackageId
2184 DPHThis -> thisPackage dflags
2186 setMainIs :: String -> DynP ()
2188 | not (null main_fn) && isLower (head main_fn)
2189 -- The arg looked like "Foo.Bar.baz"
2190 = upd $ \d -> d{ mainFunIs = Just main_fn,
2191 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2193 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2194 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2196 | otherwise -- The arg looked like "baz"
2197 = upd $ \d -> d{ mainFunIs = Just arg }
2199 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2201 -----------------------------------------------------------------------------
2202 -- Paths & Libraries
2204 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2206 -- -i on its own deletes the import paths
2207 addImportPath "" = upd (\s -> s{importPaths = []})
2208 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2212 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2215 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2217 addFrameworkPath p =
2218 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2220 #ifndef mingw32_TARGET_OS
2221 split_marker :: Char
2222 split_marker = ':' -- not configurable (ToDo)
2225 splitPathList :: String -> [String]
2226 splitPathList s = filter notNull (splitUp s)
2227 -- empty paths are ignored: there might be a trailing
2228 -- ':' in the initial list, for example. Empty paths can
2229 -- cause confusion when they are translated into -I options
2230 -- for passing to gcc.
2232 #ifndef mingw32_TARGET_OS
2233 splitUp xs = split split_marker xs
2235 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2237 -- That is, if "foo:bar:baz" is used, this interpreted as
2238 -- consisting of three entries, 'foo', 'bar', 'baz'.
2239 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2240 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2242 -- Notice that no attempt is made to fully replace the 'standard'
2243 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2244 -- that this will cause too much breakage for users & ':' will
2245 -- work fine even with DOS paths, if you're not insisting on being silly.
2248 splitUp (x:':':div:xs) | div `elem` dir_markers
2249 = ((x:':':div:p): splitUp rs)
2251 (p,rs) = findNextPath xs
2252 -- we used to check for existence of the path here, but that
2253 -- required the IO monad to be threaded through the command-line
2254 -- parser which is quite inconvenient. The
2255 splitUp xs = cons p (splitUp rs)
2257 (p,rs) = findNextPath xs
2262 -- will be called either when we've consumed nought or the
2263 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2264 -- finding the next split marker.
2266 case break (`elem` split_markers) xs of
2267 (p, _:ds) -> (p, ds)
2270 split_markers :: [Char]
2271 split_markers = [':', ';']
2273 dir_markers :: [Char]
2274 dir_markers = ['/', '\\']
2277 -- -----------------------------------------------------------------------------
2278 -- tmpDir, where we store temporary files.
2280 setTmpDir :: FilePath -> DynFlags -> DynFlags
2281 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2282 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2283 -- seem necessary now --SDM 7/2/2008
2285 -----------------------------------------------------------------------------
2288 setOptHpcDir :: String -> DynP ()
2289 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2291 -----------------------------------------------------------------------------
2292 -- Via-C compilation stuff
2294 -- There are some options that we need to pass to gcc when compiling
2295 -- Haskell code via C, but are only supported by recent versions of
2296 -- gcc. The configure script decides which of these options we need,
2297 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2298 -- read before each via-C compilation. The advantage of having these
2299 -- in a separate file is that the file can be created at install-time
2300 -- depending on the available gcc version, and even re-generated later
2301 -- if gcc is upgraded.
2303 -- The options below are not dependent on the version of gcc, only the
2306 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2307 [String]) -- for registerised HC compilations
2308 machdepCCOpts _dflags
2309 #if alpha_TARGET_ARCH
2311 #ifdef HAVE_THREADED_RTS_SUPPORT
2315 -- For now, to suppress the gcc warning "call-clobbered
2316 -- register used for global register variable", we simply
2317 -- disable all warnings altogether using the -w flag. Oh well.
2319 #elif hppa_TARGET_ARCH
2320 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2321 -- (very nice, but too bad the HP /usr/include files don't agree.)
2322 = ( ["-D_HPUX_SOURCE"], [] )
2324 #elif m68k_TARGET_ARCH
2325 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2326 -- popping of args to routines to be explicit; if we let things
2327 -- be deferred 'til after an STGJUMP, imminent death is certain!
2329 -- -fomit-frame-pointer : *don't*
2330 -- It's better to have a6 completely tied up being a frame pointer
2331 -- rather than let GCC pick random things to do with it.
2332 -- (If we want to steal a6, then we would try to do things
2333 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2334 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2336 #elif i386_TARGET_ARCH
2337 -- -fno-defer-pop : basically the same game as for m68k
2339 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2340 -- the fp (%ebp) for our register maps.
2341 = let n_regs = stolen_x86_regs _dflags
2344 #if darwin_TARGET_OS
2345 -- By default, gcc on OS X will generate SSE
2346 -- instructions, which need things 16-byte aligned,
2347 -- but we don't 16-byte align things. Thus drop
2348 -- back to generic i686 compatibility. Trac #2983.
2350 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2351 ["-march=i686", "-m32"],
2353 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2357 "-fomit-frame-pointer",
2358 -- we want -fno-builtin, because when gcc inlines
2359 -- built-in functions like memcpy() it tends to
2360 -- run out of registers, requiring -monly-n-regs
2362 "-DSTOLEN_X86_REGS="++show n_regs ]
2365 #elif ia64_TARGET_ARCH
2366 = ( [], ["-fomit-frame-pointer", "-G0"] )
2368 #elif x86_64_TARGET_ARCH
2370 #if darwin_TARGET_OS
2375 ["-fomit-frame-pointer",
2376 "-fno-asynchronous-unwind-tables",
2377 -- the unwind tables are unnecessary for HC code,
2378 -- and get in the way of -split-objs. Another option
2379 -- would be to throw them away in the mangler, but this
2382 -- calling builtins like strlen() using the FFI can
2383 -- cause gcc to run out of regs, so use the external
2387 #elif sparc_TARGET_ARCH
2389 -- For now, to suppress the gcc warning "call-clobbered
2390 -- register used for global register variable", we simply
2391 -- disable all warnings altogether using the -w flag. Oh well.
2393 #elif powerpc_apple_darwin_TARGET
2395 -- Disable Apple's precompiling preprocessor. It's a great thing
2396 -- for "normal" programs, but it doesn't support register variable
2398 = ( [], ["-no-cpp-precomp"] )
2403 picCCOpts :: DynFlags -> [String]
2405 #if darwin_TARGET_OS
2406 -- Apple prefers to do things the other way round.
2407 -- PIC is on by default.
2408 -- -mdynamic-no-pic:
2409 -- Turn off PIC code generation.
2411 -- Don't generate "common" symbols - these are unwanted
2412 -- in dynamic libraries.
2415 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2417 = ["-mdynamic-no-pic"]
2418 #elif mingw32_TARGET_OS
2419 -- no -fPIC for Windows
2421 = ["-U __PIC__","-D__PIC__"]
2425 | opt_PIC || not opt_Static
2426 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2431 -- -----------------------------------------------------------------------------
2435 can_split = cSplitObjs == "YES"
2437 -- -----------------------------------------------------------------------------
2440 data Printable = String String
2441 | FromDynFlags (DynFlags -> String)
2443 compilerInfo :: [(String, Printable)]
2444 compilerInfo = [("Project name", String cProjectName),
2445 ("Project version", String cProjectVersion),
2446 ("Booter version", String cBooterVersion),
2447 ("Stage", String cStage),
2448 ("Have interpreter", String cGhcWithInterpreter),
2449 ("Object splitting", String cSplitObjs),
2450 ("Have native code generator", String cGhcWithNativeCodeGen),
2451 ("Support SMP", String cGhcWithSMP),
2452 ("Unregisterised", String cGhcUnregisterised),
2453 ("Tables next to code", String cGhcEnableTablesNextToCode),
2454 ("Win32 DLLs", String cEnableWin32DLLs),
2455 ("RTS ways", String cGhcRTSWays),
2456 ("Leading underscore", String cLeadingUnderscore),
2457 ("Debug on", String (show debugIsOn)),
2458 ("LibDir", FromDynFlags topDir)