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 )
86 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
89 import Control.Monad ( when )
93 import System.FilePath
94 import System.IO ( stderr, hPutChar )
96 -- -----------------------------------------------------------------------------
99 -- | Enumerates the simple on-or-off dynamic flags
105 | Opt_D_dump_cmmz_pretty
109 | Opt_D_dump_asm_native
110 | Opt_D_dump_asm_liveness
111 | Opt_D_dump_asm_coalesce
112 | Opt_D_dump_asm_regalloc
113 | Opt_D_dump_asm_regalloc_stages
114 | Opt_D_dump_asm_conflicts
115 | Opt_D_dump_asm_stats
116 | Opt_D_dump_asm_expanded
122 | Opt_D_dump_inlinings
123 | Opt_D_dump_rule_firings
124 | Opt_D_dump_occur_anal
128 | Opt_D_dump_simpl_iterations
129 | Opt_D_dump_simpl_phases
138 | Opt_D_dump_worker_wrapper
139 | Opt_D_dump_rn_trace
140 | Opt_D_dump_rn_stats
142 | Opt_D_dump_simpl_stats
143 | Opt_D_dump_tc_trace
144 | Opt_D_dump_if_trace
151 | Opt_D_verbose_core2core
152 | Opt_D_verbose_stg2stg
154 | Opt_D_dump_hi_diffs
155 | Opt_D_dump_minimal_imports
156 | Opt_D_dump_mod_cycles
157 | Opt_D_dump_view_pattern_commoning
158 | Opt_D_faststring_stats
159 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
160 | Opt_D_no_debug_output
166 | Opt_WarnIsError -- -Werror; makes warnings fatal
167 | Opt_WarnDuplicateExports
169 | Opt_WarnImplicitPrelude
170 | Opt_WarnIncompletePatterns
171 | Opt_WarnIncompletePatternsRecUpd
172 | Opt_WarnMissingFields
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
197 | Opt_OverlappingInstances
198 | Opt_UndecidableInstances
199 | Opt_IncoherentInstances
200 | Opt_MonomorphismRestriction
203 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
204 | Opt_ForeignFunctionInterface
205 | Opt_UnliftedFFITypes
206 | Opt_GHCForeignImportPrim
207 | Opt_PArr -- Syntactic support for parallel arrays
208 | Opt_Arrows -- Arrow-notation syntax
209 | Opt_TemplateHaskell
212 | Opt_Generics -- "Derivable type classes"
213 | Opt_ImplicitPrelude
214 | Opt_ScopedTypeVariables
218 | Opt_OverloadedStrings
219 | Opt_DisambiguateRecordFields
220 | Opt_RecordWildCards
227 | Opt_StandaloneDeriving
228 | Opt_DeriveDataTypeable
230 | Opt_DeriveTraversable
233 | Opt_TypeSynonymInstances
234 | Opt_FlexibleContexts
235 | Opt_FlexibleInstances
236 | Opt_ConstrainedClassMethods
237 | Opt_MultiParamTypeClasses
238 | Opt_FunctionalDependencies
240 | Opt_PolymorphicComponents
241 | Opt_ExistentialQuantification
245 | Opt_ParallelListComp
246 | Opt_TransformListComp
247 | Opt_GeneralizedNewtypeDeriving
250 | Opt_PostfixOperators
253 | Opt_LiberalTypeSynonyms
256 | Opt_ImpredicativeTypes
259 | Opt_NewQualifiedOperators
262 | Opt_PrintExplicitForalls
269 | Opt_StaticArgumentTransformation
273 | Opt_IgnoreInterfacePragmas
274 | Opt_OmitInterfacePragmas
275 | Opt_DoLambdaEtaExpansion
279 | Opt_UnboxStrictFields
282 | Opt_InlineIfEnoughArgs
283 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
285 | Opt_RegsGraph -- do graph coloring register allocation
286 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
289 | Opt_AutoSccsOnAllToplevs
290 | Opt_AutoSccsOnExportedToplevs
291 | Opt_AutoSccsOnIndividualCafs
299 | Opt_ExcessPrecision
300 | Opt_EagerBlackHoling
301 | Opt_ReadUserPackageConf
305 | Opt_HideAllPackages
306 | Opt_PrintBindResult
310 | Opt_BreakOnException
312 | Opt_PrintEvldWithShow
313 | Opt_PrintBindContents
316 | Opt_EmitExternalCore
318 | Opt_BuildingCabalPackage
323 | Opt_ConvertToZipCfgAndBack
324 | Opt_AutoLinkPackages
325 | Opt_ImplicitImportQualified
334 | Opt_KeepRawTokenStream
338 -- | Contains not only a collection of 'DynFlag's but also a plethora of
339 -- information relating to the compilation of a single file or GHC session
340 data DynFlags = DynFlags {
343 coreToDo :: Maybe [CoreToDo], -- reserved for -Ofile
344 stgToDo :: Maybe [StgToDo], -- similarly
345 hscTarget :: HscTarget,
346 hscOutName :: String, -- ^ Name of the output file
347 extCoreName :: String, -- ^ Name of the .hcr output file
348 verbosity :: Int, -- ^ Verbosity level: see "DynFlags#verbosity_levels"
349 optLevel :: Int, -- ^ Optimisation level
350 simplPhases :: Int, -- ^ Number of simplifier phases
351 maxSimplIterations :: Int, -- ^ Max simplifier iterations
352 shouldDumpSimplPhase :: SimplifierMode -> Bool,
353 ruleCheck :: Maybe String,
355 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
356 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
357 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
359 #ifndef OMIT_NATIVE_CODEGEN
360 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
362 stolen_x86_regs :: Int,
363 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
364 importPaths :: [FilePath],
366 mainFunIs :: Maybe String,
367 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
369 dphBackend :: DPHBackend,
371 thisPackage :: PackageId, -- ^ name of package currently being compiled
374 ways :: [Way], -- ^ Way flags from the command line
375 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
376 rtsBuildTag :: String, -- ^ The RTS \"way\"
378 -- For object splitting
379 splitInfo :: Maybe (String,Int),
382 objectDir :: Maybe String,
383 hiDir :: Maybe String,
384 stubDir :: Maybe String,
390 outputFile :: Maybe String,
391 outputHi :: Maybe String,
392 dynLibLoader :: DynLibLoader,
394 -- | This is set by 'DriverPipeline.runPipeline' based on where
395 -- its output is going.
396 dumpPrefix :: Maybe FilePath,
398 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
399 -- Set by @-ddump-file-prefix@
400 dumpPrefixForce :: Maybe FilePath,
402 includePaths :: [String],
403 libraryPaths :: [String],
404 frameworkPaths :: [String], -- used on darwin only
405 cmdlineFrameworks :: [String], -- ditto
406 tmpDir :: String, -- no trailing '/'
408 ghcUsagePath :: FilePath, -- Filled in by SysTools
409 ghciUsagePath :: FilePath, -- ditto
411 hpcDir :: String, -- ^ Path to store the .mix files
413 -- options for particular phases
421 opt_windres :: [String],
423 -- commands for particular phases
425 pgm_P :: (String,[Option]),
427 pgm_c :: (String,[Option]),
428 pgm_m :: (String,[Option]),
429 pgm_s :: (String,[Option]),
430 pgm_a :: (String,[Option]),
431 pgm_l :: (String,[Option]),
432 pgm_dll :: (String,[Option]),
434 pgm_sysman :: String,
435 pgm_windres :: String,
438 depMakefile :: FilePath,
439 depIncludePkgDeps :: Bool,
440 depExcludeMods :: [ModuleName],
441 depSuffixes :: [String],
444 extraPkgConfs :: [FilePath],
445 topDir :: FilePath, -- filled in by SysTools
446 systemPackageConfig :: FilePath, -- ditto
447 -- ^ The @-package-conf@ flags given on the command line, in the order
450 packageFlags :: [PackageFlag],
451 -- ^ The @-package@ and @-hide-package@ flags from the command-line
454 -- NB. do not modify this field, it is calculated by
455 -- Packages.initPackages and Packages.updatePackages.
456 pkgDatabase :: Maybe [PackageConfig],
457 pkgState :: PackageState,
460 -- These have to be IORefs, because the defaultCleanupHandler needs to
461 -- know what to clean when an exception happens
462 filesToClean :: IORef [FilePath],
463 dirsToClean :: IORef (FiniteMap FilePath FilePath),
468 -- | Message output action: use "ErrUtils" instead of this if you can
469 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
471 haddockOptions :: Maybe String
474 wayNames :: DynFlags -> [WayName]
475 wayNames = map wayName . ways
477 -- | The target code type of the compilation (if any).
479 -- Whenever you change the target, also make sure to set 'ghcLink' to
480 -- something sensible.
482 -- 'HscNothing' can be used to avoid generating any output, however, note
485 -- * This will not run the desugaring step, thus no warnings generated in
486 -- this step will be output. In particular, this includes warnings related
487 -- to pattern matching. You can run the desugarer manually using
488 -- 'GHC.desugarModule'.
490 -- * If a program uses Template Haskell the typechecker may try to run code
491 -- from an imported module. This will fail if no code has been generated
492 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
493 -- whether this might be the case and choose to either switch to a
494 -- different target or avoid typechecking such modules. (The latter may
495 -- preferable for security reasons.)
498 = HscC -- ^ Generate C code.
499 | HscAsm -- ^ Generate assembly using the native code generator.
500 | HscJava -- ^ Generate Java bytecode.
501 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
502 | HscNothing -- ^ Don't generate any code. See notes above.
505 -- | Will this target result in an object file on the disk?
506 isObjectTarget :: HscTarget -> Bool
507 isObjectTarget HscC = True
508 isObjectTarget HscAsm = True
509 isObjectTarget _ = False
511 -- | The 'GhcMode' tells us whether we're doing multi-module
512 -- compilation (controlled via the "GHC" API) or one-shot
513 -- (single-module) compilation. This makes a difference primarily to
514 -- the "Finder": in one-shot mode we look for interface files for
515 -- imported modules, but in multi-module mode we look for source files
516 -- in order to check whether they need to be recompiled.
518 = CompManager -- ^ @\-\-make@, GHCi, etc.
519 | OneShot -- ^ @ghc -c Foo.hs@
520 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
523 instance Outputable GhcMode where
524 ppr CompManager = ptext (sLit "CompManager")
525 ppr OneShot = ptext (sLit "OneShot")
526 ppr MkDepend = ptext (sLit "MkDepend")
528 isOneShot :: GhcMode -> Bool
529 isOneShot OneShot = True
530 isOneShot _other = False
532 -- | What to do in the link step, if there is one.
534 = NoLink -- ^ Don't link at all
535 | LinkBinary -- ^ Link object code into a binary
536 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
537 -- bytecode and object code).
538 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
541 isNoLink :: GhcLink -> Bool
542 isNoLink NoLink = True
545 -- Is it worth evaluating this Bool and caching it in the DynFlags value
546 -- during initDynFlags?
547 doingTickyProfiling :: DynFlags -> Bool
548 doingTickyProfiling dflags = WayTicky `elem` wayNames dflags
551 = ExposePackage String
552 | ExposePackageId String
554 | IgnorePackage String
557 defaultHscTarget :: HscTarget
558 defaultHscTarget = defaultObjectTarget
560 -- | The 'HscTarget' value corresponding to the default way to create
561 -- object files on the current platform.
562 defaultObjectTarget :: HscTarget
564 | cGhcWithNativeCodeGen == "YES" = HscAsm
569 | Wrapped (Maybe String)
573 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
574 initDynFlags :: DynFlags -> IO DynFlags
575 initDynFlags dflags = do
576 -- someday these will be dynamic flags
577 ways <- readIORef v_Ways
578 refFilesToClean <- newIORef []
579 refDirsToClean <- newIORef emptyFM
582 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
583 rtsBuildTag = mkBuildTag ways,
584 filesToClean = refFilesToClean,
585 dirsToClean = refDirsToClean
588 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
589 -- and must be fully initialized by 'GHC.newSession' first.
590 defaultDynFlags :: DynFlags
593 ghcMode = CompManager,
594 ghcLink = LinkBinary,
597 hscTarget = defaultHscTarget,
603 maxSimplIterations = 4,
604 shouldDumpSimplPhase = const False,
606 specConstrThreshold = Just 200,
607 specConstrCount = Just 3,
608 liberateCaseThreshold = Just 200,
609 #ifndef OMIT_NATIVE_CODEGEN
610 targetPlatform = defaultTargetPlatform,
613 cmdlineHcIncludes = [],
617 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
621 thisPackage = mainPackageId,
627 objectSuf = phaseInputExt StopLn,
628 hcSuf = phaseInputExt HCc,
631 outputFile = Nothing,
633 dynLibLoader = SystemDependent,
634 dumpPrefix = Nothing,
635 dumpPrefixForce = Nothing,
639 cmdlineFrameworks = [],
640 tmpDir = cDEFAULT_TMPDIR,
646 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
657 pkgDatabase = Nothing,
658 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
659 ways = panic "defaultDynFlags: No ways",
660 buildTag = panic "defaultDynFlags: No buildTag",
661 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
663 -- initSysTools fills all these in
664 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
665 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
666 topDir = panic "defaultDynFlags: No topDir",
667 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
668 pgm_L = panic "defaultDynFlags: No pgm_L",
669 pgm_P = panic "defaultDynFlags: No pgm_P",
670 pgm_F = panic "defaultDynFlags: No pgm_F",
671 pgm_c = panic "defaultDynFlags: No pgm_c",
672 pgm_m = panic "defaultDynFlags: No pgm_m",
673 pgm_s = panic "defaultDynFlags: No pgm_s",
674 pgm_a = panic "defaultDynFlags: No pgm_a",
675 pgm_l = panic "defaultDynFlags: No pgm_l",
676 pgm_dll = panic "defaultDynFlags: No pgm_dll",
677 pgm_T = panic "defaultDynFlags: No pgm_T",
678 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
679 pgm_windres = panic "defaultDynFlags: No pgm_windres",
680 -- end of initSysTools values
682 depMakefile = "Makefile",
683 depIncludePkgDeps = False,
686 -- end of ghc -M values
687 filesToClean = panic "defaultDynFlags: No filesToClean",
688 dirsToClean = panic "defaultDynFlags: No dirsToClean",
689 haddockOptions = Nothing,
691 Opt_AutoLinkPackages,
692 Opt_ReadUserPackageConf,
694 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
695 -- behaviour the default, to see if anyone notices
699 Opt_MonomorphismRestriction,
710 Opt_PrintBindContents
712 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
713 -- The default -O0 options
716 log_action = \severity srcSpan style msg ->
718 SevInfo -> printErrs (msg style)
719 SevFatal -> printErrs (msg style)
722 printErrs ((mkLocMessage srcSpan msg) style)
723 -- careful (#2302): printErrs prints in UTF-8, whereas
724 -- converting to string first and using hPutStr would
725 -- just emit the low 8 bits of each unicode char.
732 0 | print errors & warnings only
733 1 | minimal verbosity: print "compiling M ... done." for each module.
734 2 | equivalent to -dshow-passes
735 3 | equivalent to existing "ghc -v"
736 4 | "ghc -v -ddump-most"
737 5 | "ghc -v -ddump-all"
740 -- | Test whether a 'DynFlag' is set
741 dopt :: DynFlag -> DynFlags -> Bool
742 dopt f dflags = f `elem` (flags dflags)
745 dopt_set :: DynFlags -> DynFlag -> DynFlags
746 dopt_set dfs f = dfs{ flags = f : flags dfs }
748 -- | Unset a 'DynFlag'
749 dopt_unset :: DynFlags -> DynFlag -> DynFlags
750 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
752 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
753 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
754 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
755 -> [a] -- ^ Correctly ordered extracted options
756 getOpts dflags opts = reverse (opts dflags)
757 -- We add to the options from the front, so we need to reverse the list
759 -- | Gets the verbosity flag for the current verbosity level. This is fed to
760 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
761 getVerbFlag :: DynFlags -> String
763 | verbosity dflags >= 3 = "-v"
766 setObjectDir, setHiDir, setStubDir, setOutputDir,
767 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
768 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
769 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
770 addCmdlineFramework, addHaddockOpts
771 :: String -> DynFlags -> DynFlags
772 setOutputFile, setOutputHi, setDumpPrefixForce
773 :: Maybe String -> DynFlags -> DynFlags
775 setObjectDir f d = d{ objectDir = Just f}
776 setHiDir f d = d{ hiDir = Just f}
777 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
778 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
779 -- \#included from the .hc file when compiling with -fvia-C.
780 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
782 setObjectSuf f d = d{ objectSuf = f}
783 setHiSuf f d = d{ hiSuf = f}
784 setHcSuf f d = d{ hcSuf = f}
786 setOutputFile f d = d{ outputFile = f}
787 setOutputHi f d = d{ outputHi = f}
789 parseDynLibLoaderMode f d =
791 ("deploy", "") -> d{ dynLibLoader = Deployable }
792 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
793 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
794 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
795 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
796 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
798 setDumpPrefixForce f d = d { dumpPrefixForce = f}
800 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
801 -- Config.hs should really use Option.
802 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
804 setPgmL f d = d{ pgm_L = f}
805 setPgmF f d = d{ pgm_F = f}
806 setPgmc f d = d{ pgm_c = (f,[])}
807 setPgmm f d = d{ pgm_m = (f,[])}
808 setPgms f d = d{ pgm_s = (f,[])}
809 setPgma f d = d{ pgm_a = (f,[])}
810 setPgml f d = d{ pgm_l = (f,[])}
811 setPgmdll f d = d{ pgm_dll = (f,[])}
812 setPgmwindres f d = d{ pgm_windres = f}
814 addOptL f d = d{ opt_L = f : opt_L d}
815 addOptP f d = d{ opt_P = f : opt_P d}
816 addOptF f d = d{ opt_F = f : opt_F d}
817 addOptc f d = d{ opt_c = f : opt_c d}
818 addOptm f d = d{ opt_m = f : opt_m d}
819 addOpta f d = d{ opt_a = f : opt_a d}
820 addOptl f d = d{ opt_l = f : opt_l d}
821 addOptwindres f d = d{ opt_windres = f : opt_windres d}
823 setDepMakefile :: FilePath -> DynFlags -> DynFlags
824 setDepMakefile f d = d { depMakefile = deOptDep f }
826 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
827 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
829 addDepExcludeMod :: String -> DynFlags -> DynFlags
831 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
833 addDepSuffix :: FilePath -> DynFlags -> DynFlags
834 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
837 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
838 -- we need to strip the "-optdep" off of the arg
839 deOptDep :: String -> String
840 deOptDep x = case stripPrefix "-optdep" x of
844 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
846 addHaddockOpts f d = d{ haddockOptions = Just f}
848 -- -----------------------------------------------------------------------------
849 -- Command-line options
851 -- | When invoking external tools as part of the compilation pipeline, we
852 -- pass these a sequence of options on the command-line. Rather than
853 -- just using a list of Strings, we use a type that allows us to distinguish
854 -- between filepaths and 'other stuff'. The reason for this is that
855 -- this type gives us a handle on transforming filenames, and filenames only,
856 -- to whatever format they're expected to be on a particular platform.
858 = FileOption -- an entry that _contains_ filename(s) / filepaths.
859 String -- a non-filepath prefix that shouldn't be
860 -- transformed (e.g., "/out=")
861 String -- the filepath/filename portion
864 showOpt :: Option -> String
865 showOpt (FileOption pre f) = pre ++ f
866 showOpt (Option s) = s
868 -----------------------------------------------------------------------------
869 -- Setting the optimisation level
871 updOptLevel :: Int -> DynFlags -> DynFlags
872 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
874 = dfs2{ optLevel = final_n }
876 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
877 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
878 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
880 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
881 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
883 optLevelFlags :: [([Int], DynFlag)]
885 = [ ([0], Opt_IgnoreInterfacePragmas)
886 , ([0], Opt_OmitInterfacePragmas)
888 , ([1,2], Opt_IgnoreAsserts)
889 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
891 , ([1,2], Opt_DoEtaReduction)
892 , ([1,2], Opt_CaseMerge)
893 , ([1,2], Opt_Strictness)
895 , ([1,2], Opt_FullLaziness)
896 , ([1,2], Opt_Specialise)
897 , ([1,2], Opt_FloatIn)
899 , ([2], Opt_LiberateCase)
900 , ([2], Opt_SpecConstr)
902 -- , ([2], Opt_StaticArgumentTransformation)
903 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
904 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
905 -- several improvements to the heuristics, and I'm concerned that without
906 -- those changes SAT will interfere with some attempts to write "high
907 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
908 -- this year. In particular, the version in HEAD lacks the tail call
909 -- criterion, so many things that look like reasonable loops will be
910 -- turned into functions with extra (unneccesary) thunk creation.
912 , ([0,1,2], Opt_DoLambdaEtaExpansion)
913 -- This one is important for a tiresome reason:
914 -- we want to make sure that the bindings for data
915 -- constructors are eta-expanded. This is probably
916 -- a good thing anyway, but it seems fragile.
919 -- -----------------------------------------------------------------------------
920 -- Standard sets of warning options
922 standardWarnings :: [DynFlag]
924 = [ Opt_WarnWarningsDeprecations,
925 Opt_WarnDeprecatedFlags,
926 Opt_WarnUnrecognisedPragmas,
927 Opt_WarnOverlappingPatterns,
928 Opt_WarnMissingFields,
929 Opt_WarnMissingMethods,
930 Opt_WarnDuplicateExports,
931 Opt_WarnLazyUnliftedBindings,
932 Opt_WarnDodgyForeignImports,
936 minusWOpts :: [DynFlag]
938 = standardWarnings ++
939 [ Opt_WarnUnusedBinds,
940 Opt_WarnUnusedMatches,
941 Opt_WarnUnusedImports,
942 Opt_WarnIncompletePatterns,
943 Opt_WarnDodgyExports,
947 minusWallOpts :: [DynFlag]
950 [ Opt_WarnTypeDefaults,
951 Opt_WarnNameShadowing,
958 -- minuswRemovesOpts should be every warning option
959 minuswRemovesOpts :: [DynFlag]
962 [Opt_WarnImplicitPrelude,
963 Opt_WarnIncompletePatternsRecUpd,
964 Opt_WarnSimplePatterns,
965 Opt_WarnMonomorphism,
966 Opt_WarnUnrecognisedPragmas,
970 -- -----------------------------------------------------------------------------
971 -- CoreToDo: abstraction of core-to-core passes to run.
973 data CoreToDo -- These are diff core-to-core passes,
974 -- which may be invoked in any order,
975 -- as many times as you like.
977 = CoreDoSimplify -- The core-to-core simplifier.
980 -- Each run of the simplifier can take a different
981 -- set of simplifier-specific flags.
983 | CoreDoFloatOutwards FloatOutSwitches
988 | CoreDoWorkerWrapper
991 | CoreDoOldStrictness
994 | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
995 -- matching this string
996 | CoreDoVectorisation PackageId
997 | CoreDoNothing -- Useful when building up
998 | CoreDoPasses [CoreToDo] -- lists of these things
1001 data SimplifierMode -- See comments in SimplMonad
1003 | SimplPhase Int [String]
1005 instance Outputable SimplifierMode where
1006 ppr SimplGently = ptext (sLit "gentle")
1007 ppr (SimplPhase n ss) = int n <+> brackets (text (concat $ intersperse "," ss))
1010 data SimplifierSwitch
1011 = MaxSimplifierIterations Int
1015 data FloatOutSwitches = FloatOutSwitches {
1016 floatOutLambdas :: Bool, -- ^ True <=> float lambdas to top level
1017 floatOutConstants :: Bool -- ^ True <=> float constants to top level,
1018 -- even if they do not escape a lambda
1021 instance Outputable FloatOutSwitches where
1022 ppr = pprFloatOutSwitches
1024 pprFloatOutSwitches :: FloatOutSwitches -> SDoc
1025 pprFloatOutSwitches sw = pp_not (floatOutLambdas sw) <+> text "lambdas" <> comma
1026 <+> pp_not (floatOutConstants sw) <+> text "constants"
1029 pp_not False = text "not"
1031 -- | Switches that specify the minimum amount of floating out
1032 -- gentleFloatOutSwitches :: FloatOutSwitches
1033 -- gentleFloatOutSwitches = FloatOutSwitches False False
1035 -- | Switches that do not specify floating out of lambdas, just of constants
1036 constantsOnlyFloatOutSwitches :: FloatOutSwitches
1037 constantsOnlyFloatOutSwitches = FloatOutSwitches False True
1040 -- The core-to-core pass ordering is derived from the DynFlags:
1041 runWhen :: Bool -> CoreToDo -> CoreToDo
1042 runWhen True do_this = do_this
1043 runWhen False _ = CoreDoNothing
1045 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
1046 runMaybe (Just x) f = f x
1047 runMaybe Nothing _ = CoreDoNothing
1049 getCoreToDo :: DynFlags -> [CoreToDo]
1051 | Just todo <- coreToDo dflags = todo -- set explicitly by user
1052 | otherwise = core_todo
1054 opt_level = optLevel dflags
1055 phases = simplPhases dflags
1056 max_iter = maxSimplIterations dflags
1057 strictness = dopt Opt_Strictness dflags
1058 full_laziness = dopt Opt_FullLaziness dflags
1059 do_specialise = dopt Opt_Specialise dflags
1060 do_float_in = dopt Opt_FloatIn dflags
1061 cse = dopt Opt_CSE dflags
1062 spec_constr = dopt Opt_SpecConstr dflags
1063 liberate_case = dopt Opt_LiberateCase dflags
1064 rule_check = ruleCheck dflags
1065 static_args = dopt Opt_StaticArgumentTransformation dflags
1067 maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
1069 simpl_phase phase names iter
1071 [ CoreDoSimplify (SimplPhase phase names) [
1072 MaxSimplifierIterations iter
1074 maybe_rule_check phase
1078 = runWhen (dopt Opt_Vectorise dflags)
1079 $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
1082 -- By default, we have 2 phases before phase 0.
1084 -- Want to run with inline phase 2 after the specialiser to give
1085 -- maximum chance for fusion to work before we inline build/augment
1086 -- in phase 1. This made a difference in 'ansi' where an
1087 -- overloaded function wasn't inlined till too late.
1089 -- Need phase 1 so that build/augment get
1090 -- inlined. I found that spectral/hartel/genfft lost some useful
1091 -- strictness in the function sumcode' if augment is not inlined
1092 -- before strictness analysis runs
1093 simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
1094 | phase <- [phases, phases-1 .. 1] ]
1097 -- initial simplify: mk specialiser happy: minimum effort please
1098 simpl_gently = CoreDoSimplify SimplGently [
1099 -- Simplify "gently"
1100 -- Don't inline anything till full laziness has bitten
1101 -- In particular, inlining wrappers inhibits floating
1102 -- e.g. ...(case f x of ...)...
1103 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
1104 -- ==> ...(case x of I# x# -> case fw x# of ...)...
1105 -- and now the redex (f x) isn't floatable any more
1106 -- Similarly, don't apply any rules until after full
1107 -- laziness. Notably, list fusion can prevent floating.
1109 NoCaseOfCase, -- Don't do case-of-case transformations.
1110 -- This makes full laziness work better
1111 MaxSimplifierIterations max_iter
1115 if opt_level == 0 then
1117 simpl_phase 0 ["final"] max_iter]
1118 else {- opt_level >= 1 -} [
1120 -- We want to do the static argument transform before full laziness as it
1121 -- may expose extra opportunities to float things outwards. However, to fix
1122 -- up the output of the transformation we need at do at least one simplify
1123 -- after this before anything else
1124 runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1126 -- We run vectorisation here for now, but we might also try to run
1130 -- initial simplify: mk specialiser happy: minimum effort please
1133 -- Specialisation is best done before full laziness
1134 -- so that overloaded functions have all their dictionary lambdas manifest
1135 runWhen do_specialise CoreDoSpecialising,
1137 runWhen full_laziness (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1138 -- Was: gentleFloatOutSwitches
1139 -- I have no idea why, but not floating constants to top level is
1140 -- very bad in some cases.
1141 -- Notably: p_ident in spectral/rewrite
1142 -- Changing from "gentle" to "constantsOnly" improved
1143 -- rewrite's allocation by 19%, and made 0.0% difference
1144 -- to any other nofib benchmark
1146 runWhen do_float_in CoreDoFloatInwards,
1150 -- Phase 0: allow all Ids to be inlined now
1151 -- This gets foldr inlined before strictness analysis
1153 -- At least 3 iterations because otherwise we land up with
1154 -- huge dead expressions because of an infelicity in the
1156 -- let k = BIG in foldr k z xs
1157 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1158 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1160 simpl_phase 0 ["main"] (max max_iter 3),
1163 #ifdef OLD_STRICTNESS
1164 CoreDoOldStrictness,
1166 runWhen strictness (CoreDoPasses [
1168 CoreDoWorkerWrapper,
1170 simpl_phase 0 ["post-worker-wrapper"] max_iter
1173 runWhen full_laziness
1174 (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1175 -- nofib/spectral/hartel/wang doubles in speed if you
1176 -- do full laziness late in the day. It only happens
1177 -- after fusion and other stuff, so the early pass doesn't
1178 -- catch it. For the record, the redex is
1179 -- f_el22 (f_el21 r_midblock)
1182 runWhen cse CoreCSE,
1183 -- We want CSE to follow the final full-laziness pass, because it may
1184 -- succeed in commoning up things floated out by full laziness.
1185 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1187 runWhen do_float_in CoreDoFloatInwards,
1191 -- Case-liberation for -O2. This should be after
1192 -- strictness analysis and the simplification which follows it.
1193 runWhen liberate_case (CoreDoPasses [
1195 simpl_phase 0 ["post-liberate-case"] max_iter
1196 ]), -- Run the simplifier after LiberateCase to vastly
1197 -- reduce the possiblility of shadowing
1198 -- Reason: see Note [Shadowing] in SpecConstr.lhs
1200 runWhen spec_constr CoreDoSpecConstr,
1204 -- Final clean-up simplification:
1205 simpl_phase 0 ["final"] max_iter
1208 -- -----------------------------------------------------------------------------
1209 -- StgToDo: abstraction of stg-to-stg passes to run.
1212 = StgDoMassageForProfiling -- should be (next to) last
1213 -- There's also setStgVarInfo, but its absolute "lastness"
1214 -- is so critical that it is hardwired in (no flag).
1217 getStgToDo :: DynFlags -> [StgToDo]
1219 | Just todo <- stgToDo dflags = todo -- set explicitly by user
1222 stg_stats = dopt Opt_StgStats dflags
1224 todo1 = if stg_stats then [D_stg_stats] else []
1226 todo2 | WayProf `elem` wayNames dflags
1227 = StgDoMassageForProfiling : todo1
1231 -- -----------------------------------------------------------------------------
1234 allFlags :: [String]
1235 allFlags = map ('-':) $
1236 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1237 map ("fno-"++) flags ++
1238 map ("f"++) flags ++
1239 map ("X"++) supportedLanguages ++
1240 map ("XNo"++) supportedLanguages
1241 where ok (PrefixPred _ _) = False
1243 flags = [ name | (name, _, _) <- fFlags ]
1245 dynamic_flags :: [Flag DynP]
1247 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1248 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1249 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1250 , Flag "#include" (HasArg (addCmdlineHCInclude))
1251 (Deprecated "No longer has any effect")
1252 , Flag "v" (OptIntSuffix setVerbosity) Supported
1254 ------- Specific phases --------------------------------------------
1255 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1256 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1257 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1258 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1259 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1260 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1261 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1262 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1263 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1264 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1266 , Flag "optL" (HasArg (upd . addOptL)) Supported
1267 , Flag "optP" (HasArg (upd . addOptP)) Supported
1268 , Flag "optF" (HasArg (upd . addOptF)) Supported
1269 , Flag "optc" (HasArg (upd . addOptc)) Supported
1270 , Flag "optm" (HasArg (upd . addOptm)) Supported
1271 , Flag "opta" (HasArg (upd . addOpta)) Supported
1272 , Flag "optl" (HasArg (upd . addOptl)) Supported
1273 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1276 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1279 -------- ghc -M -----------------------------------------------------
1280 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1281 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1282 (Deprecated "Use -dep-suffix instead")
1283 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1284 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1285 (Deprecated "Use -dep-makefile instead")
1286 , Flag "optdep-w" (NoArg (return ()))
1287 (Deprecated "-optdep-w doesn't do anything")
1288 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1289 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1290 (Deprecated "Use -include-pkg-deps instead")
1291 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1292 (Deprecated "Use -include-pkg-deps instead")
1293 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1294 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1295 (Deprecated "Use -exclude-module instead")
1296 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1297 (Deprecated "Use -exclude-module instead")
1299 -------- Linking ----------------------------------------------------
1300 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1302 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1303 (Deprecated "Use -c instead")
1304 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1306 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1309 ------- Libraries ---------------------------------------------------
1310 , Flag "L" (Prefix addLibraryPath ) Supported
1311 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1313 ------- Frameworks --------------------------------------------------
1314 -- -framework-path should really be -F ...
1315 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1316 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1318 ------- Output Redirection ------------------------------------------
1319 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1320 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1321 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1322 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1323 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1324 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1325 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1326 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1327 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1328 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1329 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1332 ------- Keeping temporary files -------------------------------------
1333 -- These can be singular (think ghc -c) or plural (think ghc --make)
1334 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1335 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1336 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1337 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1338 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1339 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1340 -- This only makes sense as plural
1341 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1343 ------- Miscellaneous ----------------------------------------------
1344 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1345 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1346 , Flag "main-is" (SepArg setMainIs ) Supported
1347 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1348 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1349 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1351 ------- recompilation checker --------------------------------------
1352 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1353 (Deprecated "Use -fno-force-recomp instead")
1354 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1355 (Deprecated "Use -fforce-recomp instead")
1357 ------ HsCpp opts ---------------------------------------------------
1358 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1359 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1361 ------- Include/Import Paths ----------------------------------------
1362 , Flag "I" (Prefix addIncludePath) Supported
1363 , Flag "i" (OptPrefix addImportPath ) Supported
1365 ------ Debugging ----------------------------------------------------
1366 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1368 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1370 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1372 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1374 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1376 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1378 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1380 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1382 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1384 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1386 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1388 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1390 , Flag "ddump-asm-regalloc-stages"
1391 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1393 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1395 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1397 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1399 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1401 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1403 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1405 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1407 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1409 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1411 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1413 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1415 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1417 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1419 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1421 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1423 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1425 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1427 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1429 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1431 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1433 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1435 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1437 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1439 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1441 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1443 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1445 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1447 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1449 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1451 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1453 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1455 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1457 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1459 , Flag "dverbose-core2core" (NoArg setVerboseCore2Core)
1461 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1463 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1465 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1467 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1469 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1471 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1473 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1475 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1477 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1479 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1482 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1484 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1486 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1488 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1490 , Flag "dshow-passes"
1491 (NoArg (do forceRecompile
1492 setVerbosity (Just 2)))
1494 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1497 ------ Machine dependant (-m<blah>) stuff ---------------------------
1499 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1501 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1503 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1506 ------ Warning opts -------------------------------------------------
1507 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1509 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1511 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1513 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1515 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1516 (Deprecated "Use -w instead")
1517 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1520 ------ Optimisation flags ------------------------------------------
1521 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1522 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1523 (Deprecated "Use -O0 instead")
1524 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1525 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1527 -- If the number is missing, use 1
1529 , Flag "fsimplifier-phases"
1530 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1532 , Flag "fmax-simplifier-iterations"
1533 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1536 , Flag "fspec-constr-threshold"
1537 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1539 , Flag "fno-spec-constr-threshold"
1540 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1542 , Flag "fspec-constr-count"
1543 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1545 , Flag "fno-spec-constr-count"
1546 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1548 , Flag "fliberate-case-threshold"
1549 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1551 , Flag "fno-liberate-case-threshold"
1552 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1555 , Flag "frule-check"
1556 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1558 , Flag "fcontext-stack"
1559 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1562 ------ Profiling ----------------------------------------------------
1564 -- XXX Should the -f* flags be deprecated?
1565 -- They don't seem to be documented
1566 , Flag "fauto-sccs-on-all-toplevs"
1567 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1570 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1572 , Flag "no-auto-all"
1573 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1575 , Flag "fauto-sccs-on-exported-toplevs"
1576 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1579 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1582 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1584 , Flag "fauto-sccs-on-individual-cafs"
1585 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1588 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1591 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1594 ------ DPH flags ----------------------------------------------------
1597 (NoArg (setDPHBackend DPHSeq))
1600 (NoArg (setDPHBackend DPHPar))
1603 (NoArg (setDPHBackend DPHThis))
1606 ------ Compiler flags -----------------------------------------------
1608 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1609 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1610 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1612 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1613 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1614 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1616 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1618 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1621 ++ map (mkFlag True "f" setDynFlag ) fFlags
1622 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1623 ++ map (mkFlag True "X" setDynFlag ) xFlags
1624 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1626 package_flags :: [Flag DynP]
1628 ------- Packages ----------------------------------------------------
1629 Flag "package-conf" (HasArg extraPkgConf_) Supported
1630 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1632 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1633 , Flag "package-id" (HasArg exposePackageId) Supported
1634 , Flag "package" (HasArg exposePackage) Supported
1635 , Flag "hide-package" (HasArg hidePackage) Supported
1636 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1638 , Flag "ignore-package" (HasArg ignorePackage)
1640 , Flag "syslib" (HasArg exposePackage)
1641 (Deprecated "Use -package instead")
1644 mkFlag :: Bool -- ^ True <=> it should be turned on
1645 -> String -- ^ The flag prefix
1646 -> (DynFlag -> DynP ())
1647 -> (String, DynFlag, Bool -> Deprecated)
1649 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1650 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1652 deprecatedForLanguage :: String -> Bool -> Deprecated
1653 deprecatedForLanguage lang turn_on
1654 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1656 flag | turn_on = lang
1657 | otherwise = "No"++lang
1659 useInstead :: String -> Bool -> Deprecated
1660 useInstead flag turn_on
1661 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1663 no = if turn_on then "" else "no-"
1665 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1666 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1668 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1669 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1670 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1671 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1672 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1673 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1674 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1675 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1676 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1677 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1678 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1679 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1680 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1681 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1682 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1683 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1684 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1685 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1686 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1687 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1688 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1689 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1690 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1691 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1692 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1693 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1694 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1695 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1696 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1697 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1698 ( "strictness", Opt_Strictness, const Supported ),
1699 ( "specialise", Opt_Specialise, const Supported ),
1700 ( "float-in", Opt_FloatIn, const Supported ),
1701 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1702 ( "full-laziness", Opt_FullLaziness, const Supported ),
1703 ( "liberate-case", Opt_LiberateCase, const Supported ),
1704 ( "spec-constr", Opt_SpecConstr, const Supported ),
1705 ( "cse", Opt_CSE, const Supported ),
1706 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1707 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1708 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1709 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1710 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1711 ( "case-merge", Opt_CaseMerge, const Supported ),
1712 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1713 ( "method-sharing", Opt_MethodSharing, const Supported ),
1714 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1715 ( "inline-if-enough-args", Opt_InlineIfEnoughArgs, const Supported ),
1716 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1717 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1718 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1719 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1720 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1721 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1722 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1723 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1724 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1725 ( "break-on-error", Opt_BreakOnError, const Supported ),
1726 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1727 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1728 ( "run-cps", Opt_RunCPS, const Supported ),
1729 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1730 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1731 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1732 ( "vectorise", Opt_Vectorise, const Supported ),
1733 ( "regs-graph", Opt_RegsGraph, const Supported ),
1734 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1735 ( "th", Opt_TemplateHaskell,
1736 deprecatedForLanguage "TemplateHaskell" ),
1737 ( "fi", Opt_ForeignFunctionInterface,
1738 deprecatedForLanguage "ForeignFunctionInterface" ),
1739 ( "ffi", Opt_ForeignFunctionInterface,
1740 deprecatedForLanguage "ForeignFunctionInterface" ),
1741 ( "arrows", Opt_Arrows,
1742 deprecatedForLanguage "Arrows" ),
1743 ( "generics", Opt_Generics,
1744 deprecatedForLanguage "Generics" ),
1745 ( "implicit-prelude", Opt_ImplicitPrelude,
1746 deprecatedForLanguage "ImplicitPrelude" ),
1747 ( "bang-patterns", Opt_BangPatterns,
1748 deprecatedForLanguage "BangPatterns" ),
1749 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1750 deprecatedForLanguage "MonomorphismRestriction" ),
1751 ( "mono-pat-binds", Opt_MonoPatBinds,
1752 deprecatedForLanguage "MonoPatBinds" ),
1753 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1754 deprecatedForLanguage "ExtendedDefaultRules" ),
1755 ( "implicit-params", Opt_ImplicitParams,
1756 deprecatedForLanguage "ImplicitParams" ),
1757 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1758 deprecatedForLanguage "ScopedTypeVariables" ),
1760 deprecatedForLanguage "PArr" ),
1761 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1762 deprecatedForLanguage "OverlappingInstances" ),
1763 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1764 deprecatedForLanguage "UndecidableInstances" ),
1765 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1766 deprecatedForLanguage "IncoherentInstances" ),
1767 ( "gen-manifest", Opt_GenManifest, const Supported ),
1768 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1769 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1770 ( "shared-implib", Opt_SharedImplib, const Supported ),
1771 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1772 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1775 supportedLanguages :: [String]
1776 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1778 -- This may contain duplicates
1779 languageOptions :: [DynFlag]
1780 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1782 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1783 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1785 ( "CPP", Opt_Cpp, const Supported ),
1786 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1787 ( "TupleSections", Opt_TupleSections, const Supported ),
1788 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1789 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1790 ( "MagicHash", Opt_MagicHash, const Supported ),
1791 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1792 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1793 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1794 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1795 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1796 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1797 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1798 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1799 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1800 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1801 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1802 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1803 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, const Supported ),
1804 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1805 ( "RecursiveDo", Opt_RecursiveDo,
1806 deprecatedForLanguage "DoRec"),
1807 ( "DoRec", Opt_DoRec, const Supported ),
1808 ( "Arrows", Opt_Arrows, const Supported ),
1809 ( "PArr", Opt_PArr, const Supported ),
1810 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1811 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1812 ( "Generics", Opt_Generics, const Supported ),
1814 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1815 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1816 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1817 ( "RecordPuns", Opt_RecordPuns,
1818 deprecatedForLanguage "NamedFieldPuns" ),
1819 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1820 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1821 ( "GADTs", Opt_GADTs, const Supported ),
1822 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1823 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1824 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1826 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1828 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1829 -- On by default (which is not strictly H98):
1830 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1831 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1832 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1833 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1834 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1835 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1836 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1838 ( "PatternSignatures", Opt_ScopedTypeVariables,
1839 deprecatedForLanguage "ScopedTypeVariables" ),
1841 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1842 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1843 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1844 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1845 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1846 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1847 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1848 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1849 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1850 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1851 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1852 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1853 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1854 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1855 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1856 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1857 ( "PackageImports", Opt_PackageImports, const Supported ),
1858 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1861 impliedFlags :: [(DynFlag, DynFlag)]
1863 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1864 , (Opt_Rank2Types, Opt_ExplicitForAll)
1865 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1866 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1867 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1868 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1870 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1871 -- be completely rigid for GADTs
1873 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1874 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1875 -- all over the place
1877 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1878 -- Note [Scoped tyvars] in TcBinds
1879 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1881 -- Record wild-cards implies field disambiguation
1882 -- Otherwise if you write (C {..}) you may well get
1883 -- stuff like " 'a' not in scope ", which is a bit silly
1884 -- if the compiler has just filled in field 'a' of constructor 'C'
1885 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1888 glasgowExtsFlags :: [DynFlag]
1889 glasgowExtsFlags = [
1890 Opt_PrintExplicitForalls
1891 , Opt_ForeignFunctionInterface
1892 , Opt_UnliftedFFITypes
1894 , Opt_ImplicitParams
1895 , Opt_ScopedTypeVariables
1897 , Opt_TypeSynonymInstances
1898 , Opt_StandaloneDeriving
1899 , Opt_DeriveDataTypeable
1901 , Opt_DeriveFoldable
1902 , Opt_DeriveTraversable
1903 , Opt_FlexibleContexts
1904 , Opt_FlexibleInstances
1905 , Opt_ConstrainedClassMethods
1906 , Opt_MultiParamTypeClasses
1907 , Opt_FunctionalDependencies
1909 , Opt_PolymorphicComponents
1910 , Opt_ExistentialQuantification
1912 , Opt_PostfixOperators
1914 , Opt_LiberalTypeSynonyms
1918 , Opt_ParallelListComp
1919 , Opt_EmptyDataDecls
1920 , Opt_KindSignatures
1921 , Opt_GeneralizedNewtypeDeriving
1922 , Opt_TypeFamilies ]
1924 -- -----------------------------------------------------------------------------
1925 -- Parsing the dynamic flags.
1927 -- | Parse dynamic flags from a list of command line arguments. Returns the
1928 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1929 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1930 -- flags or missing arguments).
1931 parseDynamicFlags :: Monad m =>
1932 DynFlags -> [Located String]
1933 -> m (DynFlags, [Located String], [Located String])
1934 -- ^ Updated 'DynFlags', left-over arguments, and
1935 -- list of warnings.
1936 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1938 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1939 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1940 parseDynamicNoPackageFlags :: Monad m =>
1941 DynFlags -> [Located String]
1942 -> m (DynFlags, [Located String], [Located String])
1943 -- ^ Updated 'DynFlags', left-over arguments, and
1944 -- list of warnings.
1945 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1947 parseDynamicFlags_ :: Monad m =>
1948 DynFlags -> [Located String] -> Bool
1949 -> m (DynFlags, [Located String], [Located String])
1950 parseDynamicFlags_ dflags0 args pkg_flags = do
1951 -- XXX Legacy support code
1952 -- We used to accept things like
1953 -- optdep-f -optdepdepend
1954 -- optdep-f -optdep depend
1955 -- optdep -f -optdepdepend
1956 -- optdep -f -optdep depend
1957 -- but the spaces trip up proper argument handling. So get rid of them.
1958 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1959 f (x : xs) = x : f xs
1963 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1964 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1965 | otherwise = dynamic_flags
1967 let ((leftover, errs, warns), dflags1)
1968 = runCmdLine (processArgs flag_spec args') dflags0
1969 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1971 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1972 -- isn't up to the job. We know that if hscTarget == HscC, then the
1973 -- user has explicitly used -fvia-C, because -fasm is the default,
1974 -- unless there is no NCG on this platform. The latter case is
1975 -- checked when the -fPIC flag is parsed.
1977 let (pic_warns, dflags2) =
1978 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1979 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1980 dflags1{ hscTarget = HscAsm })
1983 return (dflags2, leftover, pic_warns ++ warns)
1985 type DynP = CmdLineP DynFlags
1987 upd :: (DynFlags -> DynFlags) -> DynP ()
1989 dfs <- getCmdLineState
1990 putCmdLineState $! (f dfs)
1992 --------------------------
1993 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1994 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1995 ; mapM_ setDynFlag deps }
1997 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1998 -- When you set f, set the ones it implies
1999 -- NB: use setDynFlag recursively, in case the implied flags
2000 -- implies further flags
2001 -- When you un-set f, however, we don't un-set the things it implies
2002 -- (except for -fno-glasgow-exts, which is treated specially)
2004 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2006 --------------------------
2007 setDumpFlag :: DynFlag -> OptKind DynP
2008 setDumpFlag dump_flag
2009 = NoArg (setDynFlag dump_flag >> when want_recomp forceRecompile)
2011 -- Certain dumpy-things are really interested in what's going
2012 -- on during recompilation checking, so in those cases we
2013 -- don't want to turn it off.
2014 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2015 Opt_D_dump_hi_diffs]
2017 forceRecompile :: DynP ()
2018 -- Whenver we -ddump, force recompilation (by switching off the
2019 -- recompilation checker), else you don't see the dump! However,
2020 -- don't switch it off in --make mode, else *everything* gets
2021 -- recompiled which probably isn't what you want
2022 forceRecompile = do { dfs <- getCmdLineState
2023 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2025 force_recomp dfs = isOneShot (ghcMode dfs)
2027 setVerboseCore2Core :: DynP ()
2028 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
2030 upd (\s -> s { shouldDumpSimplPhase = const True })
2032 setDumpSimplPhases :: String -> DynP ()
2033 setDumpSimplPhases s = do forceRecompile
2034 upd (\s -> s { shouldDumpSimplPhase = spec })
2036 spec :: SimplifierMode -> Bool
2038 . map (join (&&) . map match . split ':')
2044 join :: (Bool -> Bool -> Bool)
2045 -> [SimplifierMode -> Bool]
2046 -> SimplifierMode -> Bool
2047 join _ [] = const True
2048 join op ss = foldr1 (\f g x -> f x `op` g x) ss
2050 match :: String -> SimplifierMode -> Bool
2051 match "" = const True
2052 match s = case reads s of
2053 [(n,"")] -> phase_num n
2056 phase_num :: Int -> SimplifierMode -> Bool
2057 phase_num n (SimplPhase k _) = n == k
2058 phase_num _ _ = False
2060 phase_name :: String -> SimplifierMode -> Bool
2061 phase_name s SimplGently = s == "gentle"
2062 phase_name s (SimplPhase _ ss) = s `elem` ss
2064 setVerbosity :: Maybe Int -> DynP ()
2065 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2067 addCmdlineHCInclude :: String -> DynP ()
2068 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2070 extraPkgConf_ :: FilePath -> DynP ()
2071 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2073 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2075 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2077 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2079 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2081 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2083 setPackageName :: String -> DynFlags -> DynFlags
2084 setPackageName p s = s{ thisPackage = stringToPackageId p }
2086 -- If we're linking a binary, then only targets that produce object
2087 -- code are allowed (requests for other target types are ignored).
2088 setTarget :: HscTarget -> DynP ()
2089 setTarget l = upd set
2092 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2095 -- Changes the target only if we're compiling object code. This is
2096 -- used by -fasm and -fvia-C, which switch from one to the other, but
2097 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
2098 -- can be safely used in an OPTIONS_GHC pragma.
2099 setObjTarget :: HscTarget -> DynP ()
2100 setObjTarget l = upd set
2103 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2106 setOptLevel :: Int -> DynFlags -> DynFlags
2107 setOptLevel n dflags
2108 | hscTarget dflags == HscInterpreted && n > 0
2110 -- not in IO any more, oh well:
2111 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2113 = updOptLevel n dflags
2116 -- -Odph is equivalent to
2118 -- -O2 optimise as much as possible
2119 -- -fno-method-sharing sharing specialisation defeats fusion
2121 -- -fdicts-cheap always inline dictionaries
2122 -- -fmax-simplifier-iterations20 this is necessary sometimes
2123 -- -fsimplifier-phases=3 we use an additional simplifier phase
2125 -- -fno-spec-constr-threshold run SpecConstr even for big loops
2126 -- -fno-spec-constr-count SpecConstr as much as possible
2127 -- -finline-enough-args hack to prevent excessive inlining
2129 setDPHOpt :: DynFlags -> DynFlags
2130 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2132 , specConstrThreshold = Nothing
2133 , specConstrCount = Nothing
2135 `dopt_set` Opt_DictsCheap
2136 `dopt_unset` Opt_MethodSharing
2137 `dopt_set` Opt_InlineIfEnoughArgs
2139 data DPHBackend = DPHPar
2142 deriving(Eq, Ord, Enum, Show)
2144 setDPHBackend :: DPHBackend -> DynP ()
2145 setDPHBackend backend
2147 upd $ \dflags -> dflags { dphBackend = backend }
2148 mapM_ exposePackage (dph_packages backend)
2150 dph_packages DPHThis = []
2151 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
2152 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
2154 dphPackage :: DynFlags -> PackageId
2155 dphPackage dflags = case dphBackend dflags of
2156 DPHPar -> dphParPackageId
2157 DPHSeq -> dphSeqPackageId
2158 DPHThis -> thisPackage dflags
2160 setMainIs :: String -> DynP ()
2162 | not (null main_fn) && isLower (head main_fn)
2163 -- The arg looked like "Foo.Bar.baz"
2164 = upd $ \d -> d{ mainFunIs = Just main_fn,
2165 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2167 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2168 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2170 | otherwise -- The arg looked like "baz"
2171 = upd $ \d -> d{ mainFunIs = Just arg }
2173 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2175 -----------------------------------------------------------------------------
2176 -- Paths & Libraries
2178 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2180 -- -i on its own deletes the import paths
2181 addImportPath "" = upd (\s -> s{importPaths = []})
2182 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2186 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2189 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2191 addFrameworkPath p =
2192 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2194 #ifndef mingw32_TARGET_OS
2195 split_marker :: Char
2196 split_marker = ':' -- not configurable (ToDo)
2199 splitPathList :: String -> [String]
2200 splitPathList s = filter notNull (splitUp s)
2201 -- empty paths are ignored: there might be a trailing
2202 -- ':' in the initial list, for example. Empty paths can
2203 -- cause confusion when they are translated into -I options
2204 -- for passing to gcc.
2206 #ifndef mingw32_TARGET_OS
2207 splitUp xs = split split_marker xs
2209 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2211 -- That is, if "foo:bar:baz" is used, this interpreted as
2212 -- consisting of three entries, 'foo', 'bar', 'baz'.
2213 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2214 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2216 -- Notice that no attempt is made to fully replace the 'standard'
2217 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2218 -- that this will cause too much breakage for users & ':' will
2219 -- work fine even with DOS paths, if you're not insisting on being silly.
2222 splitUp (x:':':div:xs) | div `elem` dir_markers
2223 = ((x:':':div:p): splitUp rs)
2225 (p,rs) = findNextPath xs
2226 -- we used to check for existence of the path here, but that
2227 -- required the IO monad to be threaded through the command-line
2228 -- parser which is quite inconvenient. The
2229 splitUp xs = cons p (splitUp rs)
2231 (p,rs) = findNextPath xs
2236 -- will be called either when we've consumed nought or the
2237 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2238 -- finding the next split marker.
2240 case break (`elem` split_markers) xs of
2241 (p, _:ds) -> (p, ds)
2244 split_markers :: [Char]
2245 split_markers = [':', ';']
2247 dir_markers :: [Char]
2248 dir_markers = ['/', '\\']
2251 -- -----------------------------------------------------------------------------
2252 -- tmpDir, where we store temporary files.
2254 setTmpDir :: FilePath -> DynFlags -> DynFlags
2255 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2256 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2257 -- seem necessary now --SDM 7/2/2008
2259 -----------------------------------------------------------------------------
2262 setOptHpcDir :: String -> DynP ()
2263 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2265 -----------------------------------------------------------------------------
2266 -- Via-C compilation stuff
2268 -- There are some options that we need to pass to gcc when compiling
2269 -- Haskell code via C, but are only supported by recent versions of
2270 -- gcc. The configure script decides which of these options we need,
2271 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2272 -- read before each via-C compilation. The advantage of having these
2273 -- in a separate file is that the file can be created at install-time
2274 -- depending on the available gcc version, and even re-generated later
2275 -- if gcc is upgraded.
2277 -- The options below are not dependent on the version of gcc, only the
2280 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2281 [String]) -- for registerised HC compilations
2282 machdepCCOpts _dflags
2283 #if alpha_TARGET_ARCH
2285 #ifdef HAVE_THREADED_RTS_SUPPORT
2289 -- For now, to suppress the gcc warning "call-clobbered
2290 -- register used for global register variable", we simply
2291 -- disable all warnings altogether using the -w flag. Oh well.
2293 #elif hppa_TARGET_ARCH
2294 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2295 -- (very nice, but too bad the HP /usr/include files don't agree.)
2296 = ( ["-D_HPUX_SOURCE"], [] )
2298 #elif m68k_TARGET_ARCH
2299 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2300 -- popping of args to routines to be explicit; if we let things
2301 -- be deferred 'til after an STGJUMP, imminent death is certain!
2303 -- -fomit-frame-pointer : *don't*
2304 -- It's better to have a6 completely tied up being a frame pointer
2305 -- rather than let GCC pick random things to do with it.
2306 -- (If we want to steal a6, then we would try to do things
2307 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2308 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2310 #elif i386_TARGET_ARCH
2311 -- -fno-defer-pop : basically the same game as for m68k
2313 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2314 -- the fp (%ebp) for our register maps.
2315 = let n_regs = stolen_x86_regs _dflags
2318 #if darwin_TARGET_OS
2319 -- By default, gcc on OS X will generate SSE
2320 -- instructions, which need things 16-byte aligned,
2321 -- but we don't 16-byte align things. Thus drop
2322 -- back to generic i686 compatibility. Trac #2983.
2324 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2325 ["-march=i686", "-m32"],
2327 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2331 "-fomit-frame-pointer",
2332 -- we want -fno-builtin, because when gcc inlines
2333 -- built-in functions like memcpy() it tends to
2334 -- run out of registers, requiring -monly-n-regs
2336 "-DSTOLEN_X86_REGS="++show n_regs ]
2339 #elif ia64_TARGET_ARCH
2340 = ( [], ["-fomit-frame-pointer", "-G0"] )
2342 #elif x86_64_TARGET_ARCH
2344 #if darwin_TARGET_OS
2349 ["-fomit-frame-pointer",
2350 "-fno-asynchronous-unwind-tables",
2351 -- the unwind tables are unnecessary for HC code,
2352 -- and get in the way of -split-objs. Another option
2353 -- would be to throw them away in the mangler, but this
2356 -- calling builtins like strlen() using the FFI can
2357 -- cause gcc to run out of regs, so use the external
2361 #elif sparc_TARGET_ARCH
2363 -- For now, to suppress the gcc warning "call-clobbered
2364 -- register used for global register variable", we simply
2365 -- disable all warnings altogether using the -w flag. Oh well.
2367 #elif powerpc_apple_darwin_TARGET
2369 -- Disable Apple's precompiling preprocessor. It's a great thing
2370 -- for "normal" programs, but it doesn't support register variable
2372 = ( [], ["-no-cpp-precomp"] )
2377 picCCOpts :: DynFlags -> [String]
2379 #if darwin_TARGET_OS
2380 -- Apple prefers to do things the other way round.
2381 -- PIC is on by default.
2382 -- -mdynamic-no-pic:
2383 -- Turn off PIC code generation.
2385 -- Don't generate "common" symbols - these are unwanted
2386 -- in dynamic libraries.
2389 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2391 = ["-mdynamic-no-pic"]
2392 #elif mingw32_TARGET_OS
2393 -- no -fPIC for Windows
2395 = ["-U __PIC__","-D__PIC__"]
2399 | opt_PIC || not opt_Static
2400 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2405 -- -----------------------------------------------------------------------------
2409 can_split = cSplitObjs == "YES"
2411 -- -----------------------------------------------------------------------------
2414 data Printable = String String
2415 | FromDynFlags (DynFlags -> String)
2417 compilerInfo :: [(String, Printable)]
2418 compilerInfo = [("Project name", String cProjectName),
2419 ("Project version", String cProjectVersion),
2420 ("Booter version", String cBooterVersion),
2421 ("Stage", String cStage),
2422 ("Have interpreter", String cGhcWithInterpreter),
2423 ("Object splitting", String cSplitObjs),
2424 ("Have native code generator", String cGhcWithNativeCodeGen),
2425 ("Support SMP", String cGhcWithSMP),
2426 ("Unregisterised", String cGhcUnregisterised),
2427 ("Tables next to code", String cGhcEnableTablesNextToCode),
2428 ("Win32 DLLs", String cEnableWin32DLLs),
2429 ("RTS ways", String cGhcRTSWays),
2430 ("Leading underscore", String cLeadingUnderscore),
2431 ("Debug on", String (show debugIsOn)),
2432 ("LibDir", FromDynFlags topDir)