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
17 flattenExtensionFlags,
18 ensureFlattenedExtensionFlags,
23 HscTarget(..), isObjectTarget, defaultObjectTarget,
24 GhcMode(..), isOneShot,
25 GhcLink(..), isNoLink,
29 fFlags, fLangFlags, xFlags,
33 -- ** Manipulating DynFlags
34 defaultDynFlags, -- DynFlags
35 initDynFlags, -- DynFlags -> IO DynFlags
37 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
44 -- ** Parsing DynFlags
46 parseDynamicNoPackageFlags,
49 supportedLanguagesAndExtensions,
51 -- ** DynFlag C compiler options
52 machdepCCOpts, picCCOpts,
54 -- * Configuration of the stg-to-stg passes
58 -- * Compiler configuration suitable for display to the user
63 #include "HsVersions.h"
65 #ifndef OMIT_NATIVE_CODEGEN
70 import PrelNames ( mAIN )
72 import {-# SOURCE #-} Packages (PackageState)
73 import DriverPhases ( Phase(..), phaseInputExt )
76 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
79 import Maybes ( orElse )
84 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
87 import Control.Monad ( when )
91 import System.FilePath
92 import System.IO ( stderr, hPutChar )
94 -- -----------------------------------------------------------------------------
97 -- | Enumerates the simple on-or-off dynamic flags
103 | Opt_D_dump_cmmz_pretty
107 | Opt_D_dump_asm_native
108 | Opt_D_dump_asm_liveness
109 | Opt_D_dump_asm_coalesce
110 | Opt_D_dump_asm_regalloc
111 | Opt_D_dump_asm_regalloc_stages
112 | Opt_D_dump_asm_conflicts
113 | Opt_D_dump_asm_stats
114 | Opt_D_dump_asm_expanded
121 | Opt_D_dump_inlinings
122 | Opt_D_dump_rule_firings
123 | Opt_D_dump_occur_anal
127 | Opt_D_dump_simpl_iterations
128 | Opt_D_dump_simpl_phases
137 | Opt_D_dump_worker_wrapper
138 | Opt_D_dump_rn_trace
139 | Opt_D_dump_rn_stats
141 | Opt_D_dump_simpl_stats
142 | Opt_D_dump_tc_trace
143 | Opt_D_dump_if_trace
150 | Opt_D_verbose_core2core
151 | Opt_D_verbose_stg2stg
153 | Opt_D_dump_hi_diffs
154 | Opt_D_dump_minimal_imports
155 | Opt_D_dump_mod_cycles
156 | Opt_D_dump_view_pattern_commoning
157 | Opt_D_faststring_stats
158 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
159 | Opt_D_no_debug_output
165 | Opt_WarnIsError -- -Werror; makes warnings fatal
166 | Opt_WarnDuplicateExports
168 | Opt_WarnImplicitPrelude
169 | Opt_WarnIncompletePatterns
170 | Opt_WarnIncompletePatternsRecUpd
171 | Opt_WarnMissingFields
172 | Opt_WarnMissingImportList
173 | Opt_WarnMissingMethods
174 | Opt_WarnMissingSigs
175 | Opt_WarnNameShadowing
176 | Opt_WarnOverlappingPatterns
177 | Opt_WarnSimplePatterns
178 | Opt_WarnTypeDefaults
179 | Opt_WarnMonomorphism
180 | Opt_WarnUnusedBinds
181 | Opt_WarnUnusedImports
182 | Opt_WarnUnusedMatches
183 | Opt_WarnWarningsDeprecations
184 | Opt_WarnDeprecatedFlags
185 | Opt_WarnDodgyExports
186 | Opt_WarnDodgyImports
189 | Opt_WarnUnrecognisedPragmas
190 | Opt_WarnDodgyForeignImports
191 | Opt_WarnLazyUnliftedBindings
192 | Opt_WarnUnusedDoBind
193 | Opt_WarnWrongDoBind
194 | Opt_WarnAlternativeLayoutRuleTransitional
196 | Opt_PrintExplicitForalls
203 | Opt_StaticArgumentTransformation
207 | Opt_DoLambdaEtaExpansion
211 | Opt_UnboxStrictFields
214 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
216 | Opt_RegsGraph -- do graph coloring register allocation
217 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
220 | Opt_IgnoreInterfacePragmas
221 | Opt_OmitInterfacePragmas
222 | Opt_ExposeAllUnfoldings
225 | Opt_AutoSccsOnAllToplevs
226 | Opt_AutoSccsOnExportedToplevs
227 | Opt_AutoSccsOnIndividualCafs
234 | Opt_ExcessPrecision
235 | Opt_EagerBlackHoling
236 | Opt_ReadUserPackageConf
240 | Opt_HideAllPackages
241 | Opt_PrintBindResult
245 | Opt_BreakOnException
247 | Opt_PrintEvldWithShow
248 | Opt_PrintBindContents
251 | Opt_EmitExternalCore
253 | Opt_BuildingCabalPackage
259 | Opt_ConvertToZipCfgAndBack
260 | Opt_AutoLinkPackages
261 | Opt_ImplicitImportQualified
270 | Opt_KeepRawTokenStream
275 data Language = Haskell98 | Haskell2010
279 | Opt_OverlappingInstances
280 | Opt_UndecidableInstances
281 | Opt_IncoherentInstances
282 | Opt_MonomorphismRestriction
285 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
286 | Opt_ForeignFunctionInterface
287 | Opt_UnliftedFFITypes
288 | Opt_GHCForeignImportPrim
289 | Opt_PArr -- Syntactic support for parallel arrays
290 | Opt_Arrows -- Arrow-notation syntax
291 | Opt_TemplateHaskell
294 | Opt_Generics -- "Derivable type classes"
295 | Opt_ImplicitPrelude
296 | Opt_ScopedTypeVariables
300 | Opt_OverloadedStrings
301 | Opt_DisambiguateRecordFields
302 | Opt_RecordWildCards
308 | Opt_DoAndIfThenElse
310 | Opt_StandaloneDeriving
311 | Opt_DeriveDataTypeable
313 | Opt_DeriveTraversable
316 | Opt_TypeSynonymInstances
317 | Opt_FlexibleContexts
318 | Opt_FlexibleInstances
319 | Opt_ConstrainedClassMethods
320 | Opt_MultiParamTypeClasses
321 | Opt_FunctionalDependencies
323 | Opt_PolymorphicComponents
324 | Opt_ExistentialQuantification
328 | Opt_ParallelListComp
329 | Opt_TransformListComp
330 | Opt_GeneralizedNewtypeDeriving
333 | Opt_PostfixOperators
336 | Opt_LiberalTypeSynonyms
339 | Opt_ImpredicativeTypes
342 | Opt_NewQualifiedOperators
344 | Opt_AlternativeLayoutRule
345 | Opt_AlternativeLayoutRuleTransitional
346 | Opt_DatatypeContexts
349 -- | Contains not only a collection of 'DynFlag's but also a plethora of
350 -- information relating to the compilation of a single file or GHC session
351 data DynFlags = DynFlags {
354 hscTarget :: HscTarget,
355 hscOutName :: String, -- ^ Name of the output file
356 extCoreName :: String, -- ^ Name of the .hcr output file
357 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
358 optLevel :: Int, -- ^ Optimisation level
359 simplPhases :: Int, -- ^ Number of simplifier phases
360 maxSimplIterations :: Int, -- ^ Max simplifier iterations
361 shouldDumpSimplPhase :: Maybe String,
362 ruleCheck :: Maybe String,
363 strictnessBefore :: [Int], -- ^ Additional demand analysis
365 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
366 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
367 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
369 #ifndef OMIT_NATIVE_CODEGEN
370 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
372 stolen_x86_regs :: Int,
373 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
374 importPaths :: [FilePath],
376 mainFunIs :: Maybe String,
377 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
379 dphBackend :: DPHBackend,
381 thisPackage :: PackageId, -- ^ name of package currently being compiled
384 ways :: [Way], -- ^ Way flags from the command line
385 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
386 rtsBuildTag :: String, -- ^ The RTS \"way\"
388 -- For object splitting
389 splitInfo :: Maybe (String,Int),
392 objectDir :: Maybe String,
393 dylibInstallName :: Maybe String,
394 hiDir :: Maybe String,
395 stubDir :: Maybe String,
401 outputFile :: Maybe String,
402 outputHi :: Maybe String,
403 dynLibLoader :: DynLibLoader,
405 -- | This is set by 'DriverPipeline.runPipeline' based on where
406 -- its output is going.
407 dumpPrefix :: Maybe FilePath,
409 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
410 -- Set by @-ddump-file-prefix@
411 dumpPrefixForce :: Maybe FilePath,
413 includePaths :: [String],
414 libraryPaths :: [String],
415 frameworkPaths :: [String], -- used on darwin only
416 cmdlineFrameworks :: [String], -- ditto
417 tmpDir :: String, -- no trailing '/'
419 ghcUsagePath :: FilePath, -- Filled in by SysTools
420 ghciUsagePath :: FilePath, -- ditto
421 rtsOpts :: Maybe String,
422 rtsOptsEnabled :: RtsOptsEnabled,
424 hpcDir :: String, -- ^ Path to store the .mix files
426 -- options for particular phases
434 opt_windres :: [String],
435 opt_lo :: [String], -- LLVM: llvm optimiser
436 opt_lc :: [String], -- LLVM: llc static compiler
438 -- commands for particular phases
440 pgm_P :: (String,[Option]),
442 pgm_c :: (String,[Option]),
443 pgm_m :: (String,[Option]),
444 pgm_s :: (String,[Option]),
445 pgm_a :: (String,[Option]),
446 pgm_l :: (String,[Option]),
447 pgm_dll :: (String,[Option]),
449 pgm_sysman :: String,
450 pgm_windres :: String,
451 pgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
452 pgm_lc :: (String,[Option]), -- LLVM: llc static compiler
455 depMakefile :: FilePath,
456 depIncludePkgDeps :: Bool,
457 depExcludeMods :: [ModuleName],
458 depSuffixes :: [String],
461 extraPkgConfs :: [FilePath],
462 topDir :: FilePath, -- filled in by SysTools
463 systemPackageConfig :: FilePath, -- ditto
464 -- ^ The @-package-conf@ flags given on the command line, in the order
467 packageFlags :: [PackageFlag],
468 -- ^ The @-package@ and @-hide-package@ flags from the command-line
471 -- NB. do not modify this field, it is calculated by
472 -- Packages.initPackages and Packages.updatePackages.
473 pkgDatabase :: Maybe [PackageConfig],
474 pkgState :: PackageState,
477 -- These have to be IORefs, because the defaultCleanupHandler needs to
478 -- know what to clean when an exception happens
479 filesToClean :: IORef [FilePath],
480 dirsToClean :: IORef (FiniteMap FilePath FilePath),
484 language :: Maybe Language,
485 extensionFlags :: Either [OnOff ExtensionFlag]
488 -- | Message output action: use "ErrUtils" instead of this if you can
489 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
491 haddockOptions :: Maybe String
494 wayNames :: DynFlags -> [WayName]
495 wayNames = map wayName . ways
497 -- | The target code type of the compilation (if any).
499 -- Whenever you change the target, also make sure to set 'ghcLink' to
500 -- something sensible.
502 -- 'HscNothing' can be used to avoid generating any output, however, note
505 -- * This will not run the desugaring step, thus no warnings generated in
506 -- this step will be output. In particular, this includes warnings related
507 -- to pattern matching. You can run the desugarer manually using
508 -- 'GHC.desugarModule'.
510 -- * If a program uses Template Haskell the typechecker may try to run code
511 -- from an imported module. This will fail if no code has been generated
512 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
513 -- whether this might be the case and choose to either switch to a
514 -- different target or avoid typechecking such modules. (The latter may
515 -- preferable for security reasons.)
518 = HscC -- ^ Generate C code.
519 | HscAsm -- ^ Generate assembly using the native code generator.
520 | HscLlvm -- ^ Generate assembly using the llvm code generator.
521 | HscJava -- ^ Generate Java bytecode.
522 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
523 | HscNothing -- ^ Don't generate any code. See notes above.
526 -- | Will this target result in an object file on the disk?
527 isObjectTarget :: HscTarget -> Bool
528 isObjectTarget HscC = True
529 isObjectTarget HscAsm = True
530 isObjectTarget HscLlvm = True
531 isObjectTarget _ = False
533 -- | The 'GhcMode' tells us whether we're doing multi-module
534 -- compilation (controlled via the "GHC" API) or one-shot
535 -- (single-module) compilation. This makes a difference primarily to
536 -- the "Finder": in one-shot mode we look for interface files for
537 -- imported modules, but in multi-module mode we look for source files
538 -- in order to check whether they need to be recompiled.
540 = CompManager -- ^ @\-\-make@, GHCi, etc.
541 | OneShot -- ^ @ghc -c Foo.hs@
542 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
545 instance Outputable GhcMode where
546 ppr CompManager = ptext (sLit "CompManager")
547 ppr OneShot = ptext (sLit "OneShot")
548 ppr MkDepend = ptext (sLit "MkDepend")
550 isOneShot :: GhcMode -> Bool
551 isOneShot OneShot = True
552 isOneShot _other = False
554 -- | What to do in the link step, if there is one.
556 = NoLink -- ^ Don't link at all
557 | LinkBinary -- ^ Link object code into a binary
558 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
559 -- bytecode and object code).
560 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
563 isNoLink :: GhcLink -> Bool
564 isNoLink NoLink = True
567 -- Is it worth evaluating this Bool and caching it in the DynFlags value
568 -- during initDynFlags?
569 doingTickyProfiling :: DynFlags -> Bool
570 doingTickyProfiling _ = opt_Ticky
571 -- XXX -ticky is a static flag, because it implies -debug which is also
572 -- static. If the way flags were made dynamic, we could fix this.
575 = ExposePackage String
576 | ExposePackageId String
578 | IgnorePackage String
581 defaultHscTarget :: HscTarget
582 defaultHscTarget = defaultObjectTarget
584 -- | The 'HscTarget' value corresponding to the default way to create
585 -- object files on the current platform.
586 defaultObjectTarget :: HscTarget
588 | cGhcWithNativeCodeGen == "YES" = HscAsm
593 | Wrapped (Maybe String)
597 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
599 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
600 initDynFlags :: DynFlags -> IO DynFlags
601 initDynFlags dflags = do
602 -- someday these will be dynamic flags
603 ways <- readIORef v_Ways
604 refFilesToClean <- newIORef []
605 refDirsToClean <- newIORef emptyFM
608 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
609 rtsBuildTag = mkBuildTag ways,
610 filesToClean = refFilesToClean,
611 dirsToClean = refDirsToClean
614 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
615 -- and must be fully initialized by 'GHC.newSession' first.
616 defaultDynFlags :: DynFlags
619 ghcMode = CompManager,
620 ghcLink = LinkBinary,
621 hscTarget = defaultHscTarget,
627 maxSimplIterations = 4,
628 shouldDumpSimplPhase = Nothing,
630 specConstrThreshold = Just 200,
631 specConstrCount = Just 3,
632 liberateCaseThreshold = Just 200,
633 strictnessBefore = [],
635 #ifndef OMIT_NATIVE_CODEGEN
636 targetPlatform = defaultTargetPlatform,
639 cmdlineHcIncludes = [],
643 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
647 thisPackage = mainPackageId,
650 dylibInstallName = Nothing,
654 objectSuf = phaseInputExt StopLn,
655 hcSuf = phaseInputExt HCc,
658 outputFile = Nothing,
660 dynLibLoader = SystemDependent,
661 dumpPrefix = Nothing,
662 dumpPrefixForce = Nothing,
666 cmdlineFrameworks = [],
667 tmpDir = cDEFAULT_TMPDIR,
669 rtsOptsEnabled = RtsOptsSafeOnly,
675 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
688 pkgDatabase = Nothing,
689 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
690 ways = panic "defaultDynFlags: No ways",
691 buildTag = panic "defaultDynFlags: No buildTag",
692 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
694 -- initSysTools fills all these in
695 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
696 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
697 topDir = panic "defaultDynFlags: No topDir",
698 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
699 pgm_L = panic "defaultDynFlags: No pgm_L",
700 pgm_P = panic "defaultDynFlags: No pgm_P",
701 pgm_F = panic "defaultDynFlags: No pgm_F",
702 pgm_c = panic "defaultDynFlags: No pgm_c",
703 pgm_m = panic "defaultDynFlags: No pgm_m",
704 pgm_s = panic "defaultDynFlags: No pgm_s",
705 pgm_a = panic "defaultDynFlags: No pgm_a",
706 pgm_l = panic "defaultDynFlags: No pgm_l",
707 pgm_dll = panic "defaultDynFlags: No pgm_dll",
708 pgm_T = panic "defaultDynFlags: No pgm_T",
709 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
710 pgm_windres = panic "defaultDynFlags: No pgm_windres",
711 pgm_lo = panic "defaultDynFlags: No pgm_lo",
712 pgm_lc = panic "defaultDynFlags: No pgm_lc",
713 -- end of initSysTools values
715 depMakefile = "Makefile",
716 depIncludePkgDeps = False,
719 -- end of ghc -M values
720 filesToClean = panic "defaultDynFlags: No filesToClean",
721 dirsToClean = panic "defaultDynFlags: No dirsToClean",
722 haddockOptions = Nothing,
724 Opt_AutoLinkPackages,
725 Opt_ReadUserPackageConf,
735 Opt_PrintBindContents
737 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
738 -- The default -O0 options
742 extensionFlags = Left [],
744 log_action = \severity srcSpan style msg ->
746 SevOutput -> printOutput (msg style)
747 SevInfo -> printErrs (msg style)
748 SevFatal -> printErrs (msg style)
751 printErrs ((mkLocMessage srcSpan msg) style)
752 -- careful (#2302): printErrs prints in UTF-8, whereas
753 -- converting to string first and using hPutStr would
754 -- just emit the low 8 bits of each unicode char.
758 Note [Verbosity levels]
759 ~~~~~~~~~~~~~~~~~~~~~~~
760 0 | print errors & warnings only
761 1 | minimal verbosity: print "compiling M ... done." for each module.
762 2 | equivalent to -dshow-passes
763 3 | equivalent to existing "ghc -v"
764 4 | "ghc -v -ddump-most"
765 5 | "ghc -v -ddump-all"
771 flattenExtensionFlags :: DynFlags -> DynFlags
772 flattenExtensionFlags dflags
773 = case extensionFlags dflags of
776 extensionFlags = Right $ flattenExtensionFlags' (language dflags) onoffs
779 panic "Flattening already-flattened extension flags"
781 ensureFlattenedExtensionFlags :: DynFlags -> DynFlags
782 ensureFlattenedExtensionFlags dflags
783 = case extensionFlags dflags of
786 extensionFlags = Right $ flattenExtensionFlags' (language dflags) onoffs
791 -- OnOffs accumulate in reverse order, so we use foldr in order to
792 -- process them in the right order
793 flattenExtensionFlags' :: Maybe Language -> [OnOff ExtensionFlag]
795 flattenExtensionFlags' ml = foldr f defaultExtensionFlags
796 where f (On f) flags = f : delete f flags
797 f (Off f) flags = delete f flags
798 defaultExtensionFlags = languageExtensions ml
800 languageExtensions :: Maybe Language -> [ExtensionFlag]
801 languageExtensions Nothing
802 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
803 -- behaviour the default, to see if anyone notices
805 : languageExtensions (Just Haskell2010)
806 languageExtensions (Just Haskell98)
807 = [Opt_ImplicitPrelude,
808 Opt_MonomorphismRestriction,
810 Opt_DatatypeContexts]
811 languageExtensions (Just Haskell2010)
812 = [Opt_ImplicitPrelude,
813 Opt_MonomorphismRestriction,
814 Opt_DatatypeContexts,
816 Opt_ForeignFunctionInterface,
821 -- The DOpt class is a temporary workaround, to avoid having to do
822 -- a mass-renaming dopt->lopt at the moment
824 dopt :: a -> DynFlags -> Bool
825 dopt_set :: DynFlags -> a -> DynFlags
826 dopt_unset :: DynFlags -> a -> DynFlags
828 instance DOpt DynFlag where
831 dopt_unset = dopt_unset'
833 instance DOpt ExtensionFlag where
836 dopt_unset = lopt_unset
838 -- | Test whether a 'DynFlag' is set
839 dopt' :: DynFlag -> DynFlags -> Bool
840 dopt' f dflags = f `elem` (flags dflags)
843 dopt_set' :: DynFlags -> DynFlag -> DynFlags
844 dopt_set' dfs f = dfs{ flags = f : flags dfs }
846 -- | Unset a 'DynFlag'
847 dopt_unset' :: DynFlags -> DynFlag -> DynFlags
848 dopt_unset' dfs f = dfs{ flags = filter (/= f) (flags dfs) }
850 -- | Test whether a 'ExtensionFlag' is set
851 lopt :: ExtensionFlag -> DynFlags -> Bool
852 lopt f dflags = case extensionFlags dflags of
853 Left _ -> panic ("Testing for extension flag " ++ show f ++ " before flattening")
854 Right flags -> f `elem` flags
856 -- | Set a 'ExtensionFlag'
857 lopt_set :: DynFlags -> ExtensionFlag -> DynFlags
858 lopt_set dfs f = case extensionFlags dfs of
859 Left onoffs -> dfs { extensionFlags = Left (On f : onoffs) }
860 Right _ -> panic ("Setting extension flag " ++ show f ++ " after flattening")
862 -- | Set a 'ExtensionFlag'
863 lopt_set_flattened :: DynFlags -> ExtensionFlag -> DynFlags
864 lopt_set_flattened dfs f = case extensionFlags dfs of
866 panic ("Setting extension flag " ++ show f ++ " before flattening, but expected flattened")
868 dfs { extensionFlags = Right (f : delete f flags) }
870 -- | Unset a 'ExtensionFlag'
871 lopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
872 lopt_unset dfs f = case extensionFlags dfs of
873 Left onoffs -> dfs { extensionFlags = Left (Off f : onoffs) }
874 Right _ -> panic ("Unsetting extension flag " ++ show f ++ " after flattening")
876 -- | Unset a 'ExtensionFlag'
877 lopt_unset_flattened :: DynFlags -> ExtensionFlag -> DynFlags
878 lopt_unset_flattened dfs f = case extensionFlags dfs of
880 panic ("Unsetting extension flag " ++ show f ++ " before flattening, but expected flattened")
882 dfs { extensionFlags = Right (delete f flags) }
884 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
885 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
886 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
887 -> [a] -- ^ Correctly ordered extracted options
888 getOpts dflags opts = reverse (opts dflags)
889 -- We add to the options from the front, so we need to reverse the list
891 -- | Gets the verbosity flag for the current verbosity level. This is fed to
892 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
893 getVerbFlag :: DynFlags -> String
895 | verbosity dflags >= 3 = "-v"
898 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
899 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
900 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
902 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres, addOptlo, addOptlc,
903 addCmdlineFramework, addHaddockOpts
904 :: String -> DynFlags -> DynFlags
905 setOutputFile, setOutputHi, setDumpPrefixForce
906 :: Maybe String -> DynFlags -> DynFlags
908 setObjectDir f d = d{ objectDir = Just f}
909 setHiDir f d = d{ hiDir = Just f}
910 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
911 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
912 -- \#included from the .hc file when compiling with -fvia-C.
913 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
914 setDylibInstallName f d = d{ dylibInstallName = Just f}
916 setObjectSuf f d = d{ objectSuf = f}
917 setHiSuf f d = d{ hiSuf = f}
918 setHcSuf f d = d{ hcSuf = f}
920 setOutputFile f d = d{ outputFile = f}
921 setOutputHi f d = d{ outputHi = f}
923 parseDynLibLoaderMode f d =
925 ("deploy", "") -> d{ dynLibLoader = Deployable }
926 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
927 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
928 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
929 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
930 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
932 setDumpPrefixForce f d = d { dumpPrefixForce = f}
934 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
935 -- Config.hs should really use Option.
936 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
938 setPgmL f d = d{ pgm_L = f}
939 setPgmF f d = d{ pgm_F = f}
940 setPgmc f d = d{ pgm_c = (f,[])}
941 setPgmm f d = d{ pgm_m = (f,[])}
942 setPgms f d = d{ pgm_s = (f,[])}
943 setPgma f d = d{ pgm_a = (f,[])}
944 setPgml f d = d{ pgm_l = (f,[])}
945 setPgmdll f d = d{ pgm_dll = (f,[])}
946 setPgmwindres f d = d{ pgm_windres = f}
947 setPgmlo f d = d{ pgm_lo = (f,[])}
948 setPgmlc f d = d{ pgm_lc = (f,[])}
950 addOptL f d = d{ opt_L = f : opt_L d}
951 addOptP f d = d{ opt_P = f : opt_P d}
952 addOptF f d = d{ opt_F = f : opt_F d}
953 addOptc f d = d{ opt_c = f : opt_c d}
954 addOptm f d = d{ opt_m = f : opt_m d}
955 addOpta f d = d{ opt_a = f : opt_a d}
956 addOptl f d = d{ opt_l = f : opt_l d}
957 addOptwindres f d = d{ opt_windres = f : opt_windres d}
958 addOptlo f d = d{ opt_lo = f : opt_lo d}
959 addOptlc f d = d{ opt_lc = f : opt_lc d}
961 setDepMakefile :: FilePath -> DynFlags -> DynFlags
962 setDepMakefile f d = d { depMakefile = deOptDep f }
964 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
965 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
967 addDepExcludeMod :: String -> DynFlags -> DynFlags
969 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
971 addDepSuffix :: FilePath -> DynFlags -> DynFlags
972 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
975 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
976 -- we need to strip the "-optdep" off of the arg
977 deOptDep :: String -> String
978 deOptDep x = case stripPrefix "-optdep" x of
982 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
984 addHaddockOpts f d = d{ haddockOptions = Just f}
986 -- -----------------------------------------------------------------------------
987 -- Command-line options
989 -- | When invoking external tools as part of the compilation pipeline, we
990 -- pass these a sequence of options on the command-line. Rather than
991 -- just using a list of Strings, we use a type that allows us to distinguish
992 -- between filepaths and 'other stuff'. The reason for this is that
993 -- this type gives us a handle on transforming filenames, and filenames only,
994 -- to whatever format they're expected to be on a particular platform.
996 = FileOption -- an entry that _contains_ filename(s) / filepaths.
997 String -- a non-filepath prefix that shouldn't be
998 -- transformed (e.g., "/out=")
999 String -- the filepath/filename portion
1002 showOpt :: Option -> String
1003 showOpt (FileOption pre f) = pre ++ f
1004 showOpt (Option s) = s
1006 -----------------------------------------------------------------------------
1007 -- Setting the optimisation level
1009 updOptLevel :: Int -> DynFlags -> DynFlags
1010 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1012 = dfs2{ optLevel = final_n }
1014 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1015 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1016 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1018 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1019 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1021 optLevelFlags :: [([Int], DynFlag)]
1023 = [ ([0], Opt_IgnoreInterfacePragmas)
1024 , ([0], Opt_OmitInterfacePragmas)
1026 , ([1,2], Opt_IgnoreAsserts)
1027 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1029 , ([1,2], Opt_DoEtaReduction)
1030 , ([1,2], Opt_CaseMerge)
1031 , ([1,2], Opt_Strictness)
1033 , ([1,2], Opt_FullLaziness)
1034 , ([1,2], Opt_Specialise)
1035 , ([1,2], Opt_FloatIn)
1037 , ([2], Opt_LiberateCase)
1038 , ([2], Opt_SpecConstr)
1040 -- , ([2], Opt_StaticArgumentTransformation)
1041 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1042 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1043 -- several improvements to the heuristics, and I'm concerned that without
1044 -- those changes SAT will interfere with some attempts to write "high
1045 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1046 -- this year. In particular, the version in HEAD lacks the tail call
1047 -- criterion, so many things that look like reasonable loops will be
1048 -- turned into functions with extra (unneccesary) thunk creation.
1050 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1051 -- This one is important for a tiresome reason:
1052 -- we want to make sure that the bindings for data
1053 -- constructors are eta-expanded. This is probably
1054 -- a good thing anyway, but it seems fragile.
1057 -- -----------------------------------------------------------------------------
1058 -- Standard sets of warning options
1060 standardWarnings :: [DynFlag]
1062 = [ Opt_WarnWarningsDeprecations,
1063 Opt_WarnDeprecatedFlags,
1064 Opt_WarnUnrecognisedPragmas,
1065 Opt_WarnOverlappingPatterns,
1066 Opt_WarnMissingFields,
1067 Opt_WarnMissingMethods,
1068 Opt_WarnDuplicateExports,
1069 Opt_WarnLazyUnliftedBindings,
1070 Opt_WarnDodgyForeignImports,
1071 Opt_WarnWrongDoBind,
1072 Opt_WarnAlternativeLayoutRuleTransitional
1075 minusWOpts :: [DynFlag]
1077 = standardWarnings ++
1078 [ Opt_WarnUnusedBinds,
1079 Opt_WarnUnusedMatches,
1080 Opt_WarnUnusedImports,
1081 Opt_WarnIncompletePatterns,
1082 Opt_WarnDodgyExports,
1083 Opt_WarnDodgyImports
1086 minusWallOpts :: [DynFlag]
1089 [ Opt_WarnTypeDefaults,
1090 Opt_WarnNameShadowing,
1091 Opt_WarnMissingSigs,
1094 Opt_WarnUnusedDoBind
1097 -- minuswRemovesOpts should be every warning option
1098 minuswRemovesOpts :: [DynFlag]
1101 [Opt_WarnImplicitPrelude,
1102 Opt_WarnIncompletePatternsRecUpd,
1103 Opt_WarnSimplePatterns,
1104 Opt_WarnMonomorphism,
1105 Opt_WarnUnrecognisedPragmas,
1109 -- -----------------------------------------------------------------------------
1110 -- StgToDo: abstraction of stg-to-stg passes to run.
1113 = StgDoMassageForProfiling -- should be (next to) last
1114 -- There's also setStgVarInfo, but its absolute "lastness"
1115 -- is so critical that it is hardwired in (no flag).
1118 getStgToDo :: DynFlags -> [StgToDo]
1122 stg_stats = dopt Opt_StgStats dflags
1124 todo1 = if stg_stats then [D_stg_stats] else []
1126 todo2 | WayProf `elem` wayNames dflags
1127 = StgDoMassageForProfiling : todo1
1131 -- -----------------------------------------------------------------------------
1134 allFlags :: [String]
1135 allFlags = map ('-':) $
1136 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1137 map ("fno-"++) flags ++
1138 map ("f"++) flags ++
1139 map ("f"++) flags' ++
1140 map ("X"++) supportedExtensions
1141 where ok (PrefixPred _ _) = False
1143 flags = [ name | (name, _, _) <- fFlags ]
1144 flags' = [ name | (name, _, _) <- fLangFlags ]
1146 dynamic_flags :: [Flag DynP]
1148 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1149 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp)) Supported
1150 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1151 , Flag "#include" (HasArg (addCmdlineHCInclude))
1152 (DeprecatedFullText "-#include and INCLUDE pragmas are deprecated: They no longer have any effect")
1153 , Flag "v" (OptIntSuffix setVerbosity) Supported
1155 ------- Specific phases --------------------------------------------
1156 -- need to appear before -pgmL to be parsed as LLVM flags.
1157 , Flag "pgmlo" (HasArg (upd . setPgmlo)) Supported
1158 , Flag "pgmlc" (HasArg (upd . setPgmlc)) Supported
1160 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1161 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1162 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1163 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1164 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1165 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1166 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1167 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1168 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1169 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1171 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1172 , Flag "optlo" (HasArg (upd . addOptlo)) Supported
1173 , Flag "optlc" (HasArg (upd . addOptlc)) Supported
1175 , Flag "optL" (HasArg (upd . addOptL)) Supported
1176 , Flag "optP" (HasArg (upd . addOptP)) Supported
1177 , Flag "optF" (HasArg (upd . addOptF)) Supported
1178 , Flag "optc" (HasArg (upd . addOptc)) Supported
1179 , Flag "optm" (HasArg (upd . addOptm)) Supported
1180 , Flag "opta" (HasArg (upd . addOpta)) Supported
1181 , Flag "optl" (HasArg (upd . addOptl)) Supported
1182 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1185 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1188 -------- ghc -M -----------------------------------------------------
1189 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1190 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1191 (Deprecated "Use -dep-suffix instead")
1192 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1193 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1194 (Deprecated "Use -dep-makefile instead")
1195 , Flag "optdep-w" (NoArg (return ()))
1196 (Deprecated "-optdep-w doesn't do anything")
1197 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1198 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1199 (Deprecated "Use -include-pkg-deps instead")
1200 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1201 (Deprecated "Use -include-pkg-deps instead")
1202 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1203 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1204 (Deprecated "Use -exclude-module instead")
1205 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1206 (Deprecated "Use -exclude-module instead")
1208 -------- Linking ----------------------------------------------------
1209 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1211 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1213 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1215 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1217 ------- Libraries ---------------------------------------------------
1218 , Flag "L" (Prefix addLibraryPath ) Supported
1219 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1221 ------- Frameworks --------------------------------------------------
1222 -- -framework-path should really be -F ...
1223 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1224 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1226 ------- Output Redirection ------------------------------------------
1227 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1228 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1229 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1230 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1231 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1232 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1233 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1234 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1235 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1236 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1237 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1240 ------- Keeping temporary files -------------------------------------
1241 -- These can be singular (think ghc -c) or plural (think ghc --make)
1242 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1243 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1244 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1245 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1246 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1247 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1248 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1249 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1250 -- This only makes sense as plural
1251 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1253 ------- Miscellaneous ----------------------------------------------
1254 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1255 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1256 , Flag "with-rtsopts" (HasArg setRtsOpts) Supported
1257 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll)) Supported
1258 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll)) Supported
1259 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly)) Supported
1260 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone)) Supported
1261 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone)) Supported
1262 , Flag "main-is" (SepArg setMainIs ) Supported
1263 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1264 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1265 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1267 ------- recompilation checker --------------------------------------
1268 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1269 (Deprecated "Use -fno-force-recomp instead")
1270 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1271 (Deprecated "Use -fforce-recomp instead")
1273 ------ HsCpp opts ---------------------------------------------------
1274 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1275 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1277 ------- Include/Import Paths ----------------------------------------
1278 , Flag "I" (Prefix addIncludePath) Supported
1279 , Flag "i" (OptPrefix addImportPath ) Supported
1281 ------ Debugging ----------------------------------------------------
1282 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1284 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1286 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1288 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1290 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1292 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1294 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1296 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1298 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1300 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1302 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1304 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1306 , Flag "ddump-asm-regalloc-stages"
1307 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1309 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1311 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1313 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1314 ; setDumpFlag' Opt_D_dump_llvm}))
1316 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1318 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1320 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1322 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1324 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1326 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1328 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1330 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1332 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1334 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1336 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1338 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1340 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1342 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1344 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1346 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1348 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1350 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1352 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1354 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1356 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1358 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1360 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1362 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1364 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1366 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1368 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1370 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1372 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1374 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1376 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1378 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1379 ; setVerboseCore2Core }))
1381 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1383 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1385 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1387 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1389 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1391 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1393 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1395 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1397 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1399 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1402 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1404 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1406 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1408 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1410 , Flag "dshow-passes"
1411 (NoArg (do forceRecompile
1412 setVerbosity (Just 2)))
1414 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1417 ------ Machine dependant (-m<blah>) stuff ---------------------------
1419 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1421 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1423 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1426 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1429 ------ Warning opts -------------------------------------------------
1430 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1432 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1434 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1436 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1438 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1439 (Deprecated "Use -w instead")
1440 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1443 ------ Optimisation flags ------------------------------------------
1444 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1445 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1446 (Deprecated "Use -O0 instead")
1447 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1448 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1450 -- If the number is missing, use 1
1452 , Flag "fsimplifier-phases"
1453 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1455 , Flag "fmax-simplifier-iterations"
1456 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1459 , Flag "fspec-constr-threshold"
1460 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1462 , Flag "fno-spec-constr-threshold"
1463 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1465 , Flag "fspec-constr-count"
1466 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1468 , Flag "fno-spec-constr-count"
1469 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1471 , Flag "fliberate-case-threshold"
1472 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1474 , Flag "fno-liberate-case-threshold"
1475 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1478 , Flag "frule-check"
1479 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1481 , Flag "fcontext-stack"
1482 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1485 , Flag "fstrictness-before"
1486 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1489 ------ Profiling ----------------------------------------------------
1491 -- XXX Should the -f* flags be deprecated?
1492 -- They don't seem to be documented
1493 , Flag "fauto-sccs-on-all-toplevs"
1494 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1497 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1499 , Flag "no-auto-all"
1500 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1502 , Flag "fauto-sccs-on-exported-toplevs"
1503 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1506 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1509 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1511 , Flag "fauto-sccs-on-individual-cafs"
1512 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1515 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1518 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1521 ------ DPH flags ----------------------------------------------------
1524 (NoArg (setDPHBackend DPHSeq))
1527 (NoArg (setDPHBackend DPHPar))
1530 (NoArg (setDPHBackend DPHThis))
1533 ------ Compiler flags -----------------------------------------------
1535 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1536 , Flag "fvia-c" (NoArg (setObjTarget HscC))
1537 (Deprecated "The -fvia-c flag will be removed in a future GHC release")
1538 , Flag "fvia-C" (NoArg (setObjTarget HscC))
1539 (Deprecated "The -fvia-C flag will be removed in a future GHC release")
1540 , Flag "fllvm" (NoArg (setObjTarget HscLlvm)) Supported
1542 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1543 setTarget HscNothing))
1545 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1546 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1548 , Flag "fglasgow-exts" (NoArg enableGlasgowExts)
1550 , Flag "fno-glasgow-exts" (NoArg disableGlasgowExts)
1553 ++ map (mkFlag True "f" setDynFlag ) fFlags
1554 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1555 ++ map (mkFlag True "f" setExtensionFlag ) fLangFlags
1556 ++ map (mkFlag False "fno-" unSetExtensionFlag) fLangFlags
1557 ++ map (mkFlag True "X" setExtensionFlag ) xFlags
1558 ++ map (mkFlag False "XNo" unSetExtensionFlag) xFlags
1559 ++ map (mkFlag True "X" setLanguage ) languageFlags
1561 package_flags :: [Flag DynP]
1563 ------- Packages ----------------------------------------------------
1564 Flag "package-conf" (HasArg extraPkgConf_) Supported
1565 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1567 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1568 , Flag "package-id" (HasArg exposePackageId) Supported
1569 , Flag "package" (HasArg exposePackage) Supported
1570 , Flag "hide-package" (HasArg hidePackage) Supported
1571 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1573 , Flag "ignore-package" (HasArg ignorePackage)
1575 , Flag "syslib" (HasArg exposePackage)
1576 (Deprecated "Use -package instead")
1579 mkFlag :: Bool -- ^ True <=> it should be turned on
1580 -> String -- ^ The flag prefix
1581 -> (flag -> DynP ())
1582 -> (String, flag, Bool -> Deprecated)
1584 mkFlag turnOn flagPrefix f (name, flag, deprecated)
1585 = Flag (flagPrefix ++ name) (NoArg (f flag)) (deprecated turnOn)
1587 deprecatedForExtension :: String -> Bool -> Deprecated
1588 deprecatedForExtension lang turn_on
1589 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1591 flag | turn_on = lang
1592 | otherwise = "No"++lang
1594 useInstead :: String -> Bool -> Deprecated
1595 useInstead flag turn_on
1596 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1598 no = if turn_on then "" else "no-"
1600 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1601 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1603 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1604 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1605 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1606 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1607 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1608 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1609 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1610 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1611 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1612 ( "warn-missing-import-lists", Opt_WarnMissingImportList, const Supported ),
1613 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1614 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1615 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1616 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1617 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1618 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1619 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1620 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1621 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1622 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1623 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1624 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1625 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1626 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1627 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1628 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1629 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1630 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1631 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1632 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1633 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, const Supported ),
1634 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1635 ( "strictness", Opt_Strictness, const Supported ),
1636 ( "specialise", Opt_Specialise, const Supported ),
1637 ( "float-in", Opt_FloatIn, const Supported ),
1638 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1639 ( "full-laziness", Opt_FullLaziness, const Supported ),
1640 ( "liberate-case", Opt_LiberateCase, const Supported ),
1641 ( "spec-constr", Opt_SpecConstr, const Supported ),
1642 ( "cse", Opt_CSE, const Supported ),
1643 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1644 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1645 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1646 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1647 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1648 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1649 ( "case-merge", Opt_CaseMerge, const Supported ),
1650 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1651 ( "method-sharing", Opt_MethodSharing, const Supported ),
1652 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1653 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1654 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1655 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1656 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1657 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1658 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1659 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1660 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1661 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1662 ( "break-on-error", Opt_BreakOnError, const Supported ),
1663 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1664 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1665 ( "run-cps", Opt_RunCPS, const Supported ),
1666 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1667 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1668 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1669 ( "vectorise", Opt_Vectorise, const Supported ),
1670 ( "regs-graph", Opt_RegsGraph, const Supported ),
1671 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1672 ( "gen-manifest", Opt_GenManifest, const Supported ),
1673 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1674 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1675 ( "shared-implib", Opt_SharedImplib, const Supported ),
1676 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1677 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1680 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1681 fLangFlags :: [(String, ExtensionFlag, Bool -> Deprecated)]
1683 ( "th", Opt_TemplateHaskell,
1684 deprecatedForExtension "TemplateHaskell" ),
1685 ( "fi", Opt_ForeignFunctionInterface,
1686 deprecatedForExtension "ForeignFunctionInterface" ),
1687 ( "ffi", Opt_ForeignFunctionInterface,
1688 deprecatedForExtension "ForeignFunctionInterface" ),
1689 ( "arrows", Opt_Arrows,
1690 deprecatedForExtension "Arrows" ),
1691 ( "generics", Opt_Generics,
1692 deprecatedForExtension "Generics" ),
1693 ( "implicit-prelude", Opt_ImplicitPrelude,
1694 deprecatedForExtension "ImplicitPrelude" ),
1695 ( "bang-patterns", Opt_BangPatterns,
1696 deprecatedForExtension "BangPatterns" ),
1697 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1698 deprecatedForExtension "MonomorphismRestriction" ),
1699 ( "mono-pat-binds", Opt_MonoPatBinds,
1700 deprecatedForExtension "MonoPatBinds" ),
1701 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1702 deprecatedForExtension "ExtendedDefaultRules" ),
1703 ( "implicit-params", Opt_ImplicitParams,
1704 deprecatedForExtension "ImplicitParams" ),
1705 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1706 deprecatedForExtension "ScopedTypeVariables" ),
1708 deprecatedForExtension "PArr" ),
1709 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1710 deprecatedForExtension "OverlappingInstances" ),
1711 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1712 deprecatedForExtension "UndecidableInstances" ),
1713 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1714 deprecatedForExtension "IncoherentInstances" )
1717 supportedLanguages :: [String]
1718 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1720 supportedExtensions :: [String]
1721 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1723 supportedLanguagesAndExtensions :: [String]
1724 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1726 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1727 languageFlags :: [(String, Language, Bool -> Deprecated)]
1729 ( "Haskell98", Haskell98, const Supported ),
1730 ( "Haskell2010", Haskell2010, const Supported )
1733 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1734 xFlags :: [(String, ExtensionFlag, Bool -> Deprecated)]
1736 ( "CPP", Opt_Cpp, const Supported ),
1737 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1738 ( "TupleSections", Opt_TupleSections, const Supported ),
1739 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1740 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1741 ( "MagicHash", Opt_MagicHash, const Supported ),
1742 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1743 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1744 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1745 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1746 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1747 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1748 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1749 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1750 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1751 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1752 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1753 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1754 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1755 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1756 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1757 ( "RecursiveDo", Opt_RecursiveDo,
1758 deprecatedForExtension "DoRec"),
1759 ( "DoRec", Opt_DoRec, const Supported ),
1760 ( "Arrows", Opt_Arrows, const Supported ),
1761 ( "PArr", Opt_PArr, const Supported ),
1762 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1763 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1764 ( "Generics", Opt_Generics, const Supported ),
1765 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1766 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1767 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1768 ( "RecordPuns", Opt_RecordPuns,
1769 deprecatedForExtension "NamedFieldPuns" ),
1770 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1771 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1772 ( "GADTs", Opt_GADTs, const Supported ),
1773 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1774 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1775 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1776 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1777 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1778 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, const Supported ),
1779 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1780 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1781 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1782 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, const Supported ),
1783 ( "DatatypeContexts", Opt_DatatypeContexts, const Supported ),
1784 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1785 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1786 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1787 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1788 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1790 ( "PatternSignatures", Opt_ScopedTypeVariables,
1791 deprecatedForExtension "ScopedTypeVariables" ),
1793 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1794 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1795 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1796 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1797 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1798 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1799 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1800 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1801 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1802 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1803 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1804 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1805 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1806 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1807 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1808 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1809 ( "PackageImports", Opt_PackageImports, const Supported ),
1810 ( "NewQualifiedOperators", Opt_NewQualifiedOperators,
1811 const $ Deprecated "The new qualified operator syntax was rejected by Haskell'" )
1814 impliedFlags :: [(ExtensionFlag, ExtensionFlag)]
1816 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1817 , (Opt_Rank2Types, Opt_ExplicitForAll)
1818 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1819 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1820 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1821 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1823 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1824 -- be completely rigid for GADTs
1826 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1827 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1828 -- all over the place
1830 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1831 -- Note [Scoped tyvars] in TcBinds
1832 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1834 -- Record wild-cards implies field disambiguation
1835 -- Otherwise if you write (C {..}) you may well get
1836 -- stuff like " 'a' not in scope ", which is a bit silly
1837 -- if the compiler has just filled in field 'a' of constructor 'C'
1838 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1841 enableGlasgowExts :: DynP ()
1842 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1843 mapM_ setExtensionFlag glasgowExtsFlags
1845 disableGlasgowExts :: DynP ()
1846 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1847 mapM_ unSetExtensionFlag glasgowExtsFlags
1849 glasgowExtsFlags :: [ExtensionFlag]
1850 glasgowExtsFlags = [
1851 Opt_ForeignFunctionInterface
1852 , Opt_UnliftedFFITypes
1854 , Opt_ImplicitParams
1855 , Opt_ScopedTypeVariables
1857 , Opt_TypeSynonymInstances
1858 , Opt_StandaloneDeriving
1859 , Opt_DeriveDataTypeable
1861 , Opt_DeriveFoldable
1862 , Opt_DeriveTraversable
1863 , Opt_FlexibleContexts
1864 , Opt_FlexibleInstances
1865 , Opt_ConstrainedClassMethods
1866 , Opt_MultiParamTypeClasses
1867 , Opt_FunctionalDependencies
1869 , Opt_PolymorphicComponents
1870 , Opt_ExistentialQuantification
1872 , Opt_PostfixOperators
1874 , Opt_LiberalTypeSynonyms
1878 , Opt_ParallelListComp
1879 , Opt_EmptyDataDecls
1880 , Opt_KindSignatures
1881 , Opt_GeneralizedNewtypeDeriving
1882 , Opt_TypeFamilies ]
1884 -- -----------------------------------------------------------------------------
1885 -- Parsing the dynamic flags.
1887 -- | Parse dynamic flags from a list of command line arguments. Returns the
1888 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1889 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1890 -- flags or missing arguments).
1891 parseDynamicFlags :: Monad m =>
1892 DynFlags -> [Located String]
1893 -> m (DynFlags, [Located String], [Located String])
1894 -- ^ Updated 'DynFlags', left-over arguments, and
1895 -- list of warnings.
1896 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1898 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1899 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1900 parseDynamicNoPackageFlags :: Monad m =>
1901 DynFlags -> [Located String]
1902 -> m (DynFlags, [Located String], [Located String])
1903 -- ^ Updated 'DynFlags', left-over arguments, and
1904 -- list of warnings.
1905 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1907 parseDynamicFlags_ :: Monad m =>
1908 DynFlags -> [Located String] -> Bool
1909 -> m (DynFlags, [Located String], [Located String])
1910 parseDynamicFlags_ dflags0 args pkg_flags = do
1911 -- XXX Legacy support code
1912 -- We used to accept things like
1913 -- optdep-f -optdepdepend
1914 -- optdep-f -optdep depend
1915 -- optdep -f -optdepdepend
1916 -- optdep -f -optdep depend
1917 -- but the spaces trip up proper argument handling. So get rid of them.
1918 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1919 f (x : xs) = x : f xs
1923 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1924 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1925 | otherwise = dynamic_flags
1927 let ((leftover, errs, warns), dflags1)
1928 = runCmdLine (processArgs flag_spec args') dflags0
1929 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1931 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1932 -- isn't up to the job. We know that if hscTarget == HscC, then the
1933 -- user has explicitly used -fvia-C, because -fasm is the default,
1934 -- unless there is no NCG on this platform. The latter case is
1935 -- checked when the -fPIC flag is parsed.
1937 let (pic_warns, dflags2)
1938 | opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1939 = ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1940 dflags1{ hscTarget = HscAsm })
1941 #if !(x86_64_TARGET_ARCH && linux_TARGET_OS)
1942 | (not opt_Static || opt_PIC) && hscTarget dflags1 == HscLlvm
1943 = ([L noSrcSpan $ "Warning: -fllvm is incompatible with -fPIC and -dynamic on this"
1944 ++ "platform; ignoring -fllvm"], dflags1{ hscTarget = HscAsm })
1946 | otherwise = ([], dflags1)
1948 return (dflags2, leftover, pic_warns ++ warns)
1950 type DynP = CmdLineP DynFlags
1952 upd :: (DynFlags -> DynFlags) -> DynP ()
1954 dfs <- getCmdLineState
1955 putCmdLineState $! (f dfs)
1957 --------------------------
1958 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1959 setDynFlag f = upd (\dfs -> dopt_set dfs f)
1960 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1962 --------------------------
1963 setLanguage :: Language -> DynP ()
1964 setLanguage l = upd (\dfs -> dfs { language = Just l })
1966 --------------------------
1967 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
1968 setExtensionFlag f = do { upd (\dfs -> lopt_set dfs f)
1969 ; mapM_ setExtensionFlag deps }
1971 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1972 -- When you set f, set the ones it implies
1973 -- NB: use setExtensionFlag recursively, in case the implied flags
1974 -- implies further flags
1975 -- When you un-set f, however, we don't un-set the things it implies
1976 -- (except for -fno-glasgow-exts, which is treated specially)
1978 unSetExtensionFlag f = upd (\dfs -> lopt_unset dfs f)
1980 --------------------------
1981 setDumpFlag :: DynFlag -> OptKind DynP
1982 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1984 setDumpFlag' :: DynFlag -> DynP ()
1985 setDumpFlag' dump_flag
1986 = do { setDynFlag dump_flag
1987 ; when want_recomp forceRecompile }
1989 -- Certain dumpy-things are really interested in what's going
1990 -- on during recompilation checking, so in those cases we
1991 -- don't want to turn it off.
1992 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1993 Opt_D_dump_hi_diffs]
1995 forceRecompile :: DynP ()
1996 -- Whenver we -ddump, force recompilation (by switching off the
1997 -- recompilation checker), else you don't see the dump! However,
1998 -- don't switch it off in --make mode, else *everything* gets
1999 -- recompiled which probably isn't what you want
2000 forceRecompile = do { dfs <- getCmdLineState
2001 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2003 force_recomp dfs = isOneShot (ghcMode dfs)
2005 setVerboseCore2Core :: DynP ()
2006 setVerboseCore2Core = do forceRecompile
2007 setDynFlag Opt_D_verbose_core2core
2008 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2011 setDumpSimplPhases :: String -> DynP ()
2012 setDumpSimplPhases s = do forceRecompile
2013 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2015 spec = case s of { ('=' : s') -> s'; _ -> s }
2017 setVerbosity :: Maybe Int -> DynP ()
2018 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2020 addCmdlineHCInclude :: String -> DynP ()
2021 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2023 extraPkgConf_ :: FilePath -> DynP ()
2024 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2026 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2028 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2030 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2032 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2034 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2036 setPackageName :: String -> DynFlags -> DynFlags
2037 setPackageName p s = s{ thisPackage = stringToPackageId p }
2039 -- If we're linking a binary, then only targets that produce object
2040 -- code are allowed (requests for other target types are ignored).
2041 setTarget :: HscTarget -> DynP ()
2042 setTarget l = upd set
2045 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2048 -- Changes the target only if we're compiling object code. This is
2049 -- used by -fasm and -fvia-C, which switch from one to the other, but
2050 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
2051 -- can be safely used in an OPTIONS_GHC pragma.
2052 setObjTarget :: HscTarget -> DynP ()
2053 setObjTarget l = upd set
2056 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2059 setOptLevel :: Int -> DynFlags -> DynFlags
2060 setOptLevel n dflags
2061 | hscTarget dflags == HscInterpreted && n > 0
2063 -- not in IO any more, oh well:
2064 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2066 = updOptLevel n dflags
2069 -- -Odph is equivalent to
2071 -- -O2 optimise as much as possible
2072 -- -fno-method-sharing sharing specialisation defeats fusion
2074 -- -fdicts-cheap always inline dictionaries
2075 -- -fmax-simplifier-iterations20 this is necessary sometimes
2076 -- -fsimplifier-phases=3 we use an additional simplifier phase
2078 -- -fno-spec-constr-threshold run SpecConstr even for big loops
2079 -- -fno-spec-constr-count SpecConstr as much as possible
2080 -- -finline-enough-args hack to prevent excessive inlining
2082 setDPHOpt :: DynFlags -> DynFlags
2083 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2085 , specConstrThreshold = Nothing
2086 , specConstrCount = Nothing
2088 `dopt_set` Opt_DictsCheap
2089 `dopt_unset` Opt_MethodSharing
2091 data DPHBackend = DPHPar
2094 deriving(Eq, Ord, Enum, Show)
2096 setDPHBackend :: DPHBackend -> DynP ()
2097 setDPHBackend backend
2099 upd $ \dflags -> dflags { dphBackend = backend }
2100 mapM_ exposePackage (dph_packages backend)
2102 dph_packages DPHThis = []
2103 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
2104 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
2106 dphPackage :: DynFlags -> PackageId
2107 dphPackage dflags = case dphBackend dflags of
2108 DPHPar -> dphParPackageId
2109 DPHSeq -> dphSeqPackageId
2110 DPHThis -> thisPackage dflags
2112 setMainIs :: String -> DynP ()
2114 | not (null main_fn) && isLower (head main_fn)
2115 -- The arg looked like "Foo.Bar.baz"
2116 = upd $ \d -> d{ mainFunIs = Just main_fn,
2117 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2119 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2120 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2122 | otherwise -- The arg looked like "baz"
2123 = upd $ \d -> d{ mainFunIs = Just arg }
2125 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2127 -----------------------------------------------------------------------------
2128 -- Paths & Libraries
2130 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2132 -- -i on its own deletes the import paths
2133 addImportPath "" = upd (\s -> s{importPaths = []})
2134 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2138 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2141 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2143 addFrameworkPath p =
2144 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2146 #ifndef mingw32_TARGET_OS
2147 split_marker :: Char
2148 split_marker = ':' -- not configurable (ToDo)
2151 splitPathList :: String -> [String]
2152 splitPathList s = filter notNull (splitUp s)
2153 -- empty paths are ignored: there might be a trailing
2154 -- ':' in the initial list, for example. Empty paths can
2155 -- cause confusion when they are translated into -I options
2156 -- for passing to gcc.
2158 #ifndef mingw32_TARGET_OS
2159 splitUp xs = split split_marker xs
2161 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2163 -- That is, if "foo:bar:baz" is used, this interpreted as
2164 -- consisting of three entries, 'foo', 'bar', 'baz'.
2165 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2166 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2168 -- Notice that no attempt is made to fully replace the 'standard'
2169 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2170 -- that this will cause too much breakage for users & ':' will
2171 -- work fine even with DOS paths, if you're not insisting on being silly.
2174 splitUp (x:':':div:xs) | div `elem` dir_markers
2175 = ((x:':':div:p): splitUp rs)
2177 (p,rs) = findNextPath xs
2178 -- we used to check for existence of the path here, but that
2179 -- required the IO monad to be threaded through the command-line
2180 -- parser which is quite inconvenient. The
2181 splitUp xs = cons p (splitUp rs)
2183 (p,rs) = findNextPath xs
2188 -- will be called either when we've consumed nought or the
2189 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2190 -- finding the next split marker.
2192 case break (`elem` split_markers) xs of
2193 (p, _:ds) -> (p, ds)
2196 split_markers :: [Char]
2197 split_markers = [':', ';']
2199 dir_markers :: [Char]
2200 dir_markers = ['/', '\\']
2203 -- -----------------------------------------------------------------------------
2204 -- tmpDir, where we store temporary files.
2206 setTmpDir :: FilePath -> DynFlags -> DynFlags
2207 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2208 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2209 -- seem necessary now --SDM 7/2/2008
2211 -----------------------------------------------------------------------------
2214 setRtsOpts :: String -> DynP ()
2215 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2217 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2218 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2220 -----------------------------------------------------------------------------
2223 setOptHpcDir :: String -> DynP ()
2224 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2226 -----------------------------------------------------------------------------
2227 -- Via-C compilation stuff
2229 -- There are some options that we need to pass to gcc when compiling
2230 -- Haskell code via C, but are only supported by recent versions of
2231 -- gcc. The configure script decides which of these options we need,
2232 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2233 -- read before each via-C compilation. The advantage of having these
2234 -- in a separate file is that the file can be created at install-time
2235 -- depending on the available gcc version, and even re-generated later
2236 -- if gcc is upgraded.
2238 -- The options below are not dependent on the version of gcc, only the
2241 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2242 [String]) -- for registerised HC compilations
2243 machdepCCOpts _dflags
2244 #if alpha_TARGET_ARCH
2246 #ifdef HAVE_THREADED_RTS_SUPPORT
2250 -- For now, to suppress the gcc warning "call-clobbered
2251 -- register used for global register variable", we simply
2252 -- disable all warnings altogether using the -w flag. Oh well.
2254 #elif hppa_TARGET_ARCH
2255 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2256 -- (very nice, but too bad the HP /usr/include files don't agree.)
2257 = ( ["-D_HPUX_SOURCE"], [] )
2259 #elif m68k_TARGET_ARCH
2260 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2261 -- popping of args to routines to be explicit; if we let things
2262 -- be deferred 'til after an STGJUMP, imminent death is certain!
2264 -- -fomit-frame-pointer : *don't*
2265 -- It's better to have a6 completely tied up being a frame pointer
2266 -- rather than let GCC pick random things to do with it.
2267 -- (If we want to steal a6, then we would try to do things
2268 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2269 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2271 #elif i386_TARGET_ARCH
2272 -- -fno-defer-pop : basically the same game as for m68k
2274 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2275 -- the fp (%ebp) for our register maps.
2276 = let n_regs = stolen_x86_regs _dflags
2279 #if darwin_TARGET_OS
2280 -- By default, gcc on OS X will generate SSE
2281 -- instructions, which need things 16-byte aligned,
2282 -- but we don't 16-byte align things. Thus drop
2283 -- back to generic i686 compatibility. Trac #2983.
2285 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2286 ["-march=i686", "-m32"],
2288 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2292 "-fomit-frame-pointer",
2293 -- we want -fno-builtin, because when gcc inlines
2294 -- built-in functions like memcpy() it tends to
2295 -- run out of registers, requiring -monly-n-regs
2297 "-DSTOLEN_X86_REGS="++show n_regs ]
2300 #elif ia64_TARGET_ARCH
2301 = ( [], ["-fomit-frame-pointer", "-G0"] )
2303 #elif x86_64_TARGET_ARCH
2305 #if darwin_TARGET_OS
2310 ["-fomit-frame-pointer",
2311 "-fno-asynchronous-unwind-tables",
2312 -- the unwind tables are unnecessary for HC code,
2313 -- and get in the way of -split-objs. Another option
2314 -- would be to throw them away in the mangler, but this
2317 -- calling builtins like strlen() using the FFI can
2318 -- cause gcc to run out of regs, so use the external
2322 #elif sparc_TARGET_ARCH
2324 -- For now, to suppress the gcc warning "call-clobbered
2325 -- register used for global register variable", we simply
2326 -- disable all warnings altogether using the -w flag. Oh well.
2328 #elif powerpc_apple_darwin_TARGET
2330 -- Disable Apple's precompiling preprocessor. It's a great thing
2331 -- for "normal" programs, but it doesn't support register variable
2333 = ( [], ["-no-cpp-precomp"] )
2338 picCCOpts :: DynFlags -> [String]
2340 #if darwin_TARGET_OS
2341 -- Apple prefers to do things the other way round.
2342 -- PIC is on by default.
2343 -- -mdynamic-no-pic:
2344 -- Turn off PIC code generation.
2346 -- Don't generate "common" symbols - these are unwanted
2347 -- in dynamic libraries.
2350 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2352 = ["-mdynamic-no-pic"]
2353 #elif mingw32_TARGET_OS
2354 -- no -fPIC for Windows
2356 = ["-U __PIC__","-D__PIC__"]
2360 -- we need -fPIC for C files when we are compiling with -dynamic,
2361 -- otherwise things like stub.c files don't get compiled
2362 -- correctly. They need to reference data in the Haskell
2363 -- objects, but can't without -fPIC. See
2364 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2365 | opt_PIC || not opt_Static
2366 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2371 -- -----------------------------------------------------------------------------
2375 can_split = cSplitObjs == "YES"
2377 -- -----------------------------------------------------------------------------
2380 data Printable = String String
2381 | FromDynFlags (DynFlags -> String)
2383 compilerInfo :: [(String, Printable)]
2384 compilerInfo = [("Project name", String cProjectName),
2385 ("Project version", String cProjectVersion),
2386 ("Booter version", String cBooterVersion),
2387 ("Stage", String cStage),
2388 ("Build platform", String cBuildPlatform),
2389 ("Host platform", String cHostPlatform),
2390 ("Target platform", String cTargetPlatform),
2391 ("Have interpreter", String cGhcWithInterpreter),
2392 ("Object splitting", String cSplitObjs),
2393 ("Have native code generator", String cGhcWithNativeCodeGen),
2394 ("Have llvm code generator", String cGhcWithLlvmCodeGen),
2395 ("Support SMP", String cGhcWithSMP),
2396 ("Unregisterised", String cGhcUnregisterised),
2397 ("Tables next to code", String cGhcEnableTablesNextToCode),
2398 ("RTS ways", String cGhcRTSWays),
2399 ("Leading underscore", String cLeadingUnderscore),
2400 ("Debug on", String (show debugIsOn)),
2401 ("LibDir", FromDynFlags topDir),
2402 ("Global Package DB", FromDynFlags systemPackageConfig)