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 | HscJava -- ^ Generate Java bytecode.
656 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
657 | HscNothing -- ^ Don't generate any code. See notes above.
660 showHscTargetFlag :: HscTarget -> String
661 showHscTargetFlag HscC = "-fvia-c"
662 showHscTargetFlag HscAsm = "-fasm"
663 showHscTargetFlag HscLlvm = "-fllvm"
664 showHscTargetFlag HscJava = panic "No flag for HscJava"
665 showHscTargetFlag HscInterpreted = "-fbyte-code"
666 showHscTargetFlag HscNothing = "-fno-code"
668 -- | Will this target result in an object file on the disk?
669 isObjectTarget :: HscTarget -> Bool
670 isObjectTarget HscC = True
671 isObjectTarget HscAsm = True
672 isObjectTarget HscLlvm = True
673 isObjectTarget _ = False
675 -- | The 'GhcMode' tells us whether we're doing multi-module
676 -- compilation (controlled via the "GHC" API) or one-shot
677 -- (single-module) compilation. This makes a difference primarily to
678 -- the "Finder": in one-shot mode we look for interface files for
679 -- imported modules, but in multi-module mode we look for source files
680 -- in order to check whether they need to be recompiled.
682 = CompManager -- ^ @\-\-make@, GHCi, etc.
683 | OneShot -- ^ @ghc -c Foo.hs@
684 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
687 instance Outputable GhcMode where
688 ppr CompManager = ptext (sLit "CompManager")
689 ppr OneShot = ptext (sLit "OneShot")
690 ppr MkDepend = ptext (sLit "MkDepend")
692 isOneShot :: GhcMode -> Bool
693 isOneShot OneShot = True
694 isOneShot _other = False
696 -- | What to do in the link step, if there is one.
698 = NoLink -- ^ Don't link at all
699 | LinkBinary -- ^ Link object code into a binary
700 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
701 -- bytecode and object code).
702 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
705 isNoLink :: GhcLink -> Bool
706 isNoLink NoLink = True
709 -- Is it worth evaluating this Bool and caching it in the DynFlags value
710 -- during initDynFlags?
711 doingTickyProfiling :: DynFlags -> Bool
712 doingTickyProfiling _ = opt_Ticky
713 -- XXX -ticky is a static flag, because it implies -debug which is also
714 -- static. If the way flags were made dynamic, we could fix this.
717 = ExposePackage String
718 | ExposePackageId String
720 | IgnorePackage String
723 defaultHscTarget :: HscTarget
724 defaultHscTarget = defaultObjectTarget
726 -- | The 'HscTarget' value corresponding to the default way to create
727 -- object files on the current platform.
728 defaultObjectTarget :: HscTarget
730 | cGhcUnregisterised == "YES" = HscC
731 | cGhcWithNativeCodeGen == "YES" = HscAsm
732 | otherwise = HscLlvm
739 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
742 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
743 initDynFlags :: DynFlags -> IO DynFlags
744 initDynFlags dflags = do
745 -- someday these will be dynamic flags
746 ways <- readIORef v_Ways
747 refFilesToClean <- newIORef []
748 refDirsToClean <- newIORef Map.empty
749 refGeneratedDumps <- newIORef Set.empty
752 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
753 rtsBuildTag = mkBuildTag ways,
754 filesToClean = refFilesToClean,
755 dirsToClean = refDirsToClean,
756 generatedDumps = refGeneratedDumps
759 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
760 -- and must be fully initialized by 'GHC.newSession' first.
761 defaultDynFlags :: Settings -> DynFlags
762 defaultDynFlags mySettings =
764 ghcMode = CompManager,
765 ghcLink = LinkBinary,
766 hscTarget = defaultHscTarget,
772 maxSimplIterations = 4,
773 shouldDumpSimplPhase = Nothing,
775 specConstrThreshold = Just 2000,
776 specConstrCount = Just 3,
777 liberateCaseThreshold = Just 2000,
778 floatLamArgs = Just 0, -- Default: float only if no fvs
779 strictnessBefore = [],
781 targetPlatform = defaultTargetPlatform,
782 cmdlineHcIncludes = [],
786 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
788 dphBackend = DPHNone,
790 thisPackage = mainPackageId,
793 dylibInstallName = Nothing,
797 objectSuf = phaseInputExt StopLn,
798 hcSuf = phaseInputExt HCc,
801 outputFile = Nothing,
803 dynLibLoader = SystemDependent,
804 dumpPrefix = Nothing,
805 dumpPrefixForce = Nothing,
809 cmdlineFrameworks = [],
811 rtsOptsEnabled = RtsOptsSafeOnly,
817 pkgDatabase = Nothing,
818 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
819 ways = panic "defaultDynFlags: No ways",
820 buildTag = panic "defaultDynFlags: No buildTag",
821 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
823 settings = mySettings,
825 depMakefile = "Makefile",
826 depIncludePkgDeps = False,
829 -- end of ghc -M values
830 filesToClean = panic "defaultDynFlags: No filesToClean",
831 dirsToClean = panic "defaultDynFlags: No dirsToClean",
832 generatedDumps = panic "defaultDynFlags: No generatedDumps",
833 haddockOptions = Nothing,
834 flags = defaultFlags,
837 extensionFlags = flattenExtensionFlags Nothing [],
839 log_action = \severity srcSpan style msg ->
841 SevOutput -> printSDoc msg style
842 SevInfo -> printErrs msg style
843 SevFatal -> printErrs msg style
846 printErrs (mkLocMessage srcSpan msg) style
847 -- careful (#2302): printErrs prints in UTF-8, whereas
848 -- converting to string first and using hPutStr would
849 -- just emit the low 8 bits of each unicode char.
853 Note [Verbosity levels]
854 ~~~~~~~~~~~~~~~~~~~~~~~
855 0 | print errors & warnings only
856 1 | minimal verbosity: print "compiling M ... done." for each module.
857 2 | equivalent to -dshow-passes
858 3 | equivalent to existing "ghc -v"
859 4 | "ghc -v -ddump-most"
860 5 | "ghc -v -ddump-all"
866 -- OnOffs accumulate in reverse order, so we use foldr in order to
867 -- process them in the right order
868 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
870 flattenExtensionFlags ml = foldr f defaultExtensionFlags
871 where f (On f) flags = f : delete f flags
872 f (Off f) flags = delete f flags
873 defaultExtensionFlags = languageExtensions ml
875 languageExtensions :: Maybe Language -> [ExtensionFlag]
877 languageExtensions Nothing
878 -- Nothing => the default case
879 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
880 -- behaviour the default, to see if anyone notices
882 -- In due course I'd like Opt_MonoLocalBinds to be on by default
883 -- But NB it's implied by GADTs etc
884 -- SLPJ September 2010
885 : Opt_NondecreasingIndentation -- This has been on by default for some time
886 : delete Opt_DatatypeContexts -- The Haskell' committee decided to
887 -- remove datatype contexts from the
889 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
890 (languageExtensions (Just Haskell2010))
892 languageExtensions (Just Haskell98)
893 = [Opt_ImplicitPrelude,
894 Opt_MonomorphismRestriction,
896 Opt_DatatypeContexts,
897 Opt_NondecreasingIndentation
898 -- strictly speaking non-standard, but we always had this
899 -- on implicitly before the option was added in 7.1, and
900 -- turning it off breaks code, so we're keeping it on for
901 -- backwards compatibility. Cabal uses -XHaskell98 by
902 -- default unless you specify another language.
905 languageExtensions (Just Haskell2010)
906 = [Opt_ImplicitPrelude,
907 Opt_MonomorphismRestriction,
908 Opt_DatatypeContexts,
910 Opt_ForeignFunctionInterface,
915 -- | Test whether a 'DynFlag' is set
916 dopt :: DynFlag -> DynFlags -> Bool
917 dopt f dflags = f `elem` (flags dflags)
920 dopt_set :: DynFlags -> DynFlag -> DynFlags
921 dopt_set dfs f = dfs{ flags = f : flags dfs }
923 -- | Unset a 'DynFlag'
924 dopt_unset :: DynFlags -> DynFlag -> DynFlags
925 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
927 -- | Test whether a 'ExtensionFlag' is set
928 xopt :: ExtensionFlag -> DynFlags -> Bool
929 xopt f dflags = f `elem` extensionFlags dflags
931 -- | Set a 'ExtensionFlag'
932 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
934 = let onoffs = On f : extensions dfs
935 in dfs { extensions = onoffs,
936 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
938 -- | Unset a 'ExtensionFlag'
939 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
941 = let onoffs = Off f : extensions dfs
942 in dfs { extensions = onoffs,
943 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
945 setLanguage :: Language -> DynP ()
946 setLanguage l = upd f
947 where f dfs = let mLang = Just l
948 oneoffs = extensions dfs
951 extensionFlags = flattenExtensionFlags mLang oneoffs
954 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
955 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
956 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
957 -> [a] -- ^ Correctly ordered extracted options
958 getOpts dflags opts = reverse (opts dflags)
959 -- We add to the options from the front, so we need to reverse the list
961 -- | Gets the verbosity flag for the current verbosity level. This is fed to
962 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
963 getVerbFlags :: DynFlags -> [String]
965 | verbosity dflags >= 4 = ["-v"]
968 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
969 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
970 setPgmP, addOptl, addOptP,
971 addCmdlineFramework, addHaddockOpts
972 :: String -> DynFlags -> DynFlags
973 setOutputFile, setOutputHi, setDumpPrefixForce
974 :: Maybe String -> DynFlags -> DynFlags
976 setObjectDir f d = d{ objectDir = Just f}
977 setHiDir f d = d{ hiDir = Just f}
978 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
979 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
980 -- \#included from the .hc file when compiling via C (i.e. unregisterised
982 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
983 setDylibInstallName f d = d{ dylibInstallName = Just f}
985 setObjectSuf f d = d{ objectSuf = f}
986 setHiSuf f d = d{ hiSuf = f}
987 setHcSuf f d = d{ hcSuf = f}
989 setOutputFile f d = d{ outputFile = f}
990 setOutputHi f d = d{ outputHi = f}
992 parseDynLibLoaderMode f d =
994 ("deploy", "") -> d{ dynLibLoader = Deployable }
995 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
996 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
998 setDumpPrefixForce f d = d { dumpPrefixForce = f}
1000 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
1001 -- Config.hs should really use Option.
1002 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
1003 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
1004 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
1007 setDepMakefile :: FilePath -> DynFlags -> DynFlags
1008 setDepMakefile f d = d { depMakefile = deOptDep f }
1010 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1011 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1013 addDepExcludeMod :: String -> DynFlags -> DynFlags
1014 addDepExcludeMod m d
1015 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1017 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1018 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1021 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1022 -- we need to strip the "-optdep" off of the arg
1023 deOptDep :: String -> String
1024 deOptDep x = case stripPrefix "-optdep" x of
1028 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1030 addHaddockOpts f d = d{ haddockOptions = Just f}
1032 -- -----------------------------------------------------------------------------
1033 -- Command-line options
1035 -- | When invoking external tools as part of the compilation pipeline, we
1036 -- pass these a sequence of options on the command-line. Rather than
1037 -- just using a list of Strings, we use a type that allows us to distinguish
1038 -- between filepaths and 'other stuff'. The reason for this is that
1039 -- this type gives us a handle on transforming filenames, and filenames only,
1040 -- to whatever format they're expected to be on a particular platform.
1042 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1043 String -- a non-filepath prefix that shouldn't be
1044 -- transformed (e.g., "/out=")
1045 String -- the filepath/filename portion
1048 showOpt :: Option -> String
1049 showOpt (FileOption pre f) = pre ++ f
1050 showOpt (Option s) = s
1052 -----------------------------------------------------------------------------
1053 -- Setting the optimisation level
1055 updOptLevel :: Int -> DynFlags -> DynFlags
1056 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1058 = dfs2{ optLevel = final_n }
1060 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1061 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1062 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1064 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1065 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1067 -- -----------------------------------------------------------------------------
1068 -- StgToDo: abstraction of stg-to-stg passes to run.
1071 = StgDoMassageForProfiling -- should be (next to) last
1072 -- There's also setStgVarInfo, but its absolute "lastness"
1073 -- is so critical that it is hardwired in (no flag).
1076 getStgToDo :: DynFlags -> [StgToDo]
1080 stg_stats = dopt Opt_StgStats dflags
1082 todo1 = if stg_stats then [D_stg_stats] else []
1084 todo2 | WayProf `elem` wayNames dflags
1085 = StgDoMassageForProfiling : todo1
1089 {- **********************************************************************
1093 %********************************************************************* -}
1095 -- -----------------------------------------------------------------------------
1096 -- Parsing the dynamic flags.
1098 -- | Parse dynamic flags from a list of command line arguments. Returns the
1099 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1100 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1101 -- flags or missing arguments).
1102 parseDynamicFlags :: Monad m =>
1103 DynFlags -> [Located String]
1104 -> m (DynFlags, [Located String], [Located String])
1105 -- ^ Updated 'DynFlags', left-over arguments, and
1106 -- list of warnings.
1107 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1109 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1110 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1111 parseDynamicNoPackageFlags :: Monad m =>
1112 DynFlags -> [Located String]
1113 -> m (DynFlags, [Located String], [Located String])
1114 -- ^ Updated 'DynFlags', left-over arguments, and
1115 -- list of warnings.
1116 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1118 parseDynamicFlags_ :: Monad m =>
1119 DynFlags -> [Located String] -> Bool
1120 -> m (DynFlags, [Located String], [Located String])
1121 parseDynamicFlags_ dflags0 args pkg_flags = do
1122 -- XXX Legacy support code
1123 -- We used to accept things like
1124 -- optdep-f -optdepdepend
1125 -- optdep-f -optdep depend
1126 -- optdep -f -optdepdepend
1127 -- optdep -f -optdep depend
1128 -- but the spaces trip up proper argument handling. So get rid of them.
1129 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1130 f (x : xs) = x : f xs
1134 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1135 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1136 | otherwise = dynamic_flags
1138 let ((leftover, errs, warns), dflags1)
1139 = runCmdLine (processArgs flag_spec args') dflags0
1140 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1142 return (dflags1, leftover, warns)
1145 {- **********************************************************************
1147 DynFlags specifications
1149 %********************************************************************* -}
1151 allFlags :: [String]
1152 allFlags = map ('-':) $
1153 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1154 map ("fno-"++) flags ++
1155 map ("f"++) flags ++
1156 map ("f"++) flags' ++
1157 map ("X"++) supportedExtensions
1158 where ok (PrefixPred _ _) = False
1160 flags = [ name | (name, _, _) <- fFlags ]
1161 flags' = [ name | (name, _, _) <- fLangFlags ]
1163 --------------- The main flags themselves ------------------
1164 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1166 Flag "n" (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
1167 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1168 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1170 (HasArg (\s -> do { addCmdlineHCInclude s
1171 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1172 , Flag "v" (OptIntSuffix setVerbosity)
1174 ------- Specific phases --------------------------------------------
1175 -- need to appear before -pgmL to be parsed as LLVM flags.
1176 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1177 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1178 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1179 , Flag "pgmP" (hasArg setPgmP)
1180 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1181 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1182 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1183 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1184 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1185 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1186 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1187 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1189 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1190 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1191 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1192 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1193 , Flag "optP" (hasArg addOptP)
1194 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1195 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1196 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1197 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1198 , Flag "optl" (hasArg addOptl)
1199 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1202 (NoArg (if can_split
1203 then setDynFlag Opt_SplitObjs
1204 else addWarn "ignoring -fsplit-objs"))
1206 -------- ghc -M -----------------------------------------------------
1207 , Flag "dep-suffix" (hasArg addDepSuffix)
1208 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1209 , Flag "dep-makefile" (hasArg setDepMakefile)
1210 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1211 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1212 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1213 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1214 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1215 , Flag "exclude-module" (hasArg addDepExcludeMod)
1216 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1217 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1219 -------- Linking ----------------------------------------------------
1220 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1221 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1222 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1223 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1225 ------- Libraries ---------------------------------------------------
1226 , Flag "L" (Prefix addLibraryPath)
1227 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1229 ------- Frameworks --------------------------------------------------
1230 -- -framework-path should really be -F ...
1231 , Flag "framework-path" (HasArg addFrameworkPath)
1232 , Flag "framework" (hasArg addCmdlineFramework)
1234 ------- Output Redirection ------------------------------------------
1235 , Flag "odir" (hasArg setObjectDir)
1236 , Flag "o" (SepArg (upd . setOutputFile . Just))
1237 , Flag "ohi" (hasArg (setOutputHi . Just ))
1238 , Flag "osuf" (hasArg setObjectSuf)
1239 , Flag "hcsuf" (hasArg setHcSuf)
1240 , Flag "hisuf" (hasArg setHiSuf)
1241 , Flag "hidir" (hasArg setHiDir)
1242 , Flag "tmpdir" (hasArg setTmpDir)
1243 , Flag "stubdir" (hasArg setStubDir)
1244 , Flag "outputdir" (hasArg setOutputDir)
1245 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1247 ------- Keeping temporary files -------------------------------------
1248 -- These can be singular (think ghc -c) or plural (think ghc --make)
1249 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1250 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1251 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1252 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1253 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1254 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1255 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1256 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1257 -- This only makes sense as plural
1258 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1260 ------- Miscellaneous ----------------------------------------------
1261 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1262 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1263 , Flag "with-rtsopts" (HasArg setRtsOpts)
1264 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1265 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1266 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1267 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1268 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1269 , Flag "main-is" (SepArg setMainIs)
1270 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1271 , Flag "haddock-opts" (hasArg addHaddockOpts)
1272 , Flag "hpcdir" (SepArg setOptHpcDir)
1274 ------- recompilation checker --------------------------------------
1275 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1276 ; deprecate "Use -fno-force-recomp instead" }))
1277 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1278 ; deprecate "Use -fforce-recomp instead" }))
1280 ------ HsCpp opts ---------------------------------------------------
1281 , Flag "D" (AnySuffix (upd . addOptP))
1282 , Flag "U" (AnySuffix (upd . addOptP))
1284 ------- Include/Import Paths ----------------------------------------
1285 , Flag "I" (Prefix addIncludePath)
1286 , Flag "i" (OptPrefix addImportPath)
1288 ------ Debugging ----------------------------------------------------
1289 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1291 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1292 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1293 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1294 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1295 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1296 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1297 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1298 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1299 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1300 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1301 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1302 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1303 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1304 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1305 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1306 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1307 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1308 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1309 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1310 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1311 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1312 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1313 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1314 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1315 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1316 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1317 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1318 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1319 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1320 ; setDumpFlag' Opt_D_dump_llvm}))
1321 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1322 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1323 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1324 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1325 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1326 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1327 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1328 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1329 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1330 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1331 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1332 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1333 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1334 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1335 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1336 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1337 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1338 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1339 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1340 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1341 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1342 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1343 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1344 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1345 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1346 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1347 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1348 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1349 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1350 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1351 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1352 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1353 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1354 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1355 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1356 ; setVerboseCore2Core }))
1357 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1358 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1359 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1360 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1361 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1362 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1363 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1364 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1365 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1366 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1367 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1368 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1369 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1370 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1371 , Flag "dshow-passes" (NoArg (do forceRecompile
1372 setVerbosity (Just 2)))
1373 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1375 ------ Coq-in-GHC ---------------------------
1376 , Flag "ddump-proofs" (NoArg (setDynFlag Opt_D_dump_proofs))
1377 , Flag "ddump-coqpass" (NoArg (setDynFlag Opt_D_coqpass))
1378 , Flag "fcoqpass" (NoArg (setDynFlag Opt_F_coqpass))
1379 , Flag "fsimpleopt-before-flatten" (NoArg (setDynFlag Opt_F_simpleopt_before_flatten))
1380 , Flag "fflatten" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten }))
1381 , Flag "funsafe-skolemize" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten ; setDynFlag Opt_F_skolemize }))
1383 ------ Machine dependant (-m<blah>) stuff ---------------------------
1385 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1386 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1387 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1388 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1390 ------ Warning opts -------------------------------------------------
1391 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1392 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1393 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1394 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1395 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1396 ; deprecate "Use -w instead" }))
1397 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1399 ------ Optimisation flags ------------------------------------------
1400 , Flag "O" (noArgM (setOptLevel 1))
1401 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1402 setOptLevel 0 dflags))
1403 , Flag "Odph" (noArgM setDPHOpt)
1404 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1405 -- If the number is missing, use 1
1407 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1408 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1409 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1410 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1411 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1412 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1413 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1414 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1415 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1416 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1417 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1418 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1419 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1421 ------ Profiling ----------------------------------------------------
1423 -- XXX Should the -f* flags be deprecated?
1424 -- They don't seem to be documented
1425 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1426 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1427 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1428 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1429 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1430 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1431 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1432 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1433 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1435 ------ DPH flags ----------------------------------------------------
1437 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1438 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1439 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1440 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1442 ------ Compiler flags -----------------------------------------------
1444 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1445 , Flag "fvia-c" (NoArg
1446 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1447 , Flag "fvia-C" (NoArg
1448 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1449 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1451 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1452 setTarget HscNothing))
1453 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1454 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1455 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1456 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1458 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1459 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1460 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1461 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1462 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1463 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1464 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1466 package_flags :: [Flag (CmdLineP DynFlags)]
1468 ------- Packages ----------------------------------------------------
1469 Flag "package-conf" (HasArg extraPkgConf_)
1470 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1471 , Flag "package-name" (hasArg setPackageName)
1472 , Flag "package-id" (HasArg exposePackageId)
1473 , Flag "package" (HasArg exposePackage)
1474 , Flag "hide-package" (HasArg hidePackage)
1475 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1476 , Flag "ignore-package" (HasArg ignorePackage)
1477 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1478 ; deprecate "Use -package instead" }))
1481 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1482 -- False <=> we are turning the flag off
1483 turnOn :: TurnOnFlag; turnOn = True
1484 turnOff :: TurnOnFlag; turnOff = False
1487 = ( String -- Flag in string form
1488 , flag -- Flag in internal form
1489 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1490 -- Typically, emit a warning or error
1492 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1493 -> String -- ^ The flag prefix
1494 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1495 -> FlagSpec flag -- ^ Specification of this particular flag
1496 -> Flag (CmdLineP DynFlags)
1497 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1498 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1500 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1501 deprecatedForExtension lang turn_on
1502 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1504 flag | turn_on = lang
1505 | otherwise = "No"++lang
1507 useInstead :: String -> TurnOnFlag -> DynP ()
1508 useInstead flag turn_on
1509 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1511 no = if turn_on then "" else "no-"
1513 nop :: TurnOnFlag -> DynP ()
1516 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1517 fFlags :: [FlagSpec DynFlag]
1519 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1520 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1521 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1522 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1523 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1524 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1525 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1526 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1527 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1528 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1529 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1530 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1531 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1532 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1533 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1534 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1535 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1536 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1537 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1538 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1539 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1540 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1541 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1542 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1543 ( "warn-orphans", Opt_WarnOrphans, nop ),
1544 ( "warn-identities", Opt_WarnIdentities, nop ),
1545 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1546 ( "warn-tabs", Opt_WarnTabs, nop ),
1547 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1548 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1549 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1550 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1551 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1552 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1553 ( "strictness", Opt_Strictness, nop ),
1554 ( "specialise", Opt_Specialise, nop ),
1555 ( "float-in", Opt_FloatIn, nop ),
1556 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1557 ( "full-laziness", Opt_FullLaziness, nop ),
1558 ( "liberate-case", Opt_LiberateCase, nop ),
1559 ( "spec-constr", Opt_SpecConstr, nop ),
1560 ( "cse", Opt_CSE, nop ),
1561 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1562 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1563 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1564 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1565 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1566 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1567 ( "case-merge", Opt_CaseMerge, nop ),
1568 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1569 ( "method-sharing", Opt_MethodSharing,
1570 \_ -> deprecate "doesn't do anything any more"),
1571 -- Remove altogether in GHC 7.2
1572 ( "dicts-cheap", Opt_DictsCheap, nop ),
1573 ( "excess-precision", Opt_ExcessPrecision, nop ),
1574 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1575 ( "print-bind-result", Opt_PrintBindResult, nop ),
1576 ( "force-recomp", Opt_ForceRecomp, nop ),
1577 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1578 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1579 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1580 ( "break-on-exception", Opt_BreakOnException, nop ),
1581 ( "break-on-error", Opt_BreakOnError, nop ),
1582 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1583 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1584 ( "run-cps", Opt_RunCPS, nop ),
1585 ( "run-cpsz", Opt_RunCPSZ, nop ),
1586 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1587 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1588 ( "vectorise", Opt_Vectorise, nop ),
1589 ( "regs-graph", Opt_RegsGraph, nop ),
1590 ( "regs-iterative", Opt_RegsIterative, nop ),
1591 ( "gen-manifest", Opt_GenManifest, nop ),
1592 ( "embed-manifest", Opt_EmbedManifest, nop ),
1593 ( "ext-core", Opt_EmitExternalCore, nop ),
1594 ( "shared-implib", Opt_SharedImplib, nop ),
1595 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1596 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1597 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1598 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1601 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1602 fLangFlags :: [FlagSpec ExtensionFlag]
1604 ( "th", Opt_TemplateHaskell,
1605 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1606 ( "fi", Opt_ForeignFunctionInterface,
1607 deprecatedForExtension "ForeignFunctionInterface" ),
1608 ( "ffi", Opt_ForeignFunctionInterface,
1609 deprecatedForExtension "ForeignFunctionInterface" ),
1610 ( "arrows", Opt_Arrows,
1611 deprecatedForExtension "Arrows" ),
1612 ( "generics", Opt_Generics,
1613 deprecatedForExtension "Generics" ),
1614 ( "implicit-prelude", Opt_ImplicitPrelude,
1615 deprecatedForExtension "ImplicitPrelude" ),
1616 ( "bang-patterns", Opt_BangPatterns,
1617 deprecatedForExtension "BangPatterns" ),
1618 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1619 deprecatedForExtension "MonomorphismRestriction" ),
1620 ( "mono-pat-binds", Opt_MonoPatBinds,
1621 deprecatedForExtension "MonoPatBinds" ),
1622 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1623 deprecatedForExtension "ExtendedDefaultRules" ),
1624 ( "implicit-params", Opt_ImplicitParams,
1625 deprecatedForExtension "ImplicitParams" ),
1626 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1627 deprecatedForExtension "ScopedTypeVariables" ),
1628 ( "parr", Opt_ParallelArrays,
1629 deprecatedForExtension "ParallelArrays" ),
1630 ( "PArr", Opt_ParallelArrays,
1631 deprecatedForExtension "ParallelArrays" ),
1632 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1633 deprecatedForExtension "OverlappingInstances" ),
1634 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1635 deprecatedForExtension "UndecidableInstances" ),
1636 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1637 deprecatedForExtension "IncoherentInstances" )
1640 supportedLanguages :: [String]
1641 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1643 supportedExtensions :: [String]
1644 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1646 supportedLanguagesAndExtensions :: [String]
1647 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1649 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1650 languageFlags :: [FlagSpec Language]
1652 ( "Haskell98", Haskell98, nop ),
1653 ( "Haskell2010", Haskell2010, nop )
1656 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1657 xFlags :: [FlagSpec ExtensionFlag]
1659 ( "CPP", Opt_Cpp, nop ),
1660 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1661 ( "TupleSections", Opt_TupleSections, nop ),
1662 ( "PatternGuards", Opt_PatternGuards, nop ),
1663 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1664 ( "MagicHash", Opt_MagicHash, nop ),
1665 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1666 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1667 ( "KindSignatures", Opt_KindSignatures, nop ),
1668 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1669 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1670 ( "TransformListComp", Opt_TransformListComp, nop ),
1671 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1672 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1673 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1674 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1675 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1676 ( "Rank2Types", Opt_Rank2Types, nop ),
1677 ( "RankNTypes", Opt_RankNTypes, nop ),
1678 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1679 ( "TypeOperators", Opt_TypeOperators, nop ),
1680 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1681 deprecatedForExtension "DoRec"),
1682 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1683 ( "Arrows", Opt_Arrows, nop ),
1684 ( "ModalTypes", Opt_ModalTypes, nop ),
1685 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1686 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1687 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1688 ( "Generics", Opt_Generics,
1689 \ _ -> deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support." ),
1690 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1691 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1692 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1693 ( "RecordPuns", Opt_RecordPuns,
1694 deprecatedForExtension "NamedFieldPuns" ),
1695 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1696 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1697 ( "GADTs", Opt_GADTs, nop ),
1698 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1699 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1700 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1701 ( "BangPatterns", Opt_BangPatterns, nop ),
1702 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1703 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1704 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1705 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1706 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1707 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1708 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1709 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1710 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1711 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1712 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1713 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1714 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1715 \ turn_on -> if not turn_on
1716 then deprecate "You can't turn off RelaxedPolyRec any more"
1718 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1719 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1720 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1722 ( "PatternSignatures", Opt_ScopedTypeVariables,
1723 deprecatedForExtension "ScopedTypeVariables" ),
1725 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1726 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1727 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1728 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1729 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1730 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1731 ( "DeriveGeneric", Opt_DeriveGeneric, nop ),
1732 ( "DefaultSignatures", Opt_DefaultSignatures, nop ),
1733 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1734 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1735 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1736 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1737 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1738 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1739 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1740 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1741 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1742 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1743 ( "PackageImports", Opt_PackageImports, nop )
1746 defaultFlags :: [DynFlag]
1748 = [ Opt_AutoLinkPackages,
1749 Opt_ReadUserPackageConf,
1753 #if GHC_DEFAULT_NEW_CODEGEN
1759 Opt_PrintBindContents,
1764 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1765 -- The default -O0 options
1769 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1771 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1772 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1773 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1774 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1775 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1776 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1777 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1778 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1780 , (Opt_ModalTypes, turnOn, Opt_RankNTypes)
1781 , (Opt_ModalTypes, turnOn, Opt_ExplicitForAll)
1782 --, (Opt_ModalTypes, turnOn, Opt_RebindableSyntax)
1783 , (Opt_ModalTypes, turnOff, Opt_MonomorphismRestriction)
1785 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1787 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1788 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1789 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1791 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1792 -- all over the place
1794 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1796 -- Record wild-cards implies field disambiguation
1797 -- Otherwise if you write (C {..}) you may well get
1798 -- stuff like " 'a' not in scope ", which is a bit silly
1799 -- if the compiler has just filled in field 'a' of constructor 'C'
1800 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1802 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1805 optLevelFlags :: [([Int], DynFlag)]
1807 = [ ([0], Opt_IgnoreInterfacePragmas)
1808 , ([0], Opt_OmitInterfacePragmas)
1810 , ([1,2], Opt_IgnoreAsserts)
1811 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1813 , ([1,2], Opt_DoEtaReduction)
1814 , ([1,2], Opt_CaseMerge)
1815 , ([1,2], Opt_Strictness)
1817 , ([1,2], Opt_FullLaziness)
1818 , ([1,2], Opt_Specialise)
1819 , ([1,2], Opt_FloatIn)
1821 , ([2], Opt_LiberateCase)
1822 , ([2], Opt_SpecConstr)
1823 , ([2], Opt_RegsGraph)
1825 -- , ([2], Opt_StaticArgumentTransformation)
1826 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1827 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1828 -- several improvements to the heuristics, and I'm concerned that without
1829 -- those changes SAT will interfere with some attempts to write "high
1830 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1831 -- this year. In particular, the version in HEAD lacks the tail call
1832 -- criterion, so many things that look like reasonable loops will be
1833 -- turned into functions with extra (unneccesary) thunk creation.
1835 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1836 -- This one is important for a tiresome reason:
1837 -- we want to make sure that the bindings for data
1838 -- constructors are eta-expanded. This is probably
1839 -- a good thing anyway, but it seems fragile.
1842 -- -----------------------------------------------------------------------------
1843 -- Standard sets of warning options
1845 standardWarnings :: [DynFlag]
1847 = [ Opt_WarnWarningsDeprecations,
1848 Opt_WarnDeprecatedFlags,
1849 Opt_WarnUnrecognisedPragmas,
1850 Opt_WarnOverlappingPatterns,
1851 Opt_WarnMissingFields,
1852 Opt_WarnMissingMethods,
1853 Opt_WarnDuplicateExports,
1854 Opt_WarnLazyUnliftedBindings,
1855 Opt_WarnDodgyForeignImports,
1856 Opt_WarnWrongDoBind,
1857 Opt_WarnAlternativeLayoutRuleTransitional
1860 minusWOpts :: [DynFlag]
1861 -- Things you get with -W
1863 = standardWarnings ++
1864 [ Opt_WarnUnusedBinds,
1865 Opt_WarnUnusedMatches,
1866 Opt_WarnUnusedImports,
1867 Opt_WarnIncompletePatterns,
1868 Opt_WarnDodgyExports,
1869 Opt_WarnDodgyImports
1872 minusWallOpts :: [DynFlag]
1873 -- Things you get with -Wall
1876 [ Opt_WarnTypeDefaults,
1877 Opt_WarnNameShadowing,
1878 Opt_WarnMissingSigs,
1881 Opt_WarnUnusedDoBind
1884 minuswRemovesOpts :: [DynFlag]
1885 -- minuswRemovesOpts should be every warning option
1889 Opt_WarnIncompletePatternsRecUpd,
1890 Opt_WarnIncompleteUniPatterns,
1891 Opt_WarnMonomorphism,
1892 Opt_WarnUnrecognisedPragmas,
1893 Opt_WarnAutoOrphans,
1894 Opt_WarnImplicitPrelude
1897 enableGlasgowExts :: DynP ()
1898 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1899 mapM_ setExtensionFlag glasgowExtsFlags
1901 disableGlasgowExts :: DynP ()
1902 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1903 mapM_ unSetExtensionFlag glasgowExtsFlags
1905 glasgowExtsFlags :: [ExtensionFlag]
1906 glasgowExtsFlags = [
1907 Opt_ForeignFunctionInterface
1908 , Opt_UnliftedFFITypes
1909 , Opt_ImplicitParams
1910 , Opt_ScopedTypeVariables
1912 , Opt_TypeSynonymInstances
1913 , Opt_StandaloneDeriving
1914 , Opt_DeriveDataTypeable
1916 , Opt_DeriveFoldable
1917 , Opt_DeriveTraversable
1919 , Opt_FlexibleContexts
1920 , Opt_FlexibleInstances
1921 , Opt_ConstrainedClassMethods
1922 , Opt_MultiParamTypeClasses
1923 , Opt_FunctionalDependencies
1925 , Opt_PolymorphicComponents
1926 , Opt_ExistentialQuantification
1928 , Opt_PostfixOperators
1930 , Opt_LiberalTypeSynonyms
1934 , Opt_ParallelListComp
1935 , Opt_EmptyDataDecls
1936 , Opt_KindSignatures
1937 , Opt_GeneralizedNewtypeDeriving ]
1940 -- Consult the RTS to find whether GHC itself has been built profiled
1941 -- If so, you can't use Template Haskell
1942 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1944 rtsIsProfiled :: Bool
1945 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1948 checkTemplateHaskellOk :: Bool -> DynP ()
1950 checkTemplateHaskellOk turn_on
1951 | turn_on && rtsIsProfiled
1952 = addErr "You can't use Template Haskell with a profiled compiler"
1956 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1957 -- so we simply say "ok". It doesn't matter because TH isn't
1958 -- available in stage 1 anyway.
1959 checkTemplateHaskellOk _ = return ()
1962 {- **********************************************************************
1964 DynFlags constructors
1966 %********************************************************************* -}
1968 type DynP = EwM (CmdLineP DynFlags)
1970 upd :: (DynFlags -> DynFlags) -> DynP ()
1971 upd f = liftEwM (do dflags <- getCmdLineState
1972 putCmdLineState $! f dflags)
1974 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1975 updM f = do dflags <- liftEwM getCmdLineState
1977 liftEwM $ putCmdLineState $! dflags'
1979 --------------- Constructor functions for OptKind -----------------
1980 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1981 noArg fn = NoArg (upd fn)
1983 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1984 noArgM fn = NoArg (updM fn)
1986 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1987 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1989 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1990 hasArg fn = HasArg (upd . fn)
1992 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1993 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1994 ; deprecate deprec })
1996 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1997 intSuffix fn = IntSuffix (\n -> upd (fn n))
1999 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
2000 -> OptKind (CmdLineP DynFlags)
2001 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
2003 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
2004 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
2006 --------------------------
2007 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2008 setDynFlag f = upd (\dfs -> dopt_set dfs f)
2009 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2011 --------------------------
2012 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
2013 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
2016 deps = [ if turn_on then setExtensionFlag d
2017 else unSetExtensionFlag d
2018 | (f', turn_on, d) <- impliedFlags, f' == f ]
2019 -- When you set f, set the ones it implies
2020 -- NB: use setExtensionFlag recursively, in case the implied flags
2021 -- implies further flags
2023 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
2024 -- When you un-set f, however, we don't un-set the things it implies
2025 -- (except for -fno-glasgow-exts, which is treated specially)
2027 --------------------------
2028 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2029 alterSettings f dflags = dflags { settings = f (settings dflags) }
2031 --------------------------
2032 setDumpFlag' :: DynFlag -> DynP ()
2033 setDumpFlag' dump_flag
2034 = do { setDynFlag dump_flag
2035 ; when want_recomp forceRecompile }
2037 -- Certain dumpy-things are really interested in what's going
2038 -- on during recompilation checking, so in those cases we
2039 -- don't want to turn it off.
2040 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2041 Opt_D_dump_hi_diffs]
2043 forceRecompile :: DynP ()
2044 -- Whenver we -ddump, force recompilation (by switching off the
2045 -- recompilation checker), else you don't see the dump! However,
2046 -- don't switch it off in --make mode, else *everything* gets
2047 -- recompiled which probably isn't what you want
2048 forceRecompile = do { dfs <- liftEwM getCmdLineState
2049 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2051 force_recomp dfs = isOneShot (ghcMode dfs)
2053 setVerboseCore2Core :: DynP ()
2054 setVerboseCore2Core = do forceRecompile
2055 setDynFlag Opt_D_verbose_core2core
2056 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2058 setDumpSimplPhases :: String -> DynP ()
2059 setDumpSimplPhases s = do forceRecompile
2060 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2062 spec = case s of { ('=' : s') -> s'; _ -> s }
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 -fllvm, which switch from one to the other, but
2097 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2098 -- can be safely used in an OPTIONS_GHC pragma.
2099 setObjTarget :: HscTarget -> DynP ()
2100 setObjTarget l = updM set
2103 | isObjectTarget (hscTarget dflags)
2106 | cGhcUnregisterised /= "YES" ->
2107 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2110 | cGhcWithNativeCodeGen /= "YES" ->
2111 do addWarn ("Compiler has no native codegen, so ignoring " ++
2115 | cGhcUnregisterised == "YES" ->
2116 do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2118 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2119 (not opt_Static || opt_PIC)
2121 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2123 _ -> return $ dflags { hscTarget = l }
2124 | otherwise = return dflags
2125 where platform = targetPlatform dflags
2126 arch = platformArch platform
2127 os = platformOS platform
2128 flag = showHscTargetFlag l
2130 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2131 setOptLevel n dflags
2132 | hscTarget dflags == HscInterpreted && n > 0
2133 = do addWarn "-O conflicts with --interactive; -O ignored."
2136 = return (updOptLevel n dflags)
2139 -- -Odph is equivalent to
2141 -- -O2 optimise as much as possible
2142 -- -fmax-simplifier-iterations20 this is necessary sometimes
2143 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2145 setDPHOpt :: DynFlags -> DynP DynFlags
2146 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2150 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2151 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2152 -- vectoriser cannot be used.
2154 data DPHBackend = DPHPar -- "dph-par"
2155 | DPHSeq -- "dph-seq"
2156 | DPHThis -- the currently compiled package
2157 | DPHNone -- no DPH library available
2158 deriving(Eq, Ord, Enum, Show)
2160 setDPHBackend :: DPHBackend -> DynP ()
2161 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2163 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2165 dphPackageMaybe :: DynFlags -> Maybe PackageId
2166 dphPackageMaybe dflags
2167 = case dphBackend dflags of
2168 DPHPar -> Just dphParPackageId
2169 DPHSeq -> Just dphSeqPackageId
2170 DPHThis -> Just (thisPackage dflags)
2173 setMainIs :: String -> DynP ()
2175 | not (null main_fn) && isLower (head main_fn)
2176 -- The arg looked like "Foo.Bar.baz"
2177 = upd $ \d -> d{ mainFunIs = Just main_fn,
2178 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2180 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2181 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2183 | otherwise -- The arg looked like "baz"
2184 = upd $ \d -> d{ mainFunIs = Just arg }
2186 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2188 -----------------------------------------------------------------------------
2189 -- Paths & Libraries
2191 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2193 -- -i on its own deletes the import paths
2194 addImportPath "" = upd (\s -> s{importPaths = []})
2195 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2198 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2201 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2203 addFrameworkPath p =
2204 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2206 #ifndef mingw32_TARGET_OS
2207 split_marker :: Char
2208 split_marker = ':' -- not configurable (ToDo)
2211 splitPathList :: String -> [String]
2212 splitPathList s = filter notNull (splitUp s)
2213 -- empty paths are ignored: there might be a trailing
2214 -- ':' in the initial list, for example. Empty paths can
2215 -- cause confusion when they are translated into -I options
2216 -- for passing to gcc.
2218 #ifndef mingw32_TARGET_OS
2219 splitUp xs = split split_marker xs
2221 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2223 -- That is, if "foo:bar:baz" is used, this interpreted as
2224 -- consisting of three entries, 'foo', 'bar', 'baz'.
2225 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2226 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2228 -- Notice that no attempt is made to fully replace the 'standard'
2229 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2230 -- that this will cause too much breakage for users & ':' will
2231 -- work fine even with DOS paths, if you're not insisting on being silly.
2234 splitUp (x:':':div:xs) | div `elem` dir_markers
2235 = ((x:':':div:p): splitUp rs)
2237 (p,rs) = findNextPath xs
2238 -- we used to check for existence of the path here, but that
2239 -- required the IO monad to be threaded through the command-line
2240 -- parser which is quite inconvenient. The
2241 splitUp xs = cons p (splitUp rs)
2243 (p,rs) = findNextPath xs
2248 -- will be called either when we've consumed nought or the
2249 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2250 -- finding the next split marker.
2252 case break (`elem` split_markers) xs of
2253 (p, _:ds) -> (p, ds)
2256 split_markers :: [Char]
2257 split_markers = [':', ';']
2259 dir_markers :: [Char]
2260 dir_markers = ['/', '\\']
2263 -- -----------------------------------------------------------------------------
2264 -- tmpDir, where we store temporary files.
2266 setTmpDir :: FilePath -> DynFlags -> DynFlags
2267 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2268 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2269 -- seem necessary now --SDM 7/2/2008
2271 -----------------------------------------------------------------------------
2274 setRtsOpts :: String -> DynP ()
2275 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2277 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2278 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2280 -----------------------------------------------------------------------------
2283 setOptHpcDir :: String -> DynP ()
2284 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2286 -----------------------------------------------------------------------------
2287 -- Via-C compilation stuff
2289 -- There are some options that we need to pass to gcc when compiling
2290 -- Haskell code via C, but are only supported by recent versions of
2291 -- gcc. The configure script decides which of these options we need,
2292 -- and puts them in the "settings" file in $topdir. The advantage of
2293 -- having these in a separate file is that the file can be created at
2294 -- install-time depending on the available gcc version, and even
2295 -- re-generated later if gcc is upgraded.
2297 -- The options below are not dependent on the version of gcc, only the
2300 picCCOpts :: DynFlags -> [String]
2302 #if darwin_TARGET_OS
2303 -- Apple prefers to do things the other way round.
2304 -- PIC is on by default.
2305 -- -mdynamic-no-pic:
2306 -- Turn off PIC code generation.
2308 -- Don't generate "common" symbols - these are unwanted
2309 -- in dynamic libraries.
2312 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2314 = ["-mdynamic-no-pic"]
2315 #elif mingw32_TARGET_OS
2316 -- no -fPIC for Windows
2318 = ["-U __PIC__","-D__PIC__"]
2322 -- we need -fPIC for C files when we are compiling with -dynamic,
2323 -- otherwise things like stub.c files don't get compiled
2324 -- correctly. They need to reference data in the Haskell
2325 -- objects, but can't without -fPIC. See
2326 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2327 | opt_PIC || not opt_Static
2328 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2333 -- -----------------------------------------------------------------------------
2337 can_split = cSupportsSplitObjs == "YES"
2339 -- -----------------------------------------------------------------------------
2342 compilerInfo :: DynFlags -> [(String, String)]
2344 = -- We always make "Project name" be first to keep parsing in
2345 -- other languages simple, i.e. when looking for other fields,
2346 -- you don't have to worry whether there is a leading '[' or not
2347 ("Project name", cProjectName)
2348 -- Next come the settings, so anything else can be overridden
2349 -- in the settings file (as "lookup" uses the first match for the
2351 : rawSettings dflags
2352 ++ [("Project version", cProjectVersion),
2353 ("Booter version", cBooterVersion),
2355 ("Build platform", cBuildPlatformString),
2356 ("Host platform", cHostPlatformString),
2357 ("Target platform", cTargetPlatformString),
2358 ("Have interpreter", cGhcWithInterpreter),
2359 ("Object splitting supported", cSupportsSplitObjs),
2360 ("Have native code generator", cGhcWithNativeCodeGen),
2361 ("Support SMP", cGhcWithSMP),
2362 ("Unregisterised", cGhcUnregisterised),
2363 ("Tables next to code", cGhcEnableTablesNextToCode),
2364 ("RTS ways", cGhcRTSWays),
2365 ("Leading underscore", cLeadingUnderscore),
2366 ("Debug on", show debugIsOn),
2367 ("LibDir", topDir dflags),
2368 ("Global Package DB", systemPackageConfig dflags),
2369 ("Gcc Linker flags", show cGccLinkerOpts),
2370 ("Ld Linker flags", show cLdLinkerOpts)