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_WarnIsError -- -Werror; makes warnings fatal
208 | Opt_WarnDuplicateExports
210 | Opt_WarnImplicitPrelude
211 | Opt_WarnIncompletePatterns
212 | Opt_WarnIncompleteUniPatterns
213 | Opt_WarnIncompletePatternsRecUpd
214 | Opt_WarnMissingFields
215 | Opt_WarnMissingImportList
216 | Opt_WarnMissingMethods
217 | Opt_WarnMissingSigs
218 | Opt_WarnMissingLocalSigs
219 | Opt_WarnNameShadowing
220 | Opt_WarnOverlappingPatterns
221 | Opt_WarnTypeDefaults
222 | Opt_WarnMonomorphism
223 | Opt_WarnUnusedBinds
224 | Opt_WarnUnusedImports
225 | Opt_WarnUnusedMatches
226 | Opt_WarnWarningsDeprecations
227 | Opt_WarnDeprecatedFlags
228 | Opt_WarnDodgyExports
229 | Opt_WarnDodgyImports
231 | Opt_WarnAutoOrphans
234 | Opt_WarnUnrecognisedPragmas
235 | Opt_WarnDodgyForeignImports
236 | Opt_WarnLazyUnliftedBindings
237 | Opt_WarnUnusedDoBind
238 | Opt_WarnWrongDoBind
239 | Opt_WarnAlternativeLayoutRuleTransitional
241 | Opt_PrintExplicitForalls
248 | Opt_StaticArgumentTransformation
252 | Opt_DoLambdaEtaExpansion
256 | Opt_UnboxStrictFields
257 | Opt_MethodSharing -- Now a no-op; remove in GHC 7.2
259 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
261 | Opt_RegsGraph -- do graph coloring register allocation
262 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
265 | Opt_IgnoreInterfacePragmas
266 | Opt_OmitInterfacePragmas
267 | Opt_ExposeAllUnfoldings
270 | Opt_AutoSccsOnAllToplevs
271 | Opt_AutoSccsOnExportedToplevs
272 | Opt_AutoSccsOnIndividualCafs
278 | Opt_ExcessPrecision
279 | Opt_EagerBlackHoling
280 | Opt_ReadUserPackageConf
284 | Opt_HideAllPackages
285 | Opt_PrintBindResult
289 | Opt_BreakOnException
291 | Opt_PrintEvldWithShow
292 | Opt_PrintBindContents
295 | Opt_EmitExternalCore
297 | Opt_BuildingCabalPackage
305 | Opt_ConvertToZipCfgAndBack
306 | Opt_AutoLinkPackages
307 | Opt_ImplicitImportQualified
315 | Opt_KeepRawTokenStream
320 data Language = Haskell98 | Haskell2010
324 | Opt_OverlappingInstances
325 | Opt_UndecidableInstances
326 | Opt_IncoherentInstances
327 | Opt_MonomorphismRestriction
330 | Opt_RelaxedPolyRec -- Deprecated
331 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
332 | Opt_ForeignFunctionInterface
333 | Opt_UnliftedFFITypes
334 | Opt_GHCForeignImportPrim
335 | Opt_ParallelArrays -- Syntactic support for parallel arrays
336 | Opt_Arrows -- Arrow-notation syntax
337 | Opt_TemplateHaskell
340 | Opt_Generics -- "Derivable type classes"
341 | Opt_ImplicitPrelude
342 | Opt_ScopedTypeVariables
346 | Opt_OverloadedStrings
347 | Opt_DisambiguateRecordFields
348 | Opt_RecordWildCards
354 | Opt_DoAndIfThenElse
355 | Opt_RebindableSyntax
357 | Opt_StandaloneDeriving
358 | Opt_DeriveDataTypeable
360 | Opt_DeriveTraversable
363 | Opt_TypeSynonymInstances
364 | Opt_FlexibleContexts
365 | Opt_FlexibleInstances
366 | Opt_ConstrainedClassMethods
367 | Opt_MultiParamTypeClasses
368 | Opt_FunctionalDependencies
370 | Opt_PolymorphicComponents
371 | Opt_ExistentialQuantification
375 | Opt_ParallelListComp
376 | Opt_TransformListComp
377 | Opt_MonadComprehensions
378 | Opt_GeneralizedNewtypeDeriving
381 | Opt_PostfixOperators
384 | Opt_LiberalTypeSynonyms
387 | Opt_ImpredicativeTypes
391 | Opt_AlternativeLayoutRule
392 | Opt_AlternativeLayoutRuleTransitional
393 | Opt_DatatypeContexts
394 | Opt_NondecreasingIndentation
398 -- | Contains not only a collection of 'DynFlag's but also a plethora of
399 -- information relating to the compilation of a single file or GHC session
400 data DynFlags = DynFlags {
403 hscTarget :: HscTarget,
404 hscOutName :: String, -- ^ Name of the output file
405 extCoreName :: String, -- ^ Name of the .hcr output file
406 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
407 optLevel :: Int, -- ^ Optimisation level
408 simplPhases :: Int, -- ^ Number of simplifier phases
409 maxSimplIterations :: Int, -- ^ Max simplifier iterations
410 shouldDumpSimplPhase :: Maybe String,
411 ruleCheck :: Maybe String,
412 strictnessBefore :: [Int], -- ^ Additional demand analysis
414 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
415 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
416 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
417 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
418 -- See CoreMonad.FloatOutSwitches
420 targetPlatform :: Platform.Platform, -- ^ The platform we're compiling for. Used by the NCG.
421 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
422 importPaths :: [FilePath],
424 mainFunIs :: Maybe String,
425 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
427 dphBackend :: DPHBackend,
429 thisPackage :: PackageId, -- ^ name of package currently being compiled
432 ways :: [Way], -- ^ Way flags from the command line
433 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
434 rtsBuildTag :: String, -- ^ The RTS \"way\"
436 -- For object splitting
437 splitInfo :: Maybe (String,Int),
440 objectDir :: Maybe String,
441 dylibInstallName :: Maybe String,
442 hiDir :: Maybe String,
443 stubDir :: Maybe String,
449 outputFile :: Maybe String,
450 outputHi :: Maybe String,
451 dynLibLoader :: DynLibLoader,
453 -- | This is set by 'DriverPipeline.runPipeline' based on where
454 -- its output is going.
455 dumpPrefix :: Maybe FilePath,
457 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
458 -- Set by @-ddump-file-prefix@
459 dumpPrefixForce :: Maybe FilePath,
461 includePaths :: [String],
462 libraryPaths :: [String],
463 frameworkPaths :: [String], -- used on darwin only
464 cmdlineFrameworks :: [String], -- ditto
466 rtsOpts :: Maybe String,
467 rtsOptsEnabled :: RtsOptsEnabled,
469 hpcDir :: String, -- ^ Path to store the .mix files
471 settings :: Settings,
474 depMakefile :: FilePath,
475 depIncludePkgDeps :: Bool,
476 depExcludeMods :: [ModuleName],
477 depSuffixes :: [String],
480 extraPkgConfs :: [FilePath],
481 -- ^ The @-package-conf@ flags given on the command line, in the order
484 packageFlags :: [PackageFlag],
485 -- ^ The @-package@ and @-hide-package@ flags from the command-line
488 -- NB. do not modify this field, it is calculated by
489 -- Packages.initPackages and Packages.updatePackages.
490 pkgDatabase :: Maybe [PackageConfig],
491 pkgState :: PackageState,
494 -- These have to be IORefs, because the defaultCleanupHandler needs to
495 -- know what to clean when an exception happens
496 filesToClean :: IORef [FilePath],
497 dirsToClean :: IORef (Map FilePath FilePath),
499 -- Names of files which were generated from -ddump-to-file; used to
500 -- track which ones we need to truncate because it's our first run
502 generatedDumps :: IORef (Set FilePath),
506 -- Don't change this without updating extensionFlags:
507 language :: Maybe Language,
508 -- Don't change this without updating extensionFlags:
509 extensions :: [OnOff ExtensionFlag],
510 -- extensionFlags should always be equal to
511 -- flattenExtensionFlags language extensions
512 extensionFlags :: [ExtensionFlag],
514 -- | Message output action: use "ErrUtils" instead of this if you can
515 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
517 haddockOptions :: Maybe String
520 data Settings = Settings {
521 sGhcUsagePath :: FilePath, -- Filled in by SysTools
522 sGhciUsagePath :: FilePath, -- ditto
524 sTmpDir :: String, -- no trailing '/'
525 -- You shouldn't need to look things up in rawSettings directly.
526 -- They should have their own fields instead.
527 sRawSettings :: [(String, String)],
528 sExtraGccViaCFlags :: [String],
529 sSystemPackageConfig :: FilePath,
530 -- commands for particular phases
532 sPgm_P :: (String,[Option]),
534 sPgm_c :: (String,[Option]),
535 sPgm_s :: (String,[Option]),
536 sPgm_a :: (String,[Option]),
537 sPgm_l :: (String,[Option]),
538 sPgm_dll :: (String,[Option]),
540 sPgm_sysman :: String,
541 sPgm_windres :: String,
542 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
543 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
544 -- options for particular phases
552 sOpt_windres :: [String],
553 sOpt_lo :: [String], -- LLVM: llvm optimiser
554 sOpt_lc :: [String] -- LLVM: llc static compiler
558 ghcUsagePath :: DynFlags -> FilePath
559 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
560 ghciUsagePath :: DynFlags -> FilePath
561 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
562 topDir :: DynFlags -> FilePath
563 topDir dflags = sTopDir (settings dflags)
564 tmpDir :: DynFlags -> String
565 tmpDir dflags = sTmpDir (settings dflags)
566 rawSettings :: DynFlags -> [(String, String)]
567 rawSettings dflags = sRawSettings (settings dflags)
568 extraGccViaCFlags :: DynFlags -> [String]
569 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
570 systemPackageConfig :: DynFlags -> FilePath
571 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
572 pgm_L :: DynFlags -> String
573 pgm_L dflags = sPgm_L (settings dflags)
574 pgm_P :: DynFlags -> (String,[Option])
575 pgm_P dflags = sPgm_P (settings dflags)
576 pgm_F :: DynFlags -> String
577 pgm_F dflags = sPgm_F (settings dflags)
578 pgm_c :: DynFlags -> (String,[Option])
579 pgm_c dflags = sPgm_c (settings dflags)
580 pgm_s :: DynFlags -> (String,[Option])
581 pgm_s dflags = sPgm_s (settings dflags)
582 pgm_a :: DynFlags -> (String,[Option])
583 pgm_a dflags = sPgm_a (settings dflags)
584 pgm_l :: DynFlags -> (String,[Option])
585 pgm_l dflags = sPgm_l (settings dflags)
586 pgm_dll :: DynFlags -> (String,[Option])
587 pgm_dll dflags = sPgm_dll (settings dflags)
588 pgm_T :: DynFlags -> String
589 pgm_T dflags = sPgm_T (settings dflags)
590 pgm_sysman :: DynFlags -> String
591 pgm_sysman dflags = sPgm_sysman (settings dflags)
592 pgm_windres :: DynFlags -> String
593 pgm_windres dflags = sPgm_windres (settings dflags)
594 pgm_lo :: DynFlags -> (String,[Option])
595 pgm_lo dflags = sPgm_lo (settings dflags)
596 pgm_lc :: DynFlags -> (String,[Option])
597 pgm_lc dflags = sPgm_lc (settings dflags)
598 opt_L :: DynFlags -> [String]
599 opt_L dflags = sOpt_L (settings dflags)
600 opt_P :: DynFlags -> [String]
601 opt_P dflags = sOpt_P (settings dflags)
602 opt_F :: DynFlags -> [String]
603 opt_F dflags = sOpt_F (settings dflags)
604 opt_c :: DynFlags -> [String]
605 opt_c dflags = sOpt_c (settings dflags)
606 opt_m :: DynFlags -> [String]
607 opt_m dflags = sOpt_m (settings dflags)
608 opt_a :: DynFlags -> [String]
609 opt_a dflags = sOpt_a (settings dflags)
610 opt_l :: DynFlags -> [String]
611 opt_l dflags = sOpt_l (settings dflags)
612 opt_windres :: DynFlags -> [String]
613 opt_windres dflags = sOpt_windres (settings dflags)
614 opt_lo :: DynFlags -> [String]
615 opt_lo dflags = sOpt_lo (settings dflags)
616 opt_lc :: DynFlags -> [String]
617 opt_lc dflags = sOpt_lc (settings dflags)
619 wayNames :: DynFlags -> [WayName]
620 wayNames = map wayName . ways
622 -- | The target code type of the compilation (if any).
624 -- Whenever you change the target, also make sure to set 'ghcLink' to
625 -- something sensible.
627 -- 'HscNothing' can be used to avoid generating any output, however, note
630 -- * This will not run the desugaring step, thus no warnings generated in
631 -- this step will be output. In particular, this includes warnings related
632 -- to pattern matching. You can run the desugarer manually using
633 -- 'GHC.desugarModule'.
635 -- * If a program uses Template Haskell the typechecker may try to run code
636 -- from an imported module. This will fail if no code has been generated
637 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
638 -- whether this might be the case and choose to either switch to a
639 -- different target or avoid typechecking such modules. (The latter may
640 -- preferable for security reasons.)
643 = HscC -- ^ Generate C code.
644 | HscAsm -- ^ Generate assembly using the native code generator.
645 | HscLlvm -- ^ Generate assembly using the llvm code generator.
646 | HscJava -- ^ Generate Java bytecode.
647 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
648 | HscNothing -- ^ Don't generate any code. See notes above.
651 showHscTargetFlag :: HscTarget -> String
652 showHscTargetFlag HscC = "-fvia-c"
653 showHscTargetFlag HscAsm = "-fasm"
654 showHscTargetFlag HscLlvm = "-fllvm"
655 showHscTargetFlag HscJava = panic "No flag for HscJava"
656 showHscTargetFlag HscInterpreted = "-fbyte-code"
657 showHscTargetFlag HscNothing = "-fno-code"
659 -- | Will this target result in an object file on the disk?
660 isObjectTarget :: HscTarget -> Bool
661 isObjectTarget HscC = True
662 isObjectTarget HscAsm = True
663 isObjectTarget HscLlvm = True
664 isObjectTarget _ = False
666 -- | The 'GhcMode' tells us whether we're doing multi-module
667 -- compilation (controlled via the "GHC" API) or one-shot
668 -- (single-module) compilation. This makes a difference primarily to
669 -- the "Finder": in one-shot mode we look for interface files for
670 -- imported modules, but in multi-module mode we look for source files
671 -- in order to check whether they need to be recompiled.
673 = CompManager -- ^ @\-\-make@, GHCi, etc.
674 | OneShot -- ^ @ghc -c Foo.hs@
675 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
678 instance Outputable GhcMode where
679 ppr CompManager = ptext (sLit "CompManager")
680 ppr OneShot = ptext (sLit "OneShot")
681 ppr MkDepend = ptext (sLit "MkDepend")
683 isOneShot :: GhcMode -> Bool
684 isOneShot OneShot = True
685 isOneShot _other = False
687 -- | What to do in the link step, if there is one.
689 = NoLink -- ^ Don't link at all
690 | LinkBinary -- ^ Link object code into a binary
691 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
692 -- bytecode and object code).
693 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
696 isNoLink :: GhcLink -> Bool
697 isNoLink NoLink = True
700 -- Is it worth evaluating this Bool and caching it in the DynFlags value
701 -- during initDynFlags?
702 doingTickyProfiling :: DynFlags -> Bool
703 doingTickyProfiling _ = opt_Ticky
704 -- XXX -ticky is a static flag, because it implies -debug which is also
705 -- static. If the way flags were made dynamic, we could fix this.
708 = ExposePackage String
709 | ExposePackageId String
711 | IgnorePackage String
714 defaultHscTarget :: HscTarget
715 defaultHscTarget = defaultObjectTarget
717 -- | The 'HscTarget' value corresponding to the default way to create
718 -- object files on the current platform.
719 defaultObjectTarget :: HscTarget
721 | cGhcUnregisterised == "YES" = HscC
722 | cGhcWithNativeCodeGen == "YES" = HscAsm
723 | otherwise = HscLlvm
730 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
733 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
734 initDynFlags :: DynFlags -> IO DynFlags
735 initDynFlags dflags = do
736 -- someday these will be dynamic flags
737 ways <- readIORef v_Ways
738 refFilesToClean <- newIORef []
739 refDirsToClean <- newIORef Map.empty
740 refGeneratedDumps <- newIORef Set.empty
743 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
744 rtsBuildTag = mkBuildTag ways,
745 filesToClean = refFilesToClean,
746 dirsToClean = refDirsToClean,
747 generatedDumps = refGeneratedDumps
750 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
751 -- and must be fully initialized by 'GHC.newSession' first.
752 defaultDynFlags :: Settings -> DynFlags
753 defaultDynFlags mySettings =
755 ghcMode = CompManager,
756 ghcLink = LinkBinary,
757 hscTarget = defaultHscTarget,
763 maxSimplIterations = 4,
764 shouldDumpSimplPhase = Nothing,
766 specConstrThreshold = Just 200,
767 specConstrCount = Just 3,
768 liberateCaseThreshold = Just 200,
769 floatLamArgs = Just 0, -- Default: float only if no fvs
770 strictnessBefore = [],
772 targetPlatform = defaultTargetPlatform,
773 cmdlineHcIncludes = [],
777 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
779 dphBackend = DPHNone,
781 thisPackage = mainPackageId,
784 dylibInstallName = Nothing,
788 objectSuf = phaseInputExt StopLn,
789 hcSuf = phaseInputExt HCc,
792 outputFile = Nothing,
794 dynLibLoader = SystemDependent,
795 dumpPrefix = Nothing,
796 dumpPrefixForce = Nothing,
800 cmdlineFrameworks = [],
802 rtsOptsEnabled = RtsOptsSafeOnly,
808 pkgDatabase = Nothing,
809 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
810 ways = panic "defaultDynFlags: No ways",
811 buildTag = panic "defaultDynFlags: No buildTag",
812 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
814 settings = mySettings,
816 depMakefile = "Makefile",
817 depIncludePkgDeps = False,
820 -- end of ghc -M values
821 filesToClean = panic "defaultDynFlags: No filesToClean",
822 dirsToClean = panic "defaultDynFlags: No dirsToClean",
823 generatedDumps = panic "defaultDynFlags: No generatedDumps",
824 haddockOptions = Nothing,
825 flags = defaultFlags,
828 extensionFlags = flattenExtensionFlags Nothing [],
830 log_action = \severity srcSpan style msg ->
832 SevOutput -> printSDoc msg style
833 SevInfo -> printErrs msg style
834 SevFatal -> printErrs msg style
837 printErrs (mkLocMessage srcSpan msg) style
838 -- careful (#2302): printErrs prints in UTF-8, whereas
839 -- converting to string first and using hPutStr would
840 -- just emit the low 8 bits of each unicode char.
844 Note [Verbosity levels]
845 ~~~~~~~~~~~~~~~~~~~~~~~
846 0 | print errors & warnings only
847 1 | minimal verbosity: print "compiling M ... done." for each module.
848 2 | equivalent to -dshow-passes
849 3 | equivalent to existing "ghc -v"
850 4 | "ghc -v -ddump-most"
851 5 | "ghc -v -ddump-all"
857 -- OnOffs accumulate in reverse order, so we use foldr in order to
858 -- process them in the right order
859 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
861 flattenExtensionFlags ml = foldr f defaultExtensionFlags
862 where f (On f) flags = f : delete f flags
863 f (Off f) flags = delete f flags
864 defaultExtensionFlags = languageExtensions ml
866 languageExtensions :: Maybe Language -> [ExtensionFlag]
868 languageExtensions Nothing
869 -- Nothing => the default case
870 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
871 -- behaviour the default, to see if anyone notices
873 -- In due course I'd like Opt_MonoLocalBinds to be on by default
874 -- But NB it's implied by GADTs etc
875 -- SLPJ September 2010
876 : Opt_NondecreasingIndentation -- This has been on by default for some time
877 : languageExtensions (Just Haskell2010)
879 languageExtensions (Just Haskell98)
880 = [Opt_ImplicitPrelude,
881 Opt_MonomorphismRestriction,
883 Opt_DatatypeContexts,
884 Opt_NondecreasingIndentation
885 -- strictly speaking non-standard, but we always had this
886 -- on implicitly before the option was added in 7.1, and
887 -- turning it off breaks code, so we're keeping it on for
888 -- backwards compatibility. Cabal uses -XHaskell98 by
889 -- default unless you specify another language.
892 languageExtensions (Just Haskell2010)
893 = [Opt_ImplicitPrelude,
894 Opt_MonomorphismRestriction,
895 Opt_DatatypeContexts,
897 Opt_ForeignFunctionInterface,
902 -- | Test whether a 'DynFlag' is set
903 dopt :: DynFlag -> DynFlags -> Bool
904 dopt f dflags = f `elem` (flags dflags)
907 dopt_set :: DynFlags -> DynFlag -> DynFlags
908 dopt_set dfs f = dfs{ flags = f : flags dfs }
910 -- | Unset a 'DynFlag'
911 dopt_unset :: DynFlags -> DynFlag -> DynFlags
912 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
914 -- | Test whether a 'ExtensionFlag' is set
915 xopt :: ExtensionFlag -> DynFlags -> Bool
916 xopt f dflags = f `elem` extensionFlags dflags
918 -- | Set a 'ExtensionFlag'
919 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
921 = let onoffs = On f : extensions dfs
922 in dfs { extensions = onoffs,
923 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
925 -- | Unset a 'ExtensionFlag'
926 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
928 = let onoffs = Off f : extensions dfs
929 in dfs { extensions = onoffs,
930 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
932 setLanguage :: Language -> DynP ()
933 setLanguage l = upd f
934 where f dfs = let mLang = Just l
935 oneoffs = extensions dfs
938 extensionFlags = flattenExtensionFlags mLang oneoffs
941 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
942 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
943 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
944 -> [a] -- ^ Correctly ordered extracted options
945 getOpts dflags opts = reverse (opts dflags)
946 -- We add to the options from the front, so we need to reverse the list
948 -- | Gets the verbosity flag for the current verbosity level. This is fed to
949 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
950 getVerbFlags :: DynFlags -> [String]
952 | verbosity dflags >= 4 = ["-v"]
955 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
956 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
957 setPgmP, addOptl, addOptP,
958 addCmdlineFramework, addHaddockOpts
959 :: String -> DynFlags -> DynFlags
960 setOutputFile, setOutputHi, setDumpPrefixForce
961 :: Maybe String -> DynFlags -> DynFlags
963 setObjectDir f d = d{ objectDir = Just f}
964 setHiDir f d = d{ hiDir = Just f}
965 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
966 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
967 -- \#included from the .hc file when compiling via C (i.e. unregisterised
969 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
970 setDylibInstallName f d = d{ dylibInstallName = Just f}
972 setObjectSuf f d = d{ objectSuf = f}
973 setHiSuf f d = d{ hiSuf = f}
974 setHcSuf f d = d{ hcSuf = f}
976 setOutputFile f d = d{ outputFile = f}
977 setOutputHi f d = d{ outputHi = f}
979 parseDynLibLoaderMode f d =
981 ("deploy", "") -> d{ dynLibLoader = Deployable }
982 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
983 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
985 setDumpPrefixForce f d = d { dumpPrefixForce = f}
987 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
988 -- Config.hs should really use Option.
989 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
990 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
991 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
994 setDepMakefile :: FilePath -> DynFlags -> DynFlags
995 setDepMakefile f d = d { depMakefile = deOptDep f }
997 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
998 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1000 addDepExcludeMod :: String -> DynFlags -> DynFlags
1001 addDepExcludeMod m d
1002 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1004 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1005 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1008 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1009 -- we need to strip the "-optdep" off of the arg
1010 deOptDep :: String -> String
1011 deOptDep x = case stripPrefix "-optdep" x of
1015 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1017 addHaddockOpts f d = d{ haddockOptions = Just f}
1019 -- -----------------------------------------------------------------------------
1020 -- Command-line options
1022 -- | When invoking external tools as part of the compilation pipeline, we
1023 -- pass these a sequence of options on the command-line. Rather than
1024 -- just using a list of Strings, we use a type that allows us to distinguish
1025 -- between filepaths and 'other stuff'. The reason for this is that
1026 -- this type gives us a handle on transforming filenames, and filenames only,
1027 -- to whatever format they're expected to be on a particular platform.
1029 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1030 String -- a non-filepath prefix that shouldn't be
1031 -- transformed (e.g., "/out=")
1032 String -- the filepath/filename portion
1035 showOpt :: Option -> String
1036 showOpt (FileOption pre f) = pre ++ f
1037 showOpt (Option s) = s
1039 -----------------------------------------------------------------------------
1040 -- Setting the optimisation level
1042 updOptLevel :: Int -> DynFlags -> DynFlags
1043 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1045 = dfs2{ optLevel = final_n }
1047 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1048 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1049 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1051 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1052 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1054 -- -----------------------------------------------------------------------------
1055 -- StgToDo: abstraction of stg-to-stg passes to run.
1058 = StgDoMassageForProfiling -- should be (next to) last
1059 -- There's also setStgVarInfo, but its absolute "lastness"
1060 -- is so critical that it is hardwired in (no flag).
1063 getStgToDo :: DynFlags -> [StgToDo]
1067 stg_stats = dopt Opt_StgStats dflags
1069 todo1 = if stg_stats then [D_stg_stats] else []
1071 todo2 | WayProf `elem` wayNames dflags
1072 = StgDoMassageForProfiling : todo1
1076 {- **********************************************************************
1080 %********************************************************************* -}
1082 -- -----------------------------------------------------------------------------
1083 -- Parsing the dynamic flags.
1085 -- | Parse dynamic flags from a list of command line arguments. Returns the
1086 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1087 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1088 -- flags or missing arguments).
1089 parseDynamicFlags :: Monad m =>
1090 DynFlags -> [Located String]
1091 -> m (DynFlags, [Located String], [Located String])
1092 -- ^ Updated 'DynFlags', left-over arguments, and
1093 -- list of warnings.
1094 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1096 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1097 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1098 parseDynamicNoPackageFlags :: Monad m =>
1099 DynFlags -> [Located String]
1100 -> m (DynFlags, [Located String], [Located String])
1101 -- ^ Updated 'DynFlags', left-over arguments, and
1102 -- list of warnings.
1103 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1105 parseDynamicFlags_ :: Monad m =>
1106 DynFlags -> [Located String] -> Bool
1107 -> m (DynFlags, [Located String], [Located String])
1108 parseDynamicFlags_ dflags0 args pkg_flags = do
1109 -- XXX Legacy support code
1110 -- We used to accept things like
1111 -- optdep-f -optdepdepend
1112 -- optdep-f -optdep depend
1113 -- optdep -f -optdepdepend
1114 -- optdep -f -optdep depend
1115 -- but the spaces trip up proper argument handling. So get rid of them.
1116 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1117 f (x : xs) = x : f xs
1121 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1122 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1123 | otherwise = dynamic_flags
1125 let ((leftover, errs, warns), dflags1)
1126 = runCmdLine (processArgs flag_spec args') dflags0
1127 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1129 return (dflags1, leftover, warns)
1132 {- **********************************************************************
1134 DynFlags specifications
1136 %********************************************************************* -}
1138 allFlags :: [String]
1139 allFlags = map ('-':) $
1140 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1141 map ("fno-"++) flags ++
1142 map ("f"++) flags ++
1143 map ("f"++) flags' ++
1144 map ("X"++) supportedExtensions
1145 where ok (PrefixPred _ _) = False
1147 flags = [ name | (name, _, _) <- fFlags ]
1148 flags' = [ name | (name, _, _) <- fLangFlags ]
1150 --------------- The main flags themselves ------------------
1151 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1153 Flag "n" (NoArg (setDynFlag Opt_DryRun))
1154 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1155 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1157 (HasArg (\s -> do { addCmdlineHCInclude s
1158 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1159 , Flag "v" (OptIntSuffix setVerbosity)
1161 ------- Specific phases --------------------------------------------
1162 -- need to appear before -pgmL to be parsed as LLVM flags.
1163 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1164 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1165 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1166 , Flag "pgmP" (hasArg setPgmP)
1167 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1168 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1169 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1170 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1171 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1172 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1173 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1174 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1176 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1177 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1178 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1179 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1180 , Flag "optP" (hasArg addOptP)
1181 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1182 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1183 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1184 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1185 , Flag "optl" (hasArg addOptl)
1186 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1189 (NoArg (if can_split
1190 then setDynFlag Opt_SplitObjs
1191 else addWarn "ignoring -fsplit-objs"))
1193 -------- ghc -M -----------------------------------------------------
1194 , Flag "dep-suffix" (hasArg addDepSuffix)
1195 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1196 , Flag "dep-makefile" (hasArg setDepMakefile)
1197 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1198 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1199 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1200 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1201 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1202 , Flag "exclude-module" (hasArg addDepExcludeMod)
1203 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1204 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1206 -------- Linking ----------------------------------------------------
1207 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1208 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1209 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1210 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1212 ------- Libraries ---------------------------------------------------
1213 , Flag "L" (Prefix addLibraryPath)
1214 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1216 ------- Frameworks --------------------------------------------------
1217 -- -framework-path should really be -F ...
1218 , Flag "framework-path" (HasArg addFrameworkPath)
1219 , Flag "framework" (hasArg addCmdlineFramework)
1221 ------- Output Redirection ------------------------------------------
1222 , Flag "odir" (hasArg setObjectDir)
1223 , Flag "o" (SepArg (upd . setOutputFile . Just))
1224 , Flag "ohi" (hasArg (setOutputHi . Just ))
1225 , Flag "osuf" (hasArg setObjectSuf)
1226 , Flag "hcsuf" (hasArg setHcSuf)
1227 , Flag "hisuf" (hasArg setHiSuf)
1228 , Flag "hidir" (hasArg setHiDir)
1229 , Flag "tmpdir" (hasArg setTmpDir)
1230 , Flag "stubdir" (hasArg setStubDir)
1231 , Flag "outputdir" (hasArg setOutputDir)
1232 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1234 ------- Keeping temporary files -------------------------------------
1235 -- These can be singular (think ghc -c) or plural (think ghc --make)
1236 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1237 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1238 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1239 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1240 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1241 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1242 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1243 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1244 -- This only makes sense as plural
1245 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1247 ------- Miscellaneous ----------------------------------------------
1248 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1249 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1250 , Flag "with-rtsopts" (HasArg setRtsOpts)
1251 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1252 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1253 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1254 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1255 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1256 , Flag "main-is" (SepArg setMainIs)
1257 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1258 , Flag "haddock-opts" (hasArg addHaddockOpts)
1259 , Flag "hpcdir" (SepArg setOptHpcDir)
1261 ------- recompilation checker --------------------------------------
1262 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1263 ; deprecate "Use -fno-force-recomp instead" }))
1264 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1265 ; deprecate "Use -fforce-recomp instead" }))
1267 ------ HsCpp opts ---------------------------------------------------
1268 , Flag "D" (AnySuffix (upd . addOptP))
1269 , Flag "U" (AnySuffix (upd . addOptP))
1271 ------- Include/Import Paths ----------------------------------------
1272 , Flag "I" (Prefix addIncludePath)
1273 , Flag "i" (OptPrefix addImportPath)
1275 ------ Debugging ----------------------------------------------------
1276 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1278 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1279 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1280 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1281 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1282 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1283 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1284 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1285 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1286 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1287 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1288 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1289 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1290 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1291 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1292 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1293 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1294 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1295 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1296 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1297 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1298 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1299 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1300 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1301 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1302 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1303 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1304 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1305 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1306 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1307 ; setDumpFlag' Opt_D_dump_llvm}))
1308 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1309 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1310 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1311 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1312 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1313 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1314 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1315 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1316 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1317 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1318 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1319 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1320 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1321 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1322 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1323 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1324 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1325 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1326 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1327 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1328 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1329 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1330 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1331 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1332 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1333 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1334 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1335 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1336 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1337 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1338 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1339 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1340 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1341 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1342 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1343 ; setVerboseCore2Core }))
1344 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1345 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1346 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1347 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1348 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1349 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1350 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1351 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1352 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1353 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1354 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1355 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1356 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1357 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1358 , Flag "dshow-passes" (NoArg (do forceRecompile
1359 setVerbosity (Just 2)))
1360 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1362 ------ Machine dependant (-m<blah>) stuff ---------------------------
1364 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1365 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1366 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1367 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1369 ------ Warning opts -------------------------------------------------
1370 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1371 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1372 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1373 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1374 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1375 ; deprecate "Use -w instead" }))
1376 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1378 ------ Optimisation flags ------------------------------------------
1379 , Flag "O" (noArgM (setOptLevel 1))
1380 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1381 setOptLevel 0 dflags))
1382 , Flag "Odph" (noArgM setDPHOpt)
1383 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1384 -- If the number is missing, use 1
1386 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1387 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1388 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1389 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1390 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1391 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1392 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1393 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1394 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1395 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1396 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1397 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1398 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1400 ------ Profiling ----------------------------------------------------
1402 -- XXX Should the -f* flags be deprecated?
1403 -- They don't seem to be documented
1404 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1405 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1406 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1407 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1408 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1409 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1410 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1411 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1412 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1414 ------ DPH flags ----------------------------------------------------
1416 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1417 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1418 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1419 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1421 ------ Compiler flags -----------------------------------------------
1423 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1424 , Flag "fvia-c" (NoArg
1425 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1426 , Flag "fvia-C" (NoArg
1427 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1428 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1430 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1431 setTarget HscNothing))
1432 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1433 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1434 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1435 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1437 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1438 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1439 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1440 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1441 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1442 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1443 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1445 package_flags :: [Flag (CmdLineP DynFlags)]
1447 ------- Packages ----------------------------------------------------
1448 Flag "package-conf" (HasArg extraPkgConf_)
1449 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1450 , Flag "package-name" (hasArg setPackageName)
1451 , Flag "package-id" (HasArg exposePackageId)
1452 , Flag "package" (HasArg exposePackage)
1453 , Flag "hide-package" (HasArg hidePackage)
1454 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1455 , Flag "ignore-package" (HasArg ignorePackage)
1456 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1457 ; deprecate "Use -package instead" }))
1460 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1461 -- False <=> we are turning the flag off
1462 turnOn :: TurnOnFlag; turnOn = True
1463 turnOff :: TurnOnFlag; turnOff = False
1466 = ( String -- Flag in string form
1467 , flag -- Flag in internal form
1468 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1469 -- Typically, emit a warning or error
1471 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1472 -> String -- ^ The flag prefix
1473 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1474 -> FlagSpec flag -- ^ Specification of this particular flag
1475 -> Flag (CmdLineP DynFlags)
1476 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1477 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1479 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1480 deprecatedForExtension lang turn_on
1481 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1483 flag | turn_on = lang
1484 | otherwise = "No"++lang
1486 useInstead :: String -> TurnOnFlag -> DynP ()
1487 useInstead flag turn_on
1488 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1490 no = if turn_on then "" else "no-"
1492 nop :: TurnOnFlag -> DynP ()
1495 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1496 fFlags :: [FlagSpec DynFlag]
1498 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1499 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1500 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1501 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1502 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1503 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1504 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1505 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1506 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1507 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1508 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1509 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1510 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1511 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1512 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1513 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1514 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1515 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1516 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1517 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1518 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1519 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1520 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1521 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1522 ( "warn-orphans", Opt_WarnOrphans, nop ),
1523 ( "warn-identities", Opt_WarnIdentities, nop ),
1524 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1525 ( "warn-tabs", Opt_WarnTabs, nop ),
1526 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1527 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1528 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1529 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1530 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1531 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1532 ( "strictness", Opt_Strictness, nop ),
1533 ( "specialise", Opt_Specialise, nop ),
1534 ( "float-in", Opt_FloatIn, nop ),
1535 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1536 ( "full-laziness", Opt_FullLaziness, nop ),
1537 ( "liberate-case", Opt_LiberateCase, nop ),
1538 ( "spec-constr", Opt_SpecConstr, nop ),
1539 ( "cse", Opt_CSE, nop ),
1540 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1541 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1542 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1543 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1544 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1545 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1546 ( "case-merge", Opt_CaseMerge, nop ),
1547 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1548 ( "method-sharing", Opt_MethodSharing,
1549 \_ -> deprecate "doesn't do anything any more"),
1550 -- Remove altogether in GHC 7.2
1551 ( "dicts-cheap", Opt_DictsCheap, nop ),
1552 ( "excess-precision", Opt_ExcessPrecision, nop ),
1553 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1554 ( "print-bind-result", Opt_PrintBindResult, nop ),
1555 ( "force-recomp", Opt_ForceRecomp, nop ),
1556 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1557 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1558 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1559 ( "break-on-exception", Opt_BreakOnException, nop ),
1560 ( "break-on-error", Opt_BreakOnError, nop ),
1561 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1562 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1563 ( "run-cps", Opt_RunCPS, nop ),
1564 ( "run-cpsz", Opt_RunCPSZ, nop ),
1565 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1566 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1567 ( "vectorise", Opt_Vectorise, nop ),
1568 ( "regs-graph", Opt_RegsGraph, nop ),
1569 ( "regs-iterative", Opt_RegsIterative, nop ),
1570 ( "gen-manifest", Opt_GenManifest, nop ),
1571 ( "embed-manifest", Opt_EmbedManifest, nop ),
1572 ( "ext-core", Opt_EmitExternalCore, nop ),
1573 ( "shared-implib", Opt_SharedImplib, nop ),
1574 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1575 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1576 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1577 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1580 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1581 fLangFlags :: [FlagSpec ExtensionFlag]
1583 ( "th", Opt_TemplateHaskell,
1584 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1585 ( "fi", Opt_ForeignFunctionInterface,
1586 deprecatedForExtension "ForeignFunctionInterface" ),
1587 ( "ffi", Opt_ForeignFunctionInterface,
1588 deprecatedForExtension "ForeignFunctionInterface" ),
1589 ( "arrows", Opt_Arrows,
1590 deprecatedForExtension "Arrows" ),
1591 ( "generics", Opt_Generics,
1592 deprecatedForExtension "Generics" ),
1593 ( "implicit-prelude", Opt_ImplicitPrelude,
1594 deprecatedForExtension "ImplicitPrelude" ),
1595 ( "bang-patterns", Opt_BangPatterns,
1596 deprecatedForExtension "BangPatterns" ),
1597 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1598 deprecatedForExtension "MonomorphismRestriction" ),
1599 ( "mono-pat-binds", Opt_MonoPatBinds,
1600 deprecatedForExtension "MonoPatBinds" ),
1601 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1602 deprecatedForExtension "ExtendedDefaultRules" ),
1603 ( "implicit-params", Opt_ImplicitParams,
1604 deprecatedForExtension "ImplicitParams" ),
1605 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1606 deprecatedForExtension "ScopedTypeVariables" ),
1607 ( "parr", Opt_ParallelArrays,
1608 deprecatedForExtension "ParallelArrays" ),
1609 ( "PArr", Opt_ParallelArrays,
1610 deprecatedForExtension "ParallelArrays" ),
1611 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1612 deprecatedForExtension "OverlappingInstances" ),
1613 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1614 deprecatedForExtension "UndecidableInstances" ),
1615 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1616 deprecatedForExtension "IncoherentInstances" )
1619 supportedLanguages :: [String]
1620 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1622 supportedExtensions :: [String]
1623 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1625 supportedLanguagesAndExtensions :: [String]
1626 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1628 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1629 languageFlags :: [FlagSpec Language]
1631 ( "Haskell98", Haskell98, nop ),
1632 ( "Haskell2010", Haskell2010, nop )
1635 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1636 xFlags :: [FlagSpec ExtensionFlag]
1638 ( "CPP", Opt_Cpp, nop ),
1639 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1640 ( "TupleSections", Opt_TupleSections, nop ),
1641 ( "PatternGuards", Opt_PatternGuards, nop ),
1642 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1643 ( "MagicHash", Opt_MagicHash, nop ),
1644 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1645 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1646 ( "KindSignatures", Opt_KindSignatures, nop ),
1647 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1648 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1649 ( "TransformListComp", Opt_TransformListComp, nop ),
1650 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1651 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1652 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1653 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1654 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1655 ( "Rank2Types", Opt_Rank2Types, nop ),
1656 ( "RankNTypes", Opt_RankNTypes, nop ),
1657 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1658 ( "TypeOperators", Opt_TypeOperators, nop ),
1659 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1660 deprecatedForExtension "DoRec"),
1661 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1662 ( "Arrows", Opt_Arrows, nop ),
1663 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1664 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1665 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1666 ( "Generics", Opt_Generics, nop ),
1667 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1668 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1669 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1670 ( "RecordPuns", Opt_RecordPuns,
1671 deprecatedForExtension "NamedFieldPuns" ),
1672 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1673 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1674 ( "GADTs", Opt_GADTs, nop ),
1675 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1676 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1677 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1678 ( "BangPatterns", Opt_BangPatterns, nop ),
1679 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1680 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1681 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1682 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1683 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1684 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1685 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1686 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1687 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1688 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1689 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1690 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1691 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1692 \ turn_on -> if not turn_on
1693 then deprecate "You can't turn off RelaxedPolyRec any more"
1695 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1696 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1697 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1699 ( "PatternSignatures", Opt_ScopedTypeVariables,
1700 deprecatedForExtension "ScopedTypeVariables" ),
1702 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1703 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1704 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1705 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1706 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1707 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1708 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1709 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1710 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1711 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1712 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1713 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1714 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1715 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1716 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1717 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1718 ( "PackageImports", Opt_PackageImports, nop )
1721 defaultFlags :: [DynFlag]
1723 = [ Opt_AutoLinkPackages,
1724 Opt_ReadUserPackageConf,
1728 #if GHC_DEFAULT_NEW_CODEGEN
1734 Opt_PrintBindContents,
1739 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1740 -- The default -O0 options
1744 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1746 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1747 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1748 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1749 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1750 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1751 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1752 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1753 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1755 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1757 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1758 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1759 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1761 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1762 -- all over the place
1764 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1766 -- Record wild-cards implies field disambiguation
1767 -- Otherwise if you write (C {..}) you may well get
1768 -- stuff like " 'a' not in scope ", which is a bit silly
1769 -- if the compiler has just filled in field 'a' of constructor 'C'
1770 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1772 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1775 optLevelFlags :: [([Int], DynFlag)]
1777 = [ ([0], Opt_IgnoreInterfacePragmas)
1778 , ([0], Opt_OmitInterfacePragmas)
1780 , ([1,2], Opt_IgnoreAsserts)
1781 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1783 , ([1,2], Opt_DoEtaReduction)
1784 , ([1,2], Opt_CaseMerge)
1785 , ([1,2], Opt_Strictness)
1787 , ([1,2], Opt_FullLaziness)
1788 , ([1,2], Opt_Specialise)
1789 , ([1,2], Opt_FloatIn)
1791 , ([2], Opt_LiberateCase)
1792 , ([2], Opt_SpecConstr)
1793 , ([2], Opt_RegsGraph)
1795 -- , ([2], Opt_StaticArgumentTransformation)
1796 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1797 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1798 -- several improvements to the heuristics, and I'm concerned that without
1799 -- those changes SAT will interfere with some attempts to write "high
1800 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1801 -- this year. In particular, the version in HEAD lacks the tail call
1802 -- criterion, so many things that look like reasonable loops will be
1803 -- turned into functions with extra (unneccesary) thunk creation.
1805 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1806 -- This one is important for a tiresome reason:
1807 -- we want to make sure that the bindings for data
1808 -- constructors are eta-expanded. This is probably
1809 -- a good thing anyway, but it seems fragile.
1812 -- -----------------------------------------------------------------------------
1813 -- Standard sets of warning options
1815 standardWarnings :: [DynFlag]
1817 = [ Opt_WarnWarningsDeprecations,
1818 Opt_WarnDeprecatedFlags,
1819 Opt_WarnUnrecognisedPragmas,
1820 Opt_WarnOverlappingPatterns,
1821 Opt_WarnMissingFields,
1822 Opt_WarnMissingMethods,
1823 Opt_WarnDuplicateExports,
1824 Opt_WarnLazyUnliftedBindings,
1825 Opt_WarnDodgyForeignImports,
1826 Opt_WarnWrongDoBind,
1827 Opt_WarnAlternativeLayoutRuleTransitional
1830 minusWOpts :: [DynFlag]
1831 -- Things you get with -W
1833 = standardWarnings ++
1834 [ Opt_WarnUnusedBinds,
1835 Opt_WarnUnusedMatches,
1836 Opt_WarnUnusedImports,
1837 Opt_WarnIncompletePatterns,
1838 Opt_WarnDodgyExports,
1839 Opt_WarnDodgyImports
1842 minusWallOpts :: [DynFlag]
1843 -- Things you get with -Wall
1846 [ Opt_WarnTypeDefaults,
1847 Opt_WarnNameShadowing,
1848 Opt_WarnMissingSigs,
1851 Opt_WarnUnusedDoBind
1854 minuswRemovesOpts :: [DynFlag]
1855 -- minuswRemovesOpts should be every warning option
1859 Opt_WarnIncompletePatternsRecUpd,
1860 Opt_WarnIncompleteUniPatterns,
1861 Opt_WarnMonomorphism,
1862 Opt_WarnUnrecognisedPragmas,
1863 Opt_WarnAutoOrphans,
1864 Opt_WarnImplicitPrelude
1867 enableGlasgowExts :: DynP ()
1868 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1869 mapM_ setExtensionFlag glasgowExtsFlags
1871 disableGlasgowExts :: DynP ()
1872 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1873 mapM_ unSetExtensionFlag glasgowExtsFlags
1875 glasgowExtsFlags :: [ExtensionFlag]
1876 glasgowExtsFlags = [
1877 Opt_ForeignFunctionInterface
1878 , Opt_UnliftedFFITypes
1879 , Opt_ImplicitParams
1880 , Opt_ScopedTypeVariables
1882 , Opt_TypeSynonymInstances
1883 , Opt_StandaloneDeriving
1884 , Opt_DeriveDataTypeable
1886 , Opt_DeriveFoldable
1887 , Opt_DeriveTraversable
1888 , Opt_FlexibleContexts
1889 , Opt_FlexibleInstances
1890 , Opt_ConstrainedClassMethods
1891 , Opt_MultiParamTypeClasses
1892 , Opt_FunctionalDependencies
1894 , Opt_PolymorphicComponents
1895 , Opt_ExistentialQuantification
1897 , Opt_PostfixOperators
1899 , Opt_LiberalTypeSynonyms
1903 , Opt_ParallelListComp
1904 , Opt_EmptyDataDecls
1905 , Opt_KindSignatures
1906 , Opt_GeneralizedNewtypeDeriving ]
1909 -- Consult the RTS to find whether GHC itself has been built profiled
1910 -- If so, you can't use Template Haskell
1911 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1913 rtsIsProfiled :: Bool
1914 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1917 checkTemplateHaskellOk :: Bool -> DynP ()
1919 checkTemplateHaskellOk turn_on
1920 | turn_on && rtsIsProfiled
1921 = addErr "You can't use Template Haskell with a profiled compiler"
1925 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1926 -- so we simply say "ok". It doesn't matter because TH isn't
1927 -- available in stage 1 anyway.
1928 checkTemplateHaskellOk _ = return ()
1931 {- **********************************************************************
1933 DynFlags constructors
1935 %********************************************************************* -}
1937 type DynP = EwM (CmdLineP DynFlags)
1939 upd :: (DynFlags -> DynFlags) -> DynP ()
1940 upd f = liftEwM (do dflags <- getCmdLineState
1941 putCmdLineState $! f dflags)
1943 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1944 updM f = do dflags <- liftEwM getCmdLineState
1946 liftEwM $ putCmdLineState $! dflags'
1948 --------------- Constructor functions for OptKind -----------------
1949 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1950 noArg fn = NoArg (upd fn)
1952 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1953 noArgM fn = NoArg (updM fn)
1955 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1956 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1958 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1959 hasArg fn = HasArg (upd . fn)
1961 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1962 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1963 ; deprecate deprec })
1965 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1966 intSuffix fn = IntSuffix (\n -> upd (fn n))
1968 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
1969 -> OptKind (CmdLineP DynFlags)
1970 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
1972 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
1973 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1975 --------------------------
1976 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1977 setDynFlag f = upd (\dfs -> dopt_set dfs f)
1978 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1980 --------------------------
1981 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
1982 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
1985 deps = [ if turn_on then setExtensionFlag d
1986 else unSetExtensionFlag d
1987 | (f', turn_on, d) <- impliedFlags, f' == f ]
1988 -- When you set f, set the ones it implies
1989 -- NB: use setExtensionFlag recursively, in case the implied flags
1990 -- implies further flags
1992 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
1993 -- When you un-set f, however, we don't un-set the things it implies
1994 -- (except for -fno-glasgow-exts, which is treated specially)
1996 --------------------------
1997 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
1998 alterSettings f dflags = dflags { settings = f (settings dflags) }
2000 --------------------------
2001 setDumpFlag' :: DynFlag -> DynP ()
2002 setDumpFlag' dump_flag
2003 = do { setDynFlag dump_flag
2004 ; when want_recomp forceRecompile }
2006 -- Certain dumpy-things are really interested in what's going
2007 -- on during recompilation checking, so in those cases we
2008 -- don't want to turn it off.
2009 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2010 Opt_D_dump_hi_diffs]
2012 forceRecompile :: DynP ()
2013 -- Whenver we -ddump, force recompilation (by switching off the
2014 -- recompilation checker), else you don't see the dump! However,
2015 -- don't switch it off in --make mode, else *everything* gets
2016 -- recompiled which probably isn't what you want
2017 forceRecompile = do { dfs <- liftEwM getCmdLineState
2018 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2020 force_recomp dfs = isOneShot (ghcMode dfs)
2022 setVerboseCore2Core :: DynP ()
2023 setVerboseCore2Core = do forceRecompile
2024 setDynFlag Opt_D_verbose_core2core
2025 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2027 setDumpSimplPhases :: String -> DynP ()
2028 setDumpSimplPhases s = do forceRecompile
2029 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2031 spec = case s of { ('=' : s') -> s'; _ -> s }
2033 setVerbosity :: Maybe Int -> DynP ()
2034 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2036 addCmdlineHCInclude :: String -> DynP ()
2037 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2039 extraPkgConf_ :: FilePath -> DynP ()
2040 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2042 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2044 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2046 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2048 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2050 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2052 setPackageName :: String -> DynFlags -> DynFlags
2053 setPackageName p s = s{ thisPackage = stringToPackageId p }
2055 -- If we're linking a binary, then only targets that produce object
2056 -- code are allowed (requests for other target types are ignored).
2057 setTarget :: HscTarget -> DynP ()
2058 setTarget l = upd set
2061 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2064 -- Changes the target only if we're compiling object code. This is
2065 -- used by -fasm and -fllvm, which switch from one to the other, but
2066 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2067 -- can be safely used in an OPTIONS_GHC pragma.
2068 setObjTarget :: HscTarget -> DynP ()
2069 setObjTarget l = updM set
2072 | isObjectTarget (hscTarget dflags)
2075 | cGhcUnregisterised /= "YES" ->
2076 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2079 | cGhcWithNativeCodeGen /= "YES" ->
2080 do addWarn ("Compiler has no native codegen, so ignoring " ++
2084 | cGhcUnregisterised == "YES" ->
2085 do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2087 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2088 (not opt_Static || opt_PIC)
2090 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2092 _ -> return $ dflags { hscTarget = l }
2093 | otherwise = return dflags
2094 where platform = targetPlatform dflags
2095 arch = platformArch platform
2096 os = platformOS platform
2097 flag = showHscTargetFlag l
2099 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2100 setOptLevel n dflags
2101 | hscTarget dflags == HscInterpreted && n > 0
2102 = do addWarn "-O conflicts with --interactive; -O ignored."
2105 = return (updOptLevel n dflags)
2108 -- -Odph is equivalent to
2110 -- -O2 optimise as much as possible
2111 -- -fmax-simplifier-iterations20 this is necessary sometimes
2112 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2114 setDPHOpt :: DynFlags -> DynP DynFlags
2115 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2119 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2120 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2121 -- vectoriser cannot be used.
2123 data DPHBackend = DPHPar -- "dph-par"
2124 | DPHSeq -- "dph-seq"
2125 | DPHThis -- the currently compiled package
2126 | DPHNone -- no DPH library available
2127 deriving(Eq, Ord, Enum, Show)
2129 setDPHBackend :: DPHBackend -> DynP ()
2130 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2132 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2134 dphPackageMaybe :: DynFlags -> Maybe PackageId
2135 dphPackageMaybe dflags
2136 = case dphBackend dflags of
2137 DPHPar -> Just dphParPackageId
2138 DPHSeq -> Just dphSeqPackageId
2139 DPHThis -> Just (thisPackage dflags)
2142 setMainIs :: String -> DynP ()
2144 | not (null main_fn) && isLower (head main_fn)
2145 -- The arg looked like "Foo.Bar.baz"
2146 = upd $ \d -> d{ mainFunIs = Just main_fn,
2147 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2149 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2150 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2152 | otherwise -- The arg looked like "baz"
2153 = upd $ \d -> d{ mainFunIs = Just arg }
2155 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2157 -----------------------------------------------------------------------------
2158 -- Paths & Libraries
2160 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2162 -- -i on its own deletes the import paths
2163 addImportPath "" = upd (\s -> s{importPaths = []})
2164 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2167 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2170 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2172 addFrameworkPath p =
2173 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2175 #ifndef mingw32_TARGET_OS
2176 split_marker :: Char
2177 split_marker = ':' -- not configurable (ToDo)
2180 splitPathList :: String -> [String]
2181 splitPathList s = filter notNull (splitUp s)
2182 -- empty paths are ignored: there might be a trailing
2183 -- ':' in the initial list, for example. Empty paths can
2184 -- cause confusion when they are translated into -I options
2185 -- for passing to gcc.
2187 #ifndef mingw32_TARGET_OS
2188 splitUp xs = split split_marker xs
2190 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2192 -- That is, if "foo:bar:baz" is used, this interpreted as
2193 -- consisting of three entries, 'foo', 'bar', 'baz'.
2194 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2195 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2197 -- Notice that no attempt is made to fully replace the 'standard'
2198 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2199 -- that this will cause too much breakage for users & ':' will
2200 -- work fine even with DOS paths, if you're not insisting on being silly.
2203 splitUp (x:':':div:xs) | div `elem` dir_markers
2204 = ((x:':':div:p): splitUp rs)
2206 (p,rs) = findNextPath xs
2207 -- we used to check for existence of the path here, but that
2208 -- required the IO monad to be threaded through the command-line
2209 -- parser which is quite inconvenient. The
2210 splitUp xs = cons p (splitUp rs)
2212 (p,rs) = findNextPath xs
2217 -- will be called either when we've consumed nought or the
2218 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2219 -- finding the next split marker.
2221 case break (`elem` split_markers) xs of
2222 (p, _:ds) -> (p, ds)
2225 split_markers :: [Char]
2226 split_markers = [':', ';']
2228 dir_markers :: [Char]
2229 dir_markers = ['/', '\\']
2232 -- -----------------------------------------------------------------------------
2233 -- tmpDir, where we store temporary files.
2235 setTmpDir :: FilePath -> DynFlags -> DynFlags
2236 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2237 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2238 -- seem necessary now --SDM 7/2/2008
2240 -----------------------------------------------------------------------------
2243 setRtsOpts :: String -> DynP ()
2244 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2246 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2247 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2249 -----------------------------------------------------------------------------
2252 setOptHpcDir :: String -> DynP ()
2253 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2255 -----------------------------------------------------------------------------
2256 -- Via-C compilation stuff
2258 -- There are some options that we need to pass to gcc when compiling
2259 -- Haskell code via C, but are only supported by recent versions of
2260 -- gcc. The configure script decides which of these options we need,
2261 -- and puts them in the "settings" file in $topdir. The advantage of
2262 -- having these in a separate file is that the file can be created at
2263 -- install-time depending on the available gcc version, and even
2264 -- re-generated later if gcc is upgraded.
2266 -- The options below are not dependent on the version of gcc, only the
2269 picCCOpts :: DynFlags -> [String]
2271 #if darwin_TARGET_OS
2272 -- Apple prefers to do things the other way round.
2273 -- PIC is on by default.
2274 -- -mdynamic-no-pic:
2275 -- Turn off PIC code generation.
2277 -- Don't generate "common" symbols - these are unwanted
2278 -- in dynamic libraries.
2281 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2283 = ["-mdynamic-no-pic"]
2284 #elif mingw32_TARGET_OS
2285 -- no -fPIC for Windows
2287 = ["-U __PIC__","-D__PIC__"]
2291 -- we need -fPIC for C files when we are compiling with -dynamic,
2292 -- otherwise things like stub.c files don't get compiled
2293 -- correctly. They need to reference data in the Haskell
2294 -- objects, but can't without -fPIC. See
2295 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2296 | opt_PIC || not opt_Static
2297 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2302 -- -----------------------------------------------------------------------------
2306 can_split = cSupportsSplitObjs == "YES"
2308 -- -----------------------------------------------------------------------------
2311 compilerInfo :: DynFlags -> [(String, String)]
2313 = -- We always make "Project name" be first to keep parsing in
2314 -- other languages simple, i.e. when looking for other fields,
2315 -- you don't have to worry whether there is a leading '[' or not
2316 ("Project name", cProjectName)
2317 -- Next come the settings, so anything else can be overridden
2318 -- in the settings file (as "lookup" uses the first match for the
2320 : rawSettings dflags
2321 ++ [("Project version", cProjectVersion),
2322 ("Booter version", cBooterVersion),
2324 ("Build platform", cBuildPlatformString),
2325 ("Host platform", cHostPlatformString),
2326 ("Target platform", cTargetPlatformString),
2327 ("Have interpreter", cGhcWithInterpreter),
2328 ("Object splitting supported", cSupportsSplitObjs),
2329 ("Have native code generator", cGhcWithNativeCodeGen),
2330 ("Support SMP", cGhcWithSMP),
2331 ("Unregisterised", cGhcUnregisterised),
2332 ("Tables next to code", cGhcEnableTablesNextToCode),
2333 ("RTS ways", cGhcRTSWays),
2334 ("Leading underscore", cLeadingUnderscore),
2335 ("Debug on", show debugIsOn),
2336 ("LibDir", topDir dflags),
2337 ("Global Package DB", systemPackageConfig dflags),
2338 ("Gcc Linker flags", show cGccLinkerOpts),
2339 ("Ld Linker flags", show cLdLinkerOpts)