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
25 HscTarget(..), isObjectTarget, defaultObjectTarget,
26 GhcMode(..), isOneShot,
27 GhcLink(..), isNoLink,
31 fFlags, fLangFlags, xFlags,
32 DPHBackend(..), dphPackageMaybe,
36 ghcUsagePath, ghciUsagePath, topDir, tmpDir, rawSettings,
37 extraGccViaCFlags, systemPackageConfig,
38 pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,
39 pgm_sysman, pgm_windres, pgm_lo, pgm_lc,
40 opt_L, opt_P, opt_F, opt_c, opt_m, opt_a, opt_l,
41 opt_windres, opt_lo, opt_lc,
44 -- ** Manipulating DynFlags
45 defaultDynFlags, -- Settings -> DynFlags
46 initDynFlags, -- DynFlags -> IO DynFlags
48 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
55 -- ** Parsing DynFlags
57 parseDynamicNoPackageFlags,
60 supportedLanguagesAndExtensions,
62 -- ** DynFlag C compiler options
65 -- * Configuration of the stg-to-stg passes
69 -- * Compiler configuration suitable for display to the user
72 -- Only in stage 2 can we be sure that the RTS
73 -- exposes the appropriate runtime boolean
78 #include "HsVersions.h"
83 import PrelNames ( mAIN )
85 import {-# SOURCE #-} Packages (PackageState)
86 import DriverPhases ( Phase(..), phaseInputExt )
89 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
92 import Maybes ( orElse )
97 import Foreign.C ( CInt )
99 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
102 import System.IO.Unsafe ( unsafePerformIO )
105 import Control.Monad ( when )
109 import Data.Map (Map)
110 import qualified Data.Map as Map
111 import Data.Set (Set)
112 import qualified Data.Set as Set
113 import System.FilePath
114 import System.IO ( stderr, hPutChar )
116 -- -----------------------------------------------------------------------------
119 -- | Enumerates the simple on-or-off dynamic flags
126 | Opt_D_dump_cmmz_pretty
127 -- All of the cmmz subflags (there are a lot!) Automatically
128 -- enabled if you run -ddump-cmmz
129 | Opt_D_dump_cmmz_cbe
130 | Opt_D_dump_cmmz_proc
131 | Opt_D_dump_cmmz_spills
132 | Opt_D_dump_cmmz_rewrite
133 | Opt_D_dump_cmmz_dead
134 | Opt_D_dump_cmmz_stub
136 | Opt_D_dump_cmmz_procmap
137 | Opt_D_dump_cmmz_split
138 | Opt_D_dump_cmmz_lower
139 | Opt_D_dump_cmmz_info
140 | Opt_D_dump_cmmz_cafs
145 | Opt_D_dump_asm_native
146 | Opt_D_dump_asm_liveness
147 | Opt_D_dump_asm_coalesce
148 | Opt_D_dump_asm_regalloc
149 | Opt_D_dump_asm_regalloc_stages
150 | Opt_D_dump_asm_conflicts
151 | Opt_D_dump_asm_stats
152 | Opt_D_dump_asm_expanded
154 | Opt_D_dump_core_stats
160 | Opt_D_dump_inlinings
161 | Opt_D_dump_rule_firings
162 | Opt_D_dump_rule_rewrites
163 | Opt_D_dump_occur_anal
167 | Opt_D_dump_simpl_iterations
168 | Opt_D_dump_simpl_phases
177 | Opt_D_dump_worker_wrapper
178 | Opt_D_dump_rn_trace
179 | Opt_D_dump_rn_stats
181 | Opt_D_dump_simpl_stats
182 | Opt_D_dump_cs_trace -- Constraint solver in type checker
183 | Opt_D_dump_tc_trace
184 | Opt_D_dump_if_trace
185 | Opt_D_dump_vt_trace
192 | Opt_D_verbose_core2core
193 | Opt_D_verbose_stg2stg
195 | Opt_D_dump_hi_diffs
196 | Opt_D_dump_minimal_imports
197 | Opt_D_dump_mod_cycles
198 | Opt_D_dump_view_pattern_commoning
199 | Opt_D_faststring_stats
200 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
201 | Opt_D_no_debug_output
207 | Opt_F_coqpass -- run the core-to-core coqPass, but don't change anything (just "parse/unparse")
208 | Opt_F_skolemize -- run the core-to-core coqPass, skolemizing the proof
209 | Opt_F_flatten -- run the core-to-core coqPass, flattening the proof
210 | Opt_F_simpleopt_before_flatten -- run the "simplPgmOpt" before the coqPass
211 | Opt_D_dump_proofs -- dump natural deduction typing proof of the coqpass input
212 | Opt_D_coqpass -- run the core-to-string coqPass and dumps the result
214 | Opt_WarnIsError -- -Werror; makes warnings fatal
215 | Opt_WarnDuplicateExports
217 | Opt_WarnImplicitPrelude
218 | Opt_WarnIncompletePatterns
219 | Opt_WarnIncompleteUniPatterns
220 | Opt_WarnIncompletePatternsRecUpd
221 | Opt_WarnMissingFields
222 | Opt_WarnMissingImportList
223 | Opt_WarnMissingMethods
224 | Opt_WarnMissingSigs
225 | Opt_WarnMissingLocalSigs
226 | Opt_WarnNameShadowing
227 | Opt_WarnOverlappingPatterns
228 | Opt_WarnTypeDefaults
229 | Opt_WarnMonomorphism
230 | Opt_WarnUnusedBinds
231 | Opt_WarnUnusedImports
232 | Opt_WarnUnusedMatches
233 | Opt_WarnWarningsDeprecations
234 | Opt_WarnDeprecatedFlags
235 | Opt_WarnDodgyExports
236 | Opt_WarnDodgyImports
238 | Opt_WarnAutoOrphans
241 | Opt_WarnUnrecognisedPragmas
242 | Opt_WarnDodgyForeignImports
243 | Opt_WarnLazyUnliftedBindings
244 | Opt_WarnUnusedDoBind
245 | Opt_WarnWrongDoBind
246 | Opt_WarnAlternativeLayoutRuleTransitional
248 | Opt_PrintExplicitForalls
255 | Opt_StaticArgumentTransformation
259 | Opt_DoLambdaEtaExpansion
263 | Opt_UnboxStrictFields
264 | Opt_MethodSharing -- Now a no-op; remove in GHC 7.2
266 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
268 | Opt_RegsGraph -- do graph coloring register allocation
269 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
272 | Opt_IgnoreInterfacePragmas
273 | Opt_OmitInterfacePragmas
274 | Opt_ExposeAllUnfoldings
277 | Opt_AutoSccsOnAllToplevs
278 | Opt_AutoSccsOnExportedToplevs
279 | Opt_AutoSccsOnIndividualCafs
284 | Opt_ExcessPrecision
285 | Opt_EagerBlackHoling
286 | Opt_ReadUserPackageConf
290 | Opt_HideAllPackages
291 | Opt_PrintBindResult
295 | Opt_BreakOnException
297 | Opt_PrintEvldWithShow
298 | Opt_PrintBindContents
301 | Opt_EmitExternalCore
303 | Opt_BuildingCabalPackage
311 | Opt_ConvertToZipCfgAndBack
312 | Opt_AutoLinkPackages
313 | Opt_ImplicitImportQualified
321 | Opt_KeepRawTokenStream
326 data Language = Haskell98 | Haskell2010
330 | Opt_OverlappingInstances
331 | Opt_UndecidableInstances
332 | Opt_IncoherentInstances
333 | Opt_MonomorphismRestriction
336 | Opt_RelaxedPolyRec -- Deprecated
337 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
338 | Opt_ForeignFunctionInterface
339 | Opt_UnliftedFFITypes
340 | Opt_GHCForeignImportPrim
341 | Opt_ParallelArrays -- Syntactic support for parallel arrays
342 | Opt_Arrows -- Arrow-notation syntax
343 | Opt_ModalTypes -- Heterogeneous Metaprogramming (modal types, brackets, escape, CSP)
344 | Opt_TemplateHaskell
347 | Opt_ImplicitPrelude
348 | Opt_ScopedTypeVariables
352 | Opt_OverloadedStrings
353 | Opt_DisambiguateRecordFields
354 | Opt_RecordWildCards
360 | Opt_DoAndIfThenElse
361 | Opt_RebindableSyntax
363 | Opt_StandaloneDeriving
364 | Opt_DeriveDataTypeable
366 | Opt_DeriveTraversable
368 | Opt_DeriveGeneric -- Allow deriving Generic/1
369 | Opt_DefaultSignatures -- Allow extra signatures for defmeths
370 | Opt_Generics -- Old generic classes, now deprecated
372 | Opt_TypeSynonymInstances
373 | Opt_FlexibleContexts
374 | Opt_FlexibleInstances
375 | Opt_ConstrainedClassMethods
376 | Opt_MultiParamTypeClasses
377 | Opt_FunctionalDependencies
379 | Opt_PolymorphicComponents
380 | Opt_ExistentialQuantification
384 | Opt_ParallelListComp
385 | Opt_TransformListComp
386 | Opt_MonadComprehensions
387 | Opt_GeneralizedNewtypeDeriving
390 | Opt_PostfixOperators
393 | Opt_LiberalTypeSynonyms
396 | Opt_ImpredicativeTypes
400 | Opt_AlternativeLayoutRule
401 | Opt_AlternativeLayoutRuleTransitional
402 | Opt_DatatypeContexts
403 | Opt_NondecreasingIndentation
407 -- | Contains not only a collection of 'DynFlag's but also a plethora of
408 -- information relating to the compilation of a single file or GHC session
409 data DynFlags = DynFlags {
412 hscTarget :: HscTarget,
413 hscOutName :: String, -- ^ Name of the output file
414 extCoreName :: String, -- ^ Name of the .hcr output file
415 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
416 optLevel :: Int, -- ^ Optimisation level
417 simplPhases :: Int, -- ^ Number of simplifier phases
418 maxSimplIterations :: Int, -- ^ Max simplifier iterations
419 shouldDumpSimplPhase :: Maybe String,
420 ruleCheck :: Maybe String,
421 strictnessBefore :: [Int], -- ^ Additional demand analysis
423 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
424 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
425 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
426 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
427 -- See CoreMonad.FloatOutSwitches
429 targetPlatform :: Platform.Platform, -- ^ The platform we're compiling for. Used by the NCG.
430 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
431 importPaths :: [FilePath],
433 mainFunIs :: Maybe String,
434 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
436 dphBackend :: DPHBackend,
438 thisPackage :: PackageId, -- ^ name of package currently being compiled
441 ways :: [Way], -- ^ Way flags from the command line
442 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
443 rtsBuildTag :: String, -- ^ The RTS \"way\"
445 -- For object splitting
446 splitInfo :: Maybe (String,Int),
449 objectDir :: Maybe String,
450 dylibInstallName :: Maybe String,
451 hiDir :: Maybe String,
452 stubDir :: Maybe String,
458 outputFile :: Maybe String,
459 outputHi :: Maybe String,
460 dynLibLoader :: DynLibLoader,
462 -- | This is set by 'DriverPipeline.runPipeline' based on where
463 -- its output is going.
464 dumpPrefix :: Maybe FilePath,
466 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
467 -- Set by @-ddump-file-prefix@
468 dumpPrefixForce :: Maybe FilePath,
470 includePaths :: [String],
471 libraryPaths :: [String],
472 frameworkPaths :: [String], -- used on darwin only
473 cmdlineFrameworks :: [String], -- ditto
475 rtsOpts :: Maybe String,
476 rtsOptsEnabled :: RtsOptsEnabled,
478 hpcDir :: String, -- ^ Path to store the .mix files
480 settings :: Settings,
483 depMakefile :: FilePath,
484 depIncludePkgDeps :: Bool,
485 depExcludeMods :: [ModuleName],
486 depSuffixes :: [String],
489 extraPkgConfs :: [FilePath],
490 -- ^ The @-package-conf@ flags given on the command line, in the order
493 packageFlags :: [PackageFlag],
494 -- ^ The @-package@ and @-hide-package@ flags from the command-line
497 -- NB. do not modify this field, it is calculated by
498 -- Packages.initPackages and Packages.updatePackages.
499 pkgDatabase :: Maybe [PackageConfig],
500 pkgState :: PackageState,
503 -- These have to be IORefs, because the defaultCleanupHandler needs to
504 -- know what to clean when an exception happens
505 filesToClean :: IORef [FilePath],
506 dirsToClean :: IORef (Map FilePath FilePath),
508 -- Names of files which were generated from -ddump-to-file; used to
509 -- track which ones we need to truncate because it's our first run
511 generatedDumps :: IORef (Set FilePath),
515 -- Don't change this without updating extensionFlags:
516 language :: Maybe Language,
517 -- Don't change this without updating extensionFlags:
518 extensions :: [OnOff ExtensionFlag],
519 -- extensionFlags should always be equal to
520 -- flattenExtensionFlags language extensions
521 extensionFlags :: [ExtensionFlag],
523 -- | Message output action: use "ErrUtils" instead of this if you can
524 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
526 haddockOptions :: Maybe String
529 data Settings = Settings {
530 sGhcUsagePath :: FilePath, -- Filled in by SysTools
531 sGhciUsagePath :: FilePath, -- ditto
533 sTmpDir :: String, -- no trailing '/'
534 -- You shouldn't need to look things up in rawSettings directly.
535 -- They should have their own fields instead.
536 sRawSettings :: [(String, String)],
537 sExtraGccViaCFlags :: [String],
538 sSystemPackageConfig :: FilePath,
539 -- commands for particular phases
541 sPgm_P :: (String,[Option]),
543 sPgm_c :: (String,[Option]),
544 sPgm_s :: (String,[Option]),
545 sPgm_a :: (String,[Option]),
546 sPgm_l :: (String,[Option]),
547 sPgm_dll :: (String,[Option]),
549 sPgm_sysman :: String,
550 sPgm_windres :: String,
551 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
552 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
553 -- options for particular phases
561 sOpt_windres :: [String],
562 sOpt_lo :: [String], -- LLVM: llvm optimiser
563 sOpt_lc :: [String] -- LLVM: llc static compiler
567 ghcUsagePath :: DynFlags -> FilePath
568 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
569 ghciUsagePath :: DynFlags -> FilePath
570 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
571 topDir :: DynFlags -> FilePath
572 topDir dflags = sTopDir (settings dflags)
573 tmpDir :: DynFlags -> String
574 tmpDir dflags = sTmpDir (settings dflags)
575 rawSettings :: DynFlags -> [(String, String)]
576 rawSettings dflags = sRawSettings (settings dflags)
577 extraGccViaCFlags :: DynFlags -> [String]
578 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
579 systemPackageConfig :: DynFlags -> FilePath
580 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
581 pgm_L :: DynFlags -> String
582 pgm_L dflags = sPgm_L (settings dflags)
583 pgm_P :: DynFlags -> (String,[Option])
584 pgm_P dflags = sPgm_P (settings dflags)
585 pgm_F :: DynFlags -> String
586 pgm_F dflags = sPgm_F (settings dflags)
587 pgm_c :: DynFlags -> (String,[Option])
588 pgm_c dflags = sPgm_c (settings dflags)
589 pgm_s :: DynFlags -> (String,[Option])
590 pgm_s dflags = sPgm_s (settings dflags)
591 pgm_a :: DynFlags -> (String,[Option])
592 pgm_a dflags = sPgm_a (settings dflags)
593 pgm_l :: DynFlags -> (String,[Option])
594 pgm_l dflags = sPgm_l (settings dflags)
595 pgm_dll :: DynFlags -> (String,[Option])
596 pgm_dll dflags = sPgm_dll (settings dflags)
597 pgm_T :: DynFlags -> String
598 pgm_T dflags = sPgm_T (settings dflags)
599 pgm_sysman :: DynFlags -> String
600 pgm_sysman dflags = sPgm_sysman (settings dflags)
601 pgm_windres :: DynFlags -> String
602 pgm_windres dflags = sPgm_windres (settings dflags)
603 pgm_lo :: DynFlags -> (String,[Option])
604 pgm_lo dflags = sPgm_lo (settings dflags)
605 pgm_lc :: DynFlags -> (String,[Option])
606 pgm_lc dflags = sPgm_lc (settings dflags)
607 opt_L :: DynFlags -> [String]
608 opt_L dflags = sOpt_L (settings dflags)
609 opt_P :: DynFlags -> [String]
610 opt_P dflags = sOpt_P (settings dflags)
611 opt_F :: DynFlags -> [String]
612 opt_F dflags = sOpt_F (settings dflags)
613 opt_c :: DynFlags -> [String]
614 opt_c dflags = sOpt_c (settings dflags)
615 opt_m :: DynFlags -> [String]
616 opt_m dflags = sOpt_m (settings dflags)
617 opt_a :: DynFlags -> [String]
618 opt_a dflags = sOpt_a (settings dflags)
619 opt_l :: DynFlags -> [String]
620 opt_l dflags = sOpt_l (settings dflags)
621 opt_windres :: DynFlags -> [String]
622 opt_windres dflags = sOpt_windres (settings dflags)
623 opt_lo :: DynFlags -> [String]
624 opt_lo dflags = sOpt_lo (settings dflags)
625 opt_lc :: DynFlags -> [String]
626 opt_lc dflags = sOpt_lc (settings dflags)
628 wayNames :: DynFlags -> [WayName]
629 wayNames = map wayName . ways
631 -- | The target code type of the compilation (if any).
633 -- Whenever you change the target, also make sure to set 'ghcLink' to
634 -- something sensible.
636 -- 'HscNothing' can be used to avoid generating any output, however, note
639 -- * This will not run the desugaring step, thus no warnings generated in
640 -- this step will be output. In particular, this includes warnings related
641 -- to pattern matching. You can run the desugarer manually using
642 -- 'GHC.desugarModule'.
644 -- * If a program uses Template Haskell the typechecker may try to run code
645 -- from an imported module. This will fail if no code has been generated
646 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
647 -- whether this might be the case and choose to either switch to a
648 -- different target or avoid typechecking such modules. (The latter may
649 -- preferable for security reasons.)
652 = HscC -- ^ Generate C code.
653 | HscAsm -- ^ Generate assembly using the native code generator.
654 | HscLlvm -- ^ Generate assembly using the llvm code generator.
655 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
656 | HscNothing -- ^ Don't generate any code. See notes above.
659 showHscTargetFlag :: HscTarget -> String
660 showHscTargetFlag HscC = "-fvia-c"
661 showHscTargetFlag HscAsm = "-fasm"
662 showHscTargetFlag HscLlvm = "-fllvm"
663 showHscTargetFlag HscInterpreted = "-fbyte-code"
664 showHscTargetFlag HscNothing = "-fno-code"
666 -- | Will this target result in an object file on the disk?
667 isObjectTarget :: HscTarget -> Bool
668 isObjectTarget HscC = True
669 isObjectTarget HscAsm = True
670 isObjectTarget HscLlvm = True
671 isObjectTarget _ = False
673 -- | The 'GhcMode' tells us whether we're doing multi-module
674 -- compilation (controlled via the "GHC" API) or one-shot
675 -- (single-module) compilation. This makes a difference primarily to
676 -- the "Finder": in one-shot mode we look for interface files for
677 -- imported modules, but in multi-module mode we look for source files
678 -- in order to check whether they need to be recompiled.
680 = CompManager -- ^ @\-\-make@, GHCi, etc.
681 | OneShot -- ^ @ghc -c Foo.hs@
682 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
685 instance Outputable GhcMode where
686 ppr CompManager = ptext (sLit "CompManager")
687 ppr OneShot = ptext (sLit "OneShot")
688 ppr MkDepend = ptext (sLit "MkDepend")
690 isOneShot :: GhcMode -> Bool
691 isOneShot OneShot = True
692 isOneShot _other = False
694 -- | What to do in the link step, if there is one.
696 = NoLink -- ^ Don't link at all
697 | LinkBinary -- ^ Link object code into a binary
698 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
699 -- bytecode and object code).
700 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
703 isNoLink :: GhcLink -> Bool
704 isNoLink NoLink = True
707 -- Is it worth evaluating this Bool and caching it in the DynFlags value
708 -- during initDynFlags?
709 doingTickyProfiling :: DynFlags -> Bool
710 doingTickyProfiling _ = opt_Ticky
711 -- XXX -ticky is a static flag, because it implies -debug which is also
712 -- static. If the way flags were made dynamic, we could fix this.
715 = ExposePackage String
716 | ExposePackageId String
718 | IgnorePackage String
721 defaultHscTarget :: HscTarget
722 defaultHscTarget = defaultObjectTarget
724 -- | The 'HscTarget' value corresponding to the default way to create
725 -- object files on the current platform.
726 defaultObjectTarget :: HscTarget
728 | cGhcUnregisterised == "YES" = HscC
729 | cGhcWithNativeCodeGen == "YES" = HscAsm
730 | otherwise = HscLlvm
737 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
740 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
741 initDynFlags :: DynFlags -> IO DynFlags
742 initDynFlags dflags = do
743 -- someday these will be dynamic flags
744 ways <- readIORef v_Ways
745 refFilesToClean <- newIORef []
746 refDirsToClean <- newIORef Map.empty
747 refGeneratedDumps <- newIORef Set.empty
750 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
751 rtsBuildTag = mkBuildTag ways,
752 filesToClean = refFilesToClean,
753 dirsToClean = refDirsToClean,
754 generatedDumps = refGeneratedDumps
757 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
758 -- and must be fully initialized by 'GHC.newSession' first.
759 defaultDynFlags :: Settings -> DynFlags
760 defaultDynFlags mySettings =
762 ghcMode = CompManager,
763 ghcLink = LinkBinary,
764 hscTarget = defaultHscTarget,
770 maxSimplIterations = 4,
771 shouldDumpSimplPhase = Nothing,
773 specConstrThreshold = Just 2000,
774 specConstrCount = Just 3,
775 liberateCaseThreshold = Just 2000,
776 floatLamArgs = Just 0, -- Default: float only if no fvs
777 strictnessBefore = [],
779 targetPlatform = defaultTargetPlatform,
780 cmdlineHcIncludes = [],
784 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
786 dphBackend = DPHNone,
788 thisPackage = mainPackageId,
791 dylibInstallName = Nothing,
795 objectSuf = phaseInputExt StopLn,
796 hcSuf = phaseInputExt HCc,
799 outputFile = Nothing,
801 dynLibLoader = SystemDependent,
802 dumpPrefix = Nothing,
803 dumpPrefixForce = Nothing,
807 cmdlineFrameworks = [],
809 rtsOptsEnabled = RtsOptsSafeOnly,
815 pkgDatabase = Nothing,
816 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
817 ways = panic "defaultDynFlags: No ways",
818 buildTag = panic "defaultDynFlags: No buildTag",
819 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
821 settings = mySettings,
823 depMakefile = "Makefile",
824 depIncludePkgDeps = False,
827 -- end of ghc -M values
828 filesToClean = panic "defaultDynFlags: No filesToClean",
829 dirsToClean = panic "defaultDynFlags: No dirsToClean",
830 generatedDumps = panic "defaultDynFlags: No generatedDumps",
831 haddockOptions = Nothing,
832 flags = defaultFlags,
835 extensionFlags = flattenExtensionFlags Nothing [],
837 log_action = \severity srcSpan style msg ->
839 SevOutput -> printSDoc msg style
840 SevInfo -> printErrs msg style
841 SevFatal -> printErrs msg style
844 printErrs (mkLocMessage srcSpan msg) style
845 -- careful (#2302): printErrs prints in UTF-8, whereas
846 -- converting to string first and using hPutStr would
847 -- just emit the low 8 bits of each unicode char.
851 Note [Verbosity levels]
852 ~~~~~~~~~~~~~~~~~~~~~~~
853 0 | print errors & warnings only
854 1 | minimal verbosity: print "compiling M ... done." for each module.
855 2 | equivalent to -dshow-passes
856 3 | equivalent to existing "ghc -v"
857 4 | "ghc -v -ddump-most"
858 5 | "ghc -v -ddump-all"
864 -- OnOffs accumulate in reverse order, so we use foldr in order to
865 -- process them in the right order
866 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
868 flattenExtensionFlags ml = foldr f defaultExtensionFlags
869 where f (On f) flags = f : delete f flags
870 f (Off f) flags = delete f flags
871 defaultExtensionFlags = languageExtensions ml
873 languageExtensions :: Maybe Language -> [ExtensionFlag]
875 languageExtensions Nothing
876 -- Nothing => the default case
877 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
878 -- behaviour the default, to see if anyone notices
880 -- In due course I'd like Opt_MonoLocalBinds to be on by default
881 -- But NB it's implied by GADTs etc
882 -- SLPJ September 2010
883 : Opt_NondecreasingIndentation -- This has been on by default for some time
884 : delete Opt_DatatypeContexts -- The Haskell' committee decided to
885 -- remove datatype contexts from the
887 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
888 (languageExtensions (Just Haskell2010))
890 languageExtensions (Just Haskell98)
891 = [Opt_ImplicitPrelude,
892 Opt_MonomorphismRestriction,
894 Opt_DatatypeContexts,
895 Opt_NondecreasingIndentation
896 -- strictly speaking non-standard, but we always had this
897 -- on implicitly before the option was added in 7.1, and
898 -- turning it off breaks code, so we're keeping it on for
899 -- backwards compatibility. Cabal uses -XHaskell98 by
900 -- default unless you specify another language.
903 languageExtensions (Just Haskell2010)
904 = [Opt_ImplicitPrelude,
905 Opt_MonomorphismRestriction,
906 Opt_DatatypeContexts,
908 Opt_ForeignFunctionInterface,
913 -- | Test whether a 'DynFlag' is set
914 dopt :: DynFlag -> DynFlags -> Bool
915 dopt f dflags = f `elem` (flags dflags)
918 dopt_set :: DynFlags -> DynFlag -> DynFlags
919 dopt_set dfs f = dfs{ flags = f : flags dfs }
921 -- | Unset a 'DynFlag'
922 dopt_unset :: DynFlags -> DynFlag -> DynFlags
923 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
925 -- | Test whether a 'ExtensionFlag' is set
926 xopt :: ExtensionFlag -> DynFlags -> Bool
927 xopt f dflags = f `elem` extensionFlags dflags
929 -- | Set a 'ExtensionFlag'
930 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
932 = let onoffs = On f : extensions dfs
933 in dfs { extensions = onoffs,
934 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
936 -- | Unset a 'ExtensionFlag'
937 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
939 = let onoffs = Off f : extensions dfs
940 in dfs { extensions = onoffs,
941 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
943 setLanguage :: Language -> DynP ()
944 setLanguage l = upd f
945 where f dfs = let mLang = Just l
946 oneoffs = extensions dfs
949 extensionFlags = flattenExtensionFlags mLang oneoffs
952 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
953 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
954 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
955 -> [a] -- ^ Correctly ordered extracted options
956 getOpts dflags opts = reverse (opts dflags)
957 -- We add to the options from the front, so we need to reverse the list
959 -- | Gets the verbosity flag for the current verbosity level. This is fed to
960 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
961 getVerbFlags :: DynFlags -> [String]
963 | verbosity dflags >= 4 = ["-v"]
966 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
967 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
968 setPgmP, addOptl, addOptP,
969 addCmdlineFramework, addHaddockOpts
970 :: String -> DynFlags -> DynFlags
971 setOutputFile, setOutputHi, setDumpPrefixForce
972 :: Maybe String -> DynFlags -> DynFlags
974 setObjectDir f d = d{ objectDir = Just f}
975 setHiDir f d = d{ hiDir = Just f}
976 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
977 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
978 -- \#included from the .hc file when compiling via C (i.e. unregisterised
980 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
981 setDylibInstallName f d = d{ dylibInstallName = Just f}
983 setObjectSuf f d = d{ objectSuf = f}
984 setHiSuf f d = d{ hiSuf = f}
985 setHcSuf f d = d{ hcSuf = f}
987 setOutputFile f d = d{ outputFile = f}
988 setOutputHi f d = d{ outputHi = f}
990 parseDynLibLoaderMode f d =
992 ("deploy", "") -> d{ dynLibLoader = Deployable }
993 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
994 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
996 setDumpPrefixForce f d = d { dumpPrefixForce = f}
998 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
999 -- Config.hs should really use Option.
1000 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
1001 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
1002 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
1005 setDepMakefile :: FilePath -> DynFlags -> DynFlags
1006 setDepMakefile f d = d { depMakefile = deOptDep f }
1008 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1009 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1011 addDepExcludeMod :: String -> DynFlags -> DynFlags
1012 addDepExcludeMod m d
1013 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1015 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1016 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1019 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1020 -- we need to strip the "-optdep" off of the arg
1021 deOptDep :: String -> String
1022 deOptDep x = case stripPrefix "-optdep" x of
1026 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1028 addHaddockOpts f d = d{ haddockOptions = Just f}
1030 -- -----------------------------------------------------------------------------
1031 -- Command-line options
1033 -- | When invoking external tools as part of the compilation pipeline, we
1034 -- pass these a sequence of options on the command-line. Rather than
1035 -- just using a list of Strings, we use a type that allows us to distinguish
1036 -- between filepaths and 'other stuff'. The reason for this is that
1037 -- this type gives us a handle on transforming filenames, and filenames only,
1038 -- to whatever format they're expected to be on a particular platform.
1040 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1041 String -- a non-filepath prefix that shouldn't be
1042 -- transformed (e.g., "/out=")
1043 String -- the filepath/filename portion
1046 showOpt :: Option -> String
1047 showOpt (FileOption pre f) = pre ++ f
1048 showOpt (Option s) = s
1050 -----------------------------------------------------------------------------
1051 -- Setting the optimisation level
1053 updOptLevel :: Int -> DynFlags -> DynFlags
1054 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1056 = dfs2{ optLevel = final_n }
1058 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1059 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1060 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1062 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1063 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1065 -- -----------------------------------------------------------------------------
1066 -- StgToDo: abstraction of stg-to-stg passes to run.
1069 = StgDoMassageForProfiling -- should be (next to) last
1070 -- There's also setStgVarInfo, but its absolute "lastness"
1071 -- is so critical that it is hardwired in (no flag).
1074 getStgToDo :: DynFlags -> [StgToDo]
1078 stg_stats = dopt Opt_StgStats dflags
1080 todo1 = if stg_stats then [D_stg_stats] else []
1082 todo2 | WayProf `elem` wayNames dflags
1083 = StgDoMassageForProfiling : todo1
1087 {- **********************************************************************
1091 %********************************************************************* -}
1093 -- -----------------------------------------------------------------------------
1094 -- Parsing the dynamic flags.
1096 -- | Parse dynamic flags from a list of command line arguments. Returns the
1097 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1098 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1099 -- flags or missing arguments).
1100 parseDynamicFlags :: Monad m =>
1101 DynFlags -> [Located String]
1102 -> m (DynFlags, [Located String], [Located String])
1103 -- ^ Updated 'DynFlags', left-over arguments, and
1104 -- list of warnings.
1105 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1107 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1108 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1109 parseDynamicNoPackageFlags :: Monad m =>
1110 DynFlags -> [Located String]
1111 -> m (DynFlags, [Located String], [Located String])
1112 -- ^ Updated 'DynFlags', left-over arguments, and
1113 -- list of warnings.
1114 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1116 parseDynamicFlags_ :: Monad m =>
1117 DynFlags -> [Located String] -> Bool
1118 -> m (DynFlags, [Located String], [Located String])
1119 parseDynamicFlags_ dflags0 args pkg_flags = do
1120 -- XXX Legacy support code
1121 -- We used to accept things like
1122 -- optdep-f -optdepdepend
1123 -- optdep-f -optdep depend
1124 -- optdep -f -optdepdepend
1125 -- optdep -f -optdep depend
1126 -- but the spaces trip up proper argument handling. So get rid of them.
1127 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1128 f (x : xs) = x : f xs
1132 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1133 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1134 | otherwise = dynamic_flags
1136 let ((leftover, errs, warns), dflags1)
1137 = runCmdLine (processArgs flag_spec args') dflags0
1138 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1140 return (dflags1, leftover, warns)
1143 {- **********************************************************************
1145 DynFlags specifications
1147 %********************************************************************* -}
1149 allFlags :: [String]
1150 allFlags = map ('-':) $
1151 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1152 map ("fno-"++) flags ++
1153 map ("f"++) flags ++
1154 map ("f"++) flags' ++
1155 map ("X"++) supportedExtensions
1156 where ok (PrefixPred _ _) = False
1158 flags = [ name | (name, _, _) <- fFlags ]
1159 flags' = [ name | (name, _, _) <- fLangFlags ]
1161 --------------- The main flags themselves ------------------
1162 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1164 Flag "n" (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
1165 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1166 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1168 (HasArg (\s -> do { addCmdlineHCInclude s
1169 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1170 , Flag "v" (OptIntSuffix setVerbosity)
1172 ------- Specific phases --------------------------------------------
1173 -- need to appear before -pgmL to be parsed as LLVM flags.
1174 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1175 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1176 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1177 , Flag "pgmP" (hasArg setPgmP)
1178 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1179 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1180 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1181 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1182 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1183 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1184 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1185 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1187 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1188 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1189 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1190 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1191 , Flag "optP" (hasArg addOptP)
1192 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1193 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1194 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1195 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1196 , Flag "optl" (hasArg addOptl)
1197 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1200 (NoArg (if can_split
1201 then setDynFlag Opt_SplitObjs
1202 else addWarn "ignoring -fsplit-objs"))
1204 -------- ghc -M -----------------------------------------------------
1205 , Flag "dep-suffix" (hasArg addDepSuffix)
1206 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1207 , Flag "dep-makefile" (hasArg setDepMakefile)
1208 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1209 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1210 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1211 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1212 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1213 , Flag "exclude-module" (hasArg addDepExcludeMod)
1214 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1215 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1217 -------- Linking ----------------------------------------------------
1218 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1219 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1220 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1221 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1223 ------- Libraries ---------------------------------------------------
1224 , Flag "L" (Prefix addLibraryPath)
1225 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1227 ------- Frameworks --------------------------------------------------
1228 -- -framework-path should really be -F ...
1229 , Flag "framework-path" (HasArg addFrameworkPath)
1230 , Flag "framework" (hasArg addCmdlineFramework)
1232 ------- Output Redirection ------------------------------------------
1233 , Flag "odir" (hasArg setObjectDir)
1234 , Flag "o" (SepArg (upd . setOutputFile . Just))
1235 , Flag "ohi" (hasArg (setOutputHi . Just ))
1236 , Flag "osuf" (hasArg setObjectSuf)
1237 , Flag "hcsuf" (hasArg setHcSuf)
1238 , Flag "hisuf" (hasArg setHiSuf)
1239 , Flag "hidir" (hasArg setHiDir)
1240 , Flag "tmpdir" (hasArg setTmpDir)
1241 , Flag "stubdir" (hasArg setStubDir)
1242 , Flag "outputdir" (hasArg setOutputDir)
1243 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1245 ------- Keeping temporary files -------------------------------------
1246 -- These can be singular (think ghc -c) or plural (think ghc --make)
1247 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1248 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1249 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1250 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1251 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1252 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1253 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1254 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1255 -- This only makes sense as plural
1256 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1258 ------- Miscellaneous ----------------------------------------------
1259 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1260 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1261 , Flag "with-rtsopts" (HasArg setRtsOpts)
1262 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1263 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1264 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1265 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1266 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1267 , Flag "main-is" (SepArg setMainIs)
1268 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1269 , Flag "haddock-opts" (hasArg addHaddockOpts)
1270 , Flag "hpcdir" (SepArg setOptHpcDir)
1272 ------- recompilation checker --------------------------------------
1273 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1274 ; deprecate "Use -fno-force-recomp instead" }))
1275 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1276 ; deprecate "Use -fforce-recomp instead" }))
1278 ------ HsCpp opts ---------------------------------------------------
1279 , Flag "D" (AnySuffix (upd . addOptP))
1280 , Flag "U" (AnySuffix (upd . addOptP))
1282 ------- Include/Import Paths ----------------------------------------
1283 , Flag "I" (Prefix addIncludePath)
1284 , Flag "i" (OptPrefix addImportPath)
1286 ------ Debugging ----------------------------------------------------
1287 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1289 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1290 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1291 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1292 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1293 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1294 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1295 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1296 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1297 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1298 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1299 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1300 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1301 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1302 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1303 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1304 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1305 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1306 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1307 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1308 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1309 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1310 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1311 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1312 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1313 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1314 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1315 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1316 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1317 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1318 ; setDumpFlag' Opt_D_dump_llvm}))
1319 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1320 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1321 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1322 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1323 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1324 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1325 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1326 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1327 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1328 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1329 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1330 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1331 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1332 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1333 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1334 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1335 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1336 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1337 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1338 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1339 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1340 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1341 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1342 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1343 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1344 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1345 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1346 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1347 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1348 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1349 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1350 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1351 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1352 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1353 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1354 ; setVerboseCore2Core }))
1355 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1356 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1357 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1358 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1359 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1360 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1361 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1362 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1363 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1364 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1365 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1366 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1367 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1368 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1369 , Flag "dshow-passes" (NoArg (do forceRecompile
1370 setVerbosity (Just 2)))
1371 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1373 ------ Coq-in-GHC ---------------------------
1374 , Flag "ddump-proofs" (NoArg (setDynFlag Opt_D_dump_proofs))
1375 , Flag "ddump-coqpass" (NoArg (setDynFlag Opt_D_coqpass))
1376 , Flag "fcoqpass" (NoArg (setDynFlag Opt_F_coqpass))
1377 , Flag "fsimpleopt-before-flatten" (NoArg (setDynFlag Opt_F_simpleopt_before_flatten))
1378 , Flag "fflatten" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten }))
1379 , Flag "funsafe-skolemize" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten ; setDynFlag Opt_F_skolemize }))
1381 ------ Machine dependant (-m<blah>) stuff ---------------------------
1383 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1384 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1385 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1386 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1388 ------ Warning opts -------------------------------------------------
1389 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1390 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1391 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1392 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1393 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1394 ; deprecate "Use -w instead" }))
1395 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1397 ------ Optimisation flags ------------------------------------------
1398 , Flag "O" (noArgM (setOptLevel 1))
1399 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1400 setOptLevel 0 dflags))
1401 , Flag "Odph" (noArgM setDPHOpt)
1402 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1403 -- If the number is missing, use 1
1405 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1406 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1407 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1408 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1409 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1410 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1411 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1412 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1413 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1414 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1415 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1416 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1417 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1419 ------ Profiling ----------------------------------------------------
1421 -- XXX Should the -f* flags be deprecated?
1422 -- They don't seem to be documented
1423 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1424 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1425 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1426 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1427 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1428 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1429 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1430 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1431 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1433 ------ DPH flags ----------------------------------------------------
1435 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1436 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1437 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1438 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1440 ------ Compiler flags -----------------------------------------------
1442 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1443 , Flag "fvia-c" (NoArg
1444 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1445 , Flag "fvia-C" (NoArg
1446 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1447 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1449 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1450 setTarget HscNothing))
1451 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1452 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1453 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1454 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1456 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1457 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1458 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1459 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1460 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1461 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1462 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1464 package_flags :: [Flag (CmdLineP DynFlags)]
1466 ------- Packages ----------------------------------------------------
1467 Flag "package-conf" (HasArg extraPkgConf_)
1468 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1469 , Flag "package-name" (hasArg setPackageName)
1470 , Flag "package-id" (HasArg exposePackageId)
1471 , Flag "package" (HasArg exposePackage)
1472 , Flag "hide-package" (HasArg hidePackage)
1473 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1474 , Flag "ignore-package" (HasArg ignorePackage)
1475 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1476 ; deprecate "Use -package instead" }))
1479 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1480 -- False <=> we are turning the flag off
1481 turnOn :: TurnOnFlag; turnOn = True
1482 turnOff :: TurnOnFlag; turnOff = False
1485 = ( String -- Flag in string form
1486 , flag -- Flag in internal form
1487 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1488 -- Typically, emit a warning or error
1490 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1491 -> String -- ^ The flag prefix
1492 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1493 -> FlagSpec flag -- ^ Specification of this particular flag
1494 -> Flag (CmdLineP DynFlags)
1495 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1496 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1498 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1499 deprecatedForExtension lang turn_on
1500 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1502 flag | turn_on = lang
1503 | otherwise = "No"++lang
1505 useInstead :: String -> TurnOnFlag -> DynP ()
1506 useInstead flag turn_on
1507 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1509 no = if turn_on then "" else "no-"
1511 nop :: TurnOnFlag -> DynP ()
1514 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1515 fFlags :: [FlagSpec DynFlag]
1517 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1518 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1519 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1520 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1521 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1522 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1523 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1524 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1525 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1526 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1527 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1528 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1529 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1530 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1531 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1532 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1533 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1534 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1535 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1536 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1537 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1538 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1539 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1540 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1541 ( "warn-orphans", Opt_WarnOrphans, nop ),
1542 ( "warn-identities", Opt_WarnIdentities, nop ),
1543 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1544 ( "warn-tabs", Opt_WarnTabs, nop ),
1545 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1546 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1547 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1548 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1549 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1550 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1551 ( "strictness", Opt_Strictness, nop ),
1552 ( "specialise", Opt_Specialise, nop ),
1553 ( "float-in", Opt_FloatIn, nop ),
1554 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1555 ( "full-laziness", Opt_FullLaziness, nop ),
1556 ( "liberate-case", Opt_LiberateCase, nop ),
1557 ( "spec-constr", Opt_SpecConstr, nop ),
1558 ( "cse", Opt_CSE, nop ),
1559 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1560 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1561 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1562 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1563 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1564 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1565 ( "case-merge", Opt_CaseMerge, nop ),
1566 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1567 ( "method-sharing", Opt_MethodSharing,
1568 \_ -> deprecate "doesn't do anything any more"),
1569 -- Remove altogether in GHC 7.2
1570 ( "dicts-cheap", Opt_DictsCheap, nop ),
1571 ( "excess-precision", Opt_ExcessPrecision, nop ),
1572 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1573 ( "print-bind-result", Opt_PrintBindResult, nop ),
1574 ( "force-recomp", Opt_ForceRecomp, nop ),
1575 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1576 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1577 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1578 ( "break-on-exception", Opt_BreakOnException, nop ),
1579 ( "break-on-error", Opt_BreakOnError, nop ),
1580 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1581 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1582 ( "run-cps", Opt_RunCPS, nop ),
1583 ( "run-cpsz", Opt_RunCPSZ, nop ),
1584 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1585 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1586 ( "vectorise", Opt_Vectorise, nop ),
1587 ( "regs-graph", Opt_RegsGraph, nop ),
1588 ( "regs-iterative", Opt_RegsIterative, nop ),
1589 ( "gen-manifest", Opt_GenManifest, nop ),
1590 ( "embed-manifest", Opt_EmbedManifest, nop ),
1591 ( "ext-core", Opt_EmitExternalCore, nop ),
1592 ( "shared-implib", Opt_SharedImplib, nop ),
1593 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1594 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1595 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1596 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1599 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1600 fLangFlags :: [FlagSpec ExtensionFlag]
1602 ( "th", Opt_TemplateHaskell,
1603 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1604 ( "fi", Opt_ForeignFunctionInterface,
1605 deprecatedForExtension "ForeignFunctionInterface" ),
1606 ( "ffi", Opt_ForeignFunctionInterface,
1607 deprecatedForExtension "ForeignFunctionInterface" ),
1608 ( "arrows", Opt_Arrows,
1609 deprecatedForExtension "Arrows" ),
1610 ( "generics", Opt_Generics,
1611 deprecatedForExtension "Generics" ),
1612 ( "implicit-prelude", Opt_ImplicitPrelude,
1613 deprecatedForExtension "ImplicitPrelude" ),
1614 ( "bang-patterns", Opt_BangPatterns,
1615 deprecatedForExtension "BangPatterns" ),
1616 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1617 deprecatedForExtension "MonomorphismRestriction" ),
1618 ( "mono-pat-binds", Opt_MonoPatBinds,
1619 deprecatedForExtension "MonoPatBinds" ),
1620 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1621 deprecatedForExtension "ExtendedDefaultRules" ),
1622 ( "implicit-params", Opt_ImplicitParams,
1623 deprecatedForExtension "ImplicitParams" ),
1624 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1625 deprecatedForExtension "ScopedTypeVariables" ),
1626 ( "parr", Opt_ParallelArrays,
1627 deprecatedForExtension "ParallelArrays" ),
1628 ( "PArr", Opt_ParallelArrays,
1629 deprecatedForExtension "ParallelArrays" ),
1630 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1631 deprecatedForExtension "OverlappingInstances" ),
1632 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1633 deprecatedForExtension "UndecidableInstances" ),
1634 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1635 deprecatedForExtension "IncoherentInstances" )
1638 supportedLanguages :: [String]
1639 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1641 supportedExtensions :: [String]
1642 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1644 supportedLanguagesAndExtensions :: [String]
1645 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1647 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1648 languageFlags :: [FlagSpec Language]
1650 ( "Haskell98", Haskell98, nop ),
1651 ( "Haskell2010", Haskell2010, nop )
1654 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1655 xFlags :: [FlagSpec ExtensionFlag]
1657 ( "CPP", Opt_Cpp, nop ),
1658 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1659 ( "TupleSections", Opt_TupleSections, nop ),
1660 ( "PatternGuards", Opt_PatternGuards, nop ),
1661 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1662 ( "MagicHash", Opt_MagicHash, nop ),
1663 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1664 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1665 ( "KindSignatures", Opt_KindSignatures, nop ),
1666 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1667 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1668 ( "TransformListComp", Opt_TransformListComp, nop ),
1669 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1670 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1671 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1672 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1673 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1674 ( "Rank2Types", Opt_Rank2Types, nop ),
1675 ( "RankNTypes", Opt_RankNTypes, nop ),
1676 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1677 ( "TypeOperators", Opt_TypeOperators, nop ),
1678 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1679 deprecatedForExtension "DoRec"),
1680 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1681 ( "Arrows", Opt_Arrows, nop ),
1682 ( "ModalTypes", Opt_ModalTypes, nop ),
1683 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1684 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1685 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1686 ( "Generics", Opt_Generics,
1687 \ _ -> deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support." ),
1688 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1689 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1690 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1691 ( "RecordPuns", Opt_RecordPuns,
1692 deprecatedForExtension "NamedFieldPuns" ),
1693 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1694 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1695 ( "GADTs", Opt_GADTs, nop ),
1696 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1697 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1698 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1699 ( "BangPatterns", Opt_BangPatterns, nop ),
1700 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1701 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1702 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1703 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1704 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1705 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1706 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1707 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1708 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1709 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1710 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1711 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1712 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1713 \ turn_on -> if not turn_on
1714 then deprecate "You can't turn off RelaxedPolyRec any more"
1716 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1717 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1718 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1720 ( "PatternSignatures", Opt_ScopedTypeVariables,
1721 deprecatedForExtension "ScopedTypeVariables" ),
1723 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1724 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1725 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1726 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1727 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1728 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1729 ( "DeriveGeneric", Opt_DeriveGeneric, nop ),
1730 ( "DefaultSignatures", Opt_DefaultSignatures, nop ),
1731 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1732 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1733 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1734 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1735 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1736 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1737 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1738 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1739 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1740 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1741 ( "PackageImports", Opt_PackageImports, nop )
1744 defaultFlags :: [DynFlag]
1746 = [ Opt_AutoLinkPackages,
1747 Opt_ReadUserPackageConf,
1751 #if GHC_DEFAULT_NEW_CODEGEN
1757 Opt_PrintBindContents,
1762 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1763 -- The default -O0 options
1767 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1769 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1770 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1771 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1772 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1773 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1774 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1775 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1776 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1778 , (Opt_ModalTypes, turnOn, Opt_RankNTypes)
1779 , (Opt_ModalTypes, turnOn, Opt_ExplicitForAll)
1780 --, (Opt_ModalTypes, turnOn, Opt_RebindableSyntax)
1781 , (Opt_ModalTypes, turnOff, Opt_MonomorphismRestriction)
1783 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1785 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1786 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1787 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1789 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1790 -- all over the place
1792 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1794 -- Record wild-cards implies field disambiguation
1795 -- Otherwise if you write (C {..}) you may well get
1796 -- stuff like " 'a' not in scope ", which is a bit silly
1797 -- if the compiler has just filled in field 'a' of constructor 'C'
1798 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1800 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1803 optLevelFlags :: [([Int], DynFlag)]
1805 = [ ([0], Opt_IgnoreInterfacePragmas)
1806 , ([0], Opt_OmitInterfacePragmas)
1808 , ([1,2], Opt_IgnoreAsserts)
1809 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1811 , ([1,2], Opt_DoEtaReduction)
1812 , ([1,2], Opt_CaseMerge)
1813 , ([1,2], Opt_Strictness)
1815 , ([1,2], Opt_FullLaziness)
1816 , ([1,2], Opt_Specialise)
1817 , ([1,2], Opt_FloatIn)
1819 , ([2], Opt_LiberateCase)
1820 , ([2], Opt_SpecConstr)
1821 , ([2], Opt_RegsGraph)
1823 -- , ([2], Opt_StaticArgumentTransformation)
1824 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1825 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1826 -- several improvements to the heuristics, and I'm concerned that without
1827 -- those changes SAT will interfere with some attempts to write "high
1828 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1829 -- this year. In particular, the version in HEAD lacks the tail call
1830 -- criterion, so many things that look like reasonable loops will be
1831 -- turned into functions with extra (unneccesary) thunk creation.
1833 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1834 -- This one is important for a tiresome reason:
1835 -- we want to make sure that the bindings for data
1836 -- constructors are eta-expanded. This is probably
1837 -- a good thing anyway, but it seems fragile.
1840 -- -----------------------------------------------------------------------------
1841 -- Standard sets of warning options
1843 standardWarnings :: [DynFlag]
1845 = [ Opt_WarnWarningsDeprecations,
1846 Opt_WarnDeprecatedFlags,
1847 Opt_WarnUnrecognisedPragmas,
1848 Opt_WarnOverlappingPatterns,
1849 Opt_WarnMissingFields,
1850 Opt_WarnMissingMethods,
1851 Opt_WarnDuplicateExports,
1852 Opt_WarnLazyUnliftedBindings,
1853 Opt_WarnDodgyForeignImports,
1854 Opt_WarnWrongDoBind,
1855 Opt_WarnAlternativeLayoutRuleTransitional
1858 minusWOpts :: [DynFlag]
1859 -- Things you get with -W
1861 = standardWarnings ++
1862 [ Opt_WarnUnusedBinds,
1863 Opt_WarnUnusedMatches,
1864 Opt_WarnUnusedImports,
1865 Opt_WarnIncompletePatterns,
1866 Opt_WarnDodgyExports,
1867 Opt_WarnDodgyImports
1870 minusWallOpts :: [DynFlag]
1871 -- Things you get with -Wall
1874 [ Opt_WarnTypeDefaults,
1875 Opt_WarnNameShadowing,
1876 Opt_WarnMissingSigs,
1879 Opt_WarnUnusedDoBind
1882 minuswRemovesOpts :: [DynFlag]
1883 -- minuswRemovesOpts should be every warning option
1887 Opt_WarnIncompletePatternsRecUpd,
1888 Opt_WarnIncompleteUniPatterns,
1889 Opt_WarnMonomorphism,
1890 Opt_WarnUnrecognisedPragmas,
1891 Opt_WarnAutoOrphans,
1892 Opt_WarnImplicitPrelude
1895 enableGlasgowExts :: DynP ()
1896 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1897 mapM_ setExtensionFlag glasgowExtsFlags
1899 disableGlasgowExts :: DynP ()
1900 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1901 mapM_ unSetExtensionFlag glasgowExtsFlags
1903 glasgowExtsFlags :: [ExtensionFlag]
1904 glasgowExtsFlags = [
1905 Opt_ForeignFunctionInterface
1906 , Opt_UnliftedFFITypes
1907 , Opt_ImplicitParams
1908 , Opt_ScopedTypeVariables
1910 , Opt_TypeSynonymInstances
1911 , Opt_StandaloneDeriving
1912 , Opt_DeriveDataTypeable
1914 , Opt_DeriveFoldable
1915 , Opt_DeriveTraversable
1917 , Opt_FlexibleContexts
1918 , Opt_FlexibleInstances
1919 , Opt_ConstrainedClassMethods
1920 , Opt_MultiParamTypeClasses
1921 , Opt_FunctionalDependencies
1923 , Opt_PolymorphicComponents
1924 , Opt_ExistentialQuantification
1926 , Opt_PostfixOperators
1928 , Opt_LiberalTypeSynonyms
1932 , Opt_ParallelListComp
1933 , Opt_EmptyDataDecls
1934 , Opt_KindSignatures
1935 , Opt_GeneralizedNewtypeDeriving ]
1938 -- Consult the RTS to find whether GHC itself has been built profiled
1939 -- If so, you can't use Template Haskell
1940 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1942 rtsIsProfiled :: Bool
1943 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1946 checkTemplateHaskellOk :: Bool -> DynP ()
1948 checkTemplateHaskellOk turn_on
1949 | turn_on && rtsIsProfiled
1950 = addErr "You can't use Template Haskell with a profiled compiler"
1954 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1955 -- so we simply say "ok". It doesn't matter because TH isn't
1956 -- available in stage 1 anyway.
1957 checkTemplateHaskellOk _ = return ()
1960 {- **********************************************************************
1962 DynFlags constructors
1964 %********************************************************************* -}
1966 type DynP = EwM (CmdLineP DynFlags)
1968 upd :: (DynFlags -> DynFlags) -> DynP ()
1969 upd f = liftEwM (do dflags <- getCmdLineState
1970 putCmdLineState $! f dflags)
1972 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1973 updM f = do dflags <- liftEwM getCmdLineState
1975 liftEwM $ putCmdLineState $! dflags'
1977 --------------- Constructor functions for OptKind -----------------
1978 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1979 noArg fn = NoArg (upd fn)
1981 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1982 noArgM fn = NoArg (updM fn)
1984 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1985 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1987 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1988 hasArg fn = HasArg (upd . fn)
1990 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1991 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1992 ; deprecate deprec })
1994 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1995 intSuffix fn = IntSuffix (\n -> upd (fn n))
1997 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
1998 -> OptKind (CmdLineP DynFlags)
1999 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
2001 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
2002 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
2004 --------------------------
2005 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2006 setDynFlag f = upd (\dfs -> dopt_set dfs f)
2007 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2009 --------------------------
2010 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
2011 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
2014 deps = [ if turn_on then setExtensionFlag d
2015 else unSetExtensionFlag d
2016 | (f', turn_on, d) <- impliedFlags, f' == f ]
2017 -- When you set f, set the ones it implies
2018 -- NB: use setExtensionFlag recursively, in case the implied flags
2019 -- implies further flags
2021 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
2022 -- When you un-set f, however, we don't un-set the things it implies
2023 -- (except for -fno-glasgow-exts, which is treated specially)
2025 --------------------------
2026 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2027 alterSettings f dflags = dflags { settings = f (settings dflags) }
2029 --------------------------
2030 setDumpFlag' :: DynFlag -> DynP ()
2031 setDumpFlag' dump_flag
2032 = do { setDynFlag dump_flag
2033 ; when want_recomp forceRecompile }
2035 -- Certain dumpy-things are really interested in what's going
2036 -- on during recompilation checking, so in those cases we
2037 -- don't want to turn it off.
2038 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2039 Opt_D_dump_hi_diffs]
2041 forceRecompile :: DynP ()
2042 -- Whenver we -ddump, force recompilation (by switching off the
2043 -- recompilation checker), else you don't see the dump! However,
2044 -- don't switch it off in --make mode, else *everything* gets
2045 -- recompiled which probably isn't what you want
2046 forceRecompile = do { dfs <- liftEwM getCmdLineState
2047 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2049 force_recomp dfs = isOneShot (ghcMode dfs)
2051 setVerboseCore2Core :: DynP ()
2052 setVerboseCore2Core = do forceRecompile
2053 setDynFlag Opt_D_verbose_core2core
2054 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2056 setDumpSimplPhases :: String -> DynP ()
2057 setDumpSimplPhases s = do forceRecompile
2058 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2060 spec = case s of { ('=' : s') -> s'; _ -> s }
2062 setVerbosity :: Maybe Int -> DynP ()
2063 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2065 addCmdlineHCInclude :: String -> DynP ()
2066 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2068 extraPkgConf_ :: FilePath -> DynP ()
2069 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2071 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2073 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2075 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2077 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2079 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2081 setPackageName :: String -> DynFlags -> DynFlags
2082 setPackageName p s = s{ thisPackage = stringToPackageId p }
2084 -- If we're linking a binary, then only targets that produce object
2085 -- code are allowed (requests for other target types are ignored).
2086 setTarget :: HscTarget -> DynP ()
2087 setTarget l = upd set
2090 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2093 -- Changes the target only if we're compiling object code. This is
2094 -- used by -fasm and -fllvm, which switch from one to the other, but
2095 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2096 -- can be safely used in an OPTIONS_GHC pragma.
2097 setObjTarget :: HscTarget -> DynP ()
2098 setObjTarget l = updM set
2101 | isObjectTarget (hscTarget dflags)
2104 | cGhcUnregisterised /= "YES" ->
2105 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2108 | cGhcWithNativeCodeGen /= "YES" ->
2109 do addWarn ("Compiler has no native codegen, so ignoring " ++
2113 | cGhcUnregisterised == "YES" ->
2114 do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2116 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2117 (not opt_Static || opt_PIC)
2119 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2121 _ -> return $ dflags { hscTarget = l }
2122 | otherwise = return dflags
2123 where platform = targetPlatform dflags
2124 arch = platformArch platform
2125 os = platformOS platform
2126 flag = showHscTargetFlag l
2128 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2129 setOptLevel n dflags
2130 | hscTarget dflags == HscInterpreted && n > 0
2131 = do addWarn "-O conflicts with --interactive; -O ignored."
2134 = return (updOptLevel n dflags)
2137 -- -Odph is equivalent to
2139 -- -O2 optimise as much as possible
2140 -- -fmax-simplifier-iterations20 this is necessary sometimes
2141 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2143 setDPHOpt :: DynFlags -> DynP DynFlags
2144 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2148 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2149 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2150 -- vectoriser cannot be used.
2152 data DPHBackend = DPHPar -- "dph-par"
2153 | DPHSeq -- "dph-seq"
2154 | DPHThis -- the currently compiled package
2155 | DPHNone -- no DPH library available
2156 deriving(Eq, Ord, Enum, Show)
2158 setDPHBackend :: DPHBackend -> DynP ()
2159 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2161 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2163 dphPackageMaybe :: DynFlags -> Maybe PackageId
2164 dphPackageMaybe dflags
2165 = case dphBackend dflags of
2166 DPHPar -> Just dphParPackageId
2167 DPHSeq -> Just dphSeqPackageId
2168 DPHThis -> Just (thisPackage dflags)
2171 setMainIs :: String -> DynP ()
2173 | not (null main_fn) && isLower (head main_fn)
2174 -- The arg looked like "Foo.Bar.baz"
2175 = upd $ \d -> d{ mainFunIs = Just main_fn,
2176 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2178 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2179 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2181 | otherwise -- The arg looked like "baz"
2182 = upd $ \d -> d{ mainFunIs = Just arg }
2184 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2186 -----------------------------------------------------------------------------
2187 -- Paths & Libraries
2189 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2191 -- -i on its own deletes the import paths
2192 addImportPath "" = upd (\s -> s{importPaths = []})
2193 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2196 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2199 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2201 addFrameworkPath p =
2202 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2204 #ifndef mingw32_TARGET_OS
2205 split_marker :: Char
2206 split_marker = ':' -- not configurable (ToDo)
2209 splitPathList :: String -> [String]
2210 splitPathList s = filter notNull (splitUp s)
2211 -- empty paths are ignored: there might be a trailing
2212 -- ':' in the initial list, for example. Empty paths can
2213 -- cause confusion when they are translated into -I options
2214 -- for passing to gcc.
2216 #ifndef mingw32_TARGET_OS
2217 splitUp xs = split split_marker xs
2219 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2221 -- That is, if "foo:bar:baz" is used, this interpreted as
2222 -- consisting of three entries, 'foo', 'bar', 'baz'.
2223 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2224 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2226 -- Notice that no attempt is made to fully replace the 'standard'
2227 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2228 -- that this will cause too much breakage for users & ':' will
2229 -- work fine even with DOS paths, if you're not insisting on being silly.
2232 splitUp (x:':':div:xs) | div `elem` dir_markers
2233 = ((x:':':div:p): splitUp rs)
2235 (p,rs) = findNextPath xs
2236 -- we used to check for existence of the path here, but that
2237 -- required the IO monad to be threaded through the command-line
2238 -- parser which is quite inconvenient. The
2239 splitUp xs = cons p (splitUp rs)
2241 (p,rs) = findNextPath xs
2246 -- will be called either when we've consumed nought or the
2247 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2248 -- finding the next split marker.
2250 case break (`elem` split_markers) xs of
2251 (p, _:ds) -> (p, ds)
2254 split_markers :: [Char]
2255 split_markers = [':', ';']
2257 dir_markers :: [Char]
2258 dir_markers = ['/', '\\']
2261 -- -----------------------------------------------------------------------------
2262 -- tmpDir, where we store temporary files.
2264 setTmpDir :: FilePath -> DynFlags -> DynFlags
2265 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2266 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2267 -- seem necessary now --SDM 7/2/2008
2269 -----------------------------------------------------------------------------
2272 setRtsOpts :: String -> DynP ()
2273 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2275 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2276 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2278 -----------------------------------------------------------------------------
2281 setOptHpcDir :: String -> DynP ()
2282 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2284 -----------------------------------------------------------------------------
2285 -- Via-C compilation stuff
2287 -- There are some options that we need to pass to gcc when compiling
2288 -- Haskell code via C, but are only supported by recent versions of
2289 -- gcc. The configure script decides which of these options we need,
2290 -- and puts them in the "settings" file in $topdir. The advantage of
2291 -- having these in a separate file is that the file can be created at
2292 -- install-time depending on the available gcc version, and even
2293 -- re-generated later if gcc is upgraded.
2295 -- The options below are not dependent on the version of gcc, only the
2298 picCCOpts :: DynFlags -> [String]
2300 #if darwin_TARGET_OS
2301 -- Apple prefers to do things the other way round.
2302 -- PIC is on by default.
2303 -- -mdynamic-no-pic:
2304 -- Turn off PIC code generation.
2306 -- Don't generate "common" symbols - these are unwanted
2307 -- in dynamic libraries.
2310 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2312 = ["-mdynamic-no-pic"]
2313 #elif mingw32_TARGET_OS
2314 -- no -fPIC for Windows
2316 = ["-U __PIC__","-D__PIC__"]
2320 -- we need -fPIC for C files when we are compiling with -dynamic,
2321 -- otherwise things like stub.c files don't get compiled
2322 -- correctly. They need to reference data in the Haskell
2323 -- objects, but can't without -fPIC. See
2324 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2325 | opt_PIC || not opt_Static
2326 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2331 -- -----------------------------------------------------------------------------
2335 can_split = cSupportsSplitObjs == "YES"
2337 -- -----------------------------------------------------------------------------
2340 compilerInfo :: DynFlags -> [(String, String)]
2342 = -- We always make "Project name" be first to keep parsing in
2343 -- other languages simple, i.e. when looking for other fields,
2344 -- you don't have to worry whether there is a leading '[' or not
2345 ("Project name", cProjectName)
2346 -- Next come the settings, so anything else can be overridden
2347 -- in the settings file (as "lookup" uses the first match for the
2349 : rawSettings dflags
2350 ++ [("Project version", cProjectVersion),
2351 ("Booter version", cBooterVersion),
2353 ("Build platform", cBuildPlatformString),
2354 ("Host platform", cHostPlatformString),
2355 ("Target platform", cTargetPlatformString),
2356 ("Have interpreter", cGhcWithInterpreter),
2357 ("Object splitting supported", cSupportsSplitObjs),
2358 ("Have native code generator", cGhcWithNativeCodeGen),
2359 ("Support SMP", cGhcWithSMP),
2360 ("Unregisterised", cGhcUnregisterised),
2361 ("Tables next to code", cGhcEnableTablesNextToCode),
2362 ("RTS ways", cGhcRTSWays),
2363 ("Leading underscore", cLeadingUnderscore),
2364 ("Debug on", show debugIsOn),
2365 ("LibDir", topDir dflags),
2366 ("Global Package DB", systemPackageConfig dflags),
2367 ("Gcc Linker flags", show cGccLinkerOpts),
2368 ("Ld Linker flags", show cLdLinkerOpts)