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 System.FilePath
112 import System.IO ( stderr, hPutChar )
114 -- -----------------------------------------------------------------------------
117 -- | Enumerates the simple on-or-off dynamic flags
124 | Opt_D_dump_cmmz_pretty
125 -- All of the cmmz subflags (there are a lot!) Automatically
126 -- enabled if you run -ddump-cmmz
127 | Opt_D_dump_cmmz_cbe
128 | Opt_D_dump_cmmz_proc
129 | Opt_D_dump_cmmz_spills
130 | Opt_D_dump_cmmz_rewrite
131 | Opt_D_dump_cmmz_dead
132 | Opt_D_dump_cmmz_stub
134 | Opt_D_dump_cmmz_procmap
135 | Opt_D_dump_cmmz_split
136 | Opt_D_dump_cmmz_lower
137 | Opt_D_dump_cmmz_info
138 | Opt_D_dump_cmmz_cafs
143 | Opt_D_dump_asm_native
144 | Opt_D_dump_asm_liveness
145 | Opt_D_dump_asm_coalesce
146 | Opt_D_dump_asm_regalloc
147 | Opt_D_dump_asm_regalloc_stages
148 | Opt_D_dump_asm_conflicts
149 | Opt_D_dump_asm_stats
150 | Opt_D_dump_asm_expanded
152 | Opt_D_dump_core_stats
158 | Opt_D_dump_inlinings
159 | Opt_D_dump_rule_firings
160 | Opt_D_dump_rule_rewrites
161 | Opt_D_dump_occur_anal
165 | Opt_D_dump_simpl_iterations
166 | Opt_D_dump_simpl_phases
175 | Opt_D_dump_worker_wrapper
176 | Opt_D_dump_rn_trace
177 | Opt_D_dump_rn_stats
179 | Opt_D_dump_simpl_stats
180 | Opt_D_dump_cs_trace -- Constraint solver in type checker
181 | Opt_D_dump_tc_trace
182 | Opt_D_dump_if_trace
183 | Opt_D_dump_vt_trace
190 | Opt_D_verbose_core2core
191 | Opt_D_verbose_stg2stg
193 | Opt_D_dump_hi_diffs
194 | Opt_D_dump_minimal_imports
195 | Opt_D_dump_mod_cycles
196 | Opt_D_dump_view_pattern_commoning
197 | Opt_D_faststring_stats
198 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
199 | Opt_D_no_debug_output
205 | Opt_WarnIsError -- -Werror; makes warnings fatal
206 | Opt_WarnDuplicateExports
208 | Opt_WarnImplicitPrelude
209 | Opt_WarnIncompletePatterns
210 | Opt_WarnIncompleteUniPatterns
211 | Opt_WarnIncompletePatternsRecUpd
212 | Opt_WarnMissingFields
213 | Opt_WarnMissingImportList
214 | Opt_WarnMissingMethods
215 | Opt_WarnMissingSigs
216 | Opt_WarnMissingLocalSigs
217 | Opt_WarnNameShadowing
218 | Opt_WarnOverlappingPatterns
219 | Opt_WarnTypeDefaults
220 | Opt_WarnMonomorphism
221 | Opt_WarnUnusedBinds
222 | Opt_WarnUnusedImports
223 | Opt_WarnUnusedMatches
224 | Opt_WarnWarningsDeprecations
225 | Opt_WarnDeprecatedFlags
226 | Opt_WarnDodgyExports
227 | Opt_WarnDodgyImports
229 | Opt_WarnAutoOrphans
232 | Opt_WarnUnrecognisedPragmas
233 | Opt_WarnDodgyForeignImports
234 | Opt_WarnLazyUnliftedBindings
235 | Opt_WarnUnusedDoBind
236 | Opt_WarnWrongDoBind
237 | Opt_WarnAlternativeLayoutRuleTransitional
239 | Opt_PrintExplicitForalls
246 | Opt_StaticArgumentTransformation
250 | Opt_DoLambdaEtaExpansion
254 | Opt_UnboxStrictFields
255 | Opt_MethodSharing -- Now a no-op; remove in GHC 7.2
257 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
259 | Opt_RegsGraph -- do graph coloring register allocation
260 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
263 | Opt_IgnoreInterfacePragmas
264 | Opt_OmitInterfacePragmas
265 | Opt_ExposeAllUnfoldings
268 | Opt_AutoSccsOnAllToplevs
269 | Opt_AutoSccsOnExportedToplevs
270 | Opt_AutoSccsOnIndividualCafs
276 | Opt_ExcessPrecision
277 | Opt_EagerBlackHoling
278 | Opt_ReadUserPackageConf
282 | Opt_HideAllPackages
283 | Opt_PrintBindResult
287 | Opt_BreakOnException
289 | Opt_PrintEvldWithShow
290 | Opt_PrintBindContents
293 | Opt_EmitExternalCore
295 | Opt_BuildingCabalPackage
303 | Opt_ConvertToZipCfgAndBack
304 | Opt_AutoLinkPackages
305 | Opt_ImplicitImportQualified
313 | Opt_KeepRawTokenStream
318 data Language = Haskell98 | Haskell2010
322 | Opt_OverlappingInstances
323 | Opt_UndecidableInstances
324 | Opt_IncoherentInstances
325 | Opt_MonomorphismRestriction
328 | Opt_RelaxedPolyRec -- Deprecated
329 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
330 | Opt_ForeignFunctionInterface
331 | Opt_UnliftedFFITypes
332 | Opt_GHCForeignImportPrim
333 | Opt_ParallelArrays -- Syntactic support for parallel arrays
334 | Opt_Arrows -- Arrow-notation syntax
335 | Opt_TemplateHaskell
338 | Opt_Generics -- "Derivable type classes"
339 | Opt_ImplicitPrelude
340 | Opt_ScopedTypeVariables
344 | Opt_OverloadedStrings
345 | Opt_DisambiguateRecordFields
346 | Opt_RecordWildCards
352 | Opt_DoAndIfThenElse
353 | Opt_RebindableSyntax
355 | Opt_StandaloneDeriving
356 | Opt_DeriveDataTypeable
358 | Opt_DeriveTraversable
361 | Opt_TypeSynonymInstances
362 | Opt_FlexibleContexts
363 | Opt_FlexibleInstances
364 | Opt_ConstrainedClassMethods
365 | Opt_MultiParamTypeClasses
366 | Opt_FunctionalDependencies
368 | Opt_PolymorphicComponents
369 | Opt_ExistentialQuantification
373 | Opt_ParallelListComp
374 | Opt_TransformListComp
375 | Opt_MonadComprehensions
376 | Opt_GeneralizedNewtypeDeriving
379 | Opt_PostfixOperators
382 | Opt_LiberalTypeSynonyms
385 | Opt_ImpredicativeTypes
389 | Opt_AlternativeLayoutRule
390 | Opt_AlternativeLayoutRuleTransitional
391 | Opt_DatatypeContexts
392 | Opt_NondecreasingIndentation
396 -- | Contains not only a collection of 'DynFlag's but also a plethora of
397 -- information relating to the compilation of a single file or GHC session
398 data DynFlags = DynFlags {
401 hscTarget :: HscTarget,
402 hscOutName :: String, -- ^ Name of the output file
403 extCoreName :: String, -- ^ Name of the .hcr output file
404 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
405 optLevel :: Int, -- ^ Optimisation level
406 simplPhases :: Int, -- ^ Number of simplifier phases
407 maxSimplIterations :: Int, -- ^ Max simplifier iterations
408 shouldDumpSimplPhase :: Maybe String,
409 ruleCheck :: Maybe String,
410 strictnessBefore :: [Int], -- ^ Additional demand analysis
412 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
413 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
414 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
415 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
416 -- See CoreMonad.FloatOutSwitches
418 targetPlatform :: Platform.Platform, -- ^ The platform we're compiling for. Used by the NCG.
419 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
420 importPaths :: [FilePath],
422 mainFunIs :: Maybe String,
423 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
425 dphBackend :: DPHBackend,
427 thisPackage :: PackageId, -- ^ name of package currently being compiled
430 ways :: [Way], -- ^ Way flags from the command line
431 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
432 rtsBuildTag :: String, -- ^ The RTS \"way\"
434 -- For object splitting
435 splitInfo :: Maybe (String,Int),
438 objectDir :: Maybe String,
439 dylibInstallName :: Maybe String,
440 hiDir :: Maybe String,
441 stubDir :: Maybe String,
447 outputFile :: Maybe String,
448 outputHi :: Maybe String,
449 dynLibLoader :: DynLibLoader,
451 -- | This is set by 'DriverPipeline.runPipeline' based on where
452 -- its output is going.
453 dumpPrefix :: Maybe FilePath,
455 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
456 -- Set by @-ddump-file-prefix@
457 dumpPrefixForce :: Maybe FilePath,
459 includePaths :: [String],
460 libraryPaths :: [String],
461 frameworkPaths :: [String], -- used on darwin only
462 cmdlineFrameworks :: [String], -- ditto
464 rtsOpts :: Maybe String,
465 rtsOptsEnabled :: RtsOptsEnabled,
467 hpcDir :: String, -- ^ Path to store the .mix files
469 settings :: Settings,
472 depMakefile :: FilePath,
473 depIncludePkgDeps :: Bool,
474 depExcludeMods :: [ModuleName],
475 depSuffixes :: [String],
478 extraPkgConfs :: [FilePath],
479 -- ^ The @-package-conf@ flags given on the command line, in the order
482 packageFlags :: [PackageFlag],
483 -- ^ The @-package@ and @-hide-package@ flags from the command-line
486 -- NB. do not modify this field, it is calculated by
487 -- Packages.initPackages and Packages.updatePackages.
488 pkgDatabase :: Maybe [PackageConfig],
489 pkgState :: PackageState,
492 -- These have to be IORefs, because the defaultCleanupHandler needs to
493 -- know what to clean when an exception happens
494 filesToClean :: IORef [FilePath],
495 dirsToClean :: IORef (Map FilePath FilePath),
499 -- Don't change this without updating extensionFlags:
500 language :: Maybe Language,
501 -- Don't change this without updating extensionFlags:
502 extensions :: [OnOff ExtensionFlag],
503 -- extensionFlags should always be equal to
504 -- flattenExtensionFlags language extensions
505 extensionFlags :: [ExtensionFlag],
507 -- | Message output action: use "ErrUtils" instead of this if you can
508 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
510 haddockOptions :: Maybe String
513 data Settings = Settings {
514 sGhcUsagePath :: FilePath, -- Filled in by SysTools
515 sGhciUsagePath :: FilePath, -- ditto
517 sTmpDir :: String, -- no trailing '/'
518 -- You shouldn't need to look things up in rawSettings directly.
519 -- They should have their own fields instead.
520 sRawSettings :: [(String, String)],
521 sExtraGccViaCFlags :: [String],
522 sSystemPackageConfig :: FilePath,
523 -- commands for particular phases
525 sPgm_P :: (String,[Option]),
527 sPgm_c :: (String,[Option]),
528 sPgm_s :: (String,[Option]),
529 sPgm_a :: (String,[Option]),
530 sPgm_l :: (String,[Option]),
531 sPgm_dll :: (String,[Option]),
533 sPgm_sysman :: String,
534 sPgm_windres :: String,
535 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
536 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
537 -- options for particular phases
545 sOpt_windres :: [String],
546 sOpt_lo :: [String], -- LLVM: llvm optimiser
547 sOpt_lc :: [String] -- LLVM: llc static compiler
551 ghcUsagePath :: DynFlags -> FilePath
552 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
553 ghciUsagePath :: DynFlags -> FilePath
554 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
555 topDir :: DynFlags -> FilePath
556 topDir dflags = sTopDir (settings dflags)
557 tmpDir :: DynFlags -> String
558 tmpDir dflags = sTmpDir (settings dflags)
559 rawSettings :: DynFlags -> [(String, String)]
560 rawSettings dflags = sRawSettings (settings dflags)
561 extraGccViaCFlags :: DynFlags -> [String]
562 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
563 systemPackageConfig :: DynFlags -> FilePath
564 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
565 pgm_L :: DynFlags -> String
566 pgm_L dflags = sPgm_L (settings dflags)
567 pgm_P :: DynFlags -> (String,[Option])
568 pgm_P dflags = sPgm_P (settings dflags)
569 pgm_F :: DynFlags -> String
570 pgm_F dflags = sPgm_F (settings dflags)
571 pgm_c :: DynFlags -> (String,[Option])
572 pgm_c dflags = sPgm_c (settings dflags)
573 pgm_s :: DynFlags -> (String,[Option])
574 pgm_s dflags = sPgm_s (settings dflags)
575 pgm_a :: DynFlags -> (String,[Option])
576 pgm_a dflags = sPgm_a (settings dflags)
577 pgm_l :: DynFlags -> (String,[Option])
578 pgm_l dflags = sPgm_l (settings dflags)
579 pgm_dll :: DynFlags -> (String,[Option])
580 pgm_dll dflags = sPgm_dll (settings dflags)
581 pgm_T :: DynFlags -> String
582 pgm_T dflags = sPgm_T (settings dflags)
583 pgm_sysman :: DynFlags -> String
584 pgm_sysman dflags = sPgm_sysman (settings dflags)
585 pgm_windres :: DynFlags -> String
586 pgm_windres dflags = sPgm_windres (settings dflags)
587 pgm_lo :: DynFlags -> (String,[Option])
588 pgm_lo dflags = sPgm_lo (settings dflags)
589 pgm_lc :: DynFlags -> (String,[Option])
590 pgm_lc dflags = sPgm_lc (settings dflags)
591 opt_L :: DynFlags -> [String]
592 opt_L dflags = sOpt_L (settings dflags)
593 opt_P :: DynFlags -> [String]
594 opt_P dflags = sOpt_P (settings dflags)
595 opt_F :: DynFlags -> [String]
596 opt_F dflags = sOpt_F (settings dflags)
597 opt_c :: DynFlags -> [String]
598 opt_c dflags = sOpt_c (settings dflags)
599 opt_m :: DynFlags -> [String]
600 opt_m dflags = sOpt_m (settings dflags)
601 opt_a :: DynFlags -> [String]
602 opt_a dflags = sOpt_a (settings dflags)
603 opt_l :: DynFlags -> [String]
604 opt_l dflags = sOpt_l (settings dflags)
605 opt_windres :: DynFlags -> [String]
606 opt_windres dflags = sOpt_windres (settings dflags)
607 opt_lo :: DynFlags -> [String]
608 opt_lo dflags = sOpt_lo (settings dflags)
609 opt_lc :: DynFlags -> [String]
610 opt_lc dflags = sOpt_lc (settings dflags)
612 wayNames :: DynFlags -> [WayName]
613 wayNames = map wayName . ways
615 -- | The target code type of the compilation (if any).
617 -- Whenever you change the target, also make sure to set 'ghcLink' to
618 -- something sensible.
620 -- 'HscNothing' can be used to avoid generating any output, however, note
623 -- * This will not run the desugaring step, thus no warnings generated in
624 -- this step will be output. In particular, this includes warnings related
625 -- to pattern matching. You can run the desugarer manually using
626 -- 'GHC.desugarModule'.
628 -- * If a program uses Template Haskell the typechecker may try to run code
629 -- from an imported module. This will fail if no code has been generated
630 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
631 -- whether this might be the case and choose to either switch to a
632 -- different target or avoid typechecking such modules. (The latter may
633 -- preferable for security reasons.)
636 = HscC -- ^ Generate C code.
637 | HscAsm -- ^ Generate assembly using the native code generator.
638 | HscLlvm -- ^ Generate assembly using the llvm code generator.
639 | HscJava -- ^ Generate Java bytecode.
640 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
641 | HscNothing -- ^ Don't generate any code. See notes above.
644 showHscTargetFlag :: HscTarget -> String
645 showHscTargetFlag HscC = "-fvia-c"
646 showHscTargetFlag HscAsm = "-fasm"
647 showHscTargetFlag HscLlvm = "-fllvm"
648 showHscTargetFlag HscJava = panic "No flag for HscJava"
649 showHscTargetFlag HscInterpreted = "-fbyte-code"
650 showHscTargetFlag HscNothing = "-fno-code"
652 -- | Will this target result in an object file on the disk?
653 isObjectTarget :: HscTarget -> Bool
654 isObjectTarget HscC = True
655 isObjectTarget HscAsm = True
656 isObjectTarget HscLlvm = True
657 isObjectTarget _ = False
659 -- | The 'GhcMode' tells us whether we're doing multi-module
660 -- compilation (controlled via the "GHC" API) or one-shot
661 -- (single-module) compilation. This makes a difference primarily to
662 -- the "Finder": in one-shot mode we look for interface files for
663 -- imported modules, but in multi-module mode we look for source files
664 -- in order to check whether they need to be recompiled.
666 = CompManager -- ^ @\-\-make@, GHCi, etc.
667 | OneShot -- ^ @ghc -c Foo.hs@
668 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
671 instance Outputable GhcMode where
672 ppr CompManager = ptext (sLit "CompManager")
673 ppr OneShot = ptext (sLit "OneShot")
674 ppr MkDepend = ptext (sLit "MkDepend")
676 isOneShot :: GhcMode -> Bool
677 isOneShot OneShot = True
678 isOneShot _other = False
680 -- | What to do in the link step, if there is one.
682 = NoLink -- ^ Don't link at all
683 | LinkBinary -- ^ Link object code into a binary
684 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
685 -- bytecode and object code).
686 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
689 isNoLink :: GhcLink -> Bool
690 isNoLink NoLink = True
693 -- Is it worth evaluating this Bool and caching it in the DynFlags value
694 -- during initDynFlags?
695 doingTickyProfiling :: DynFlags -> Bool
696 doingTickyProfiling _ = opt_Ticky
697 -- XXX -ticky is a static flag, because it implies -debug which is also
698 -- static. If the way flags were made dynamic, we could fix this.
701 = ExposePackage String
702 | ExposePackageId String
704 | IgnorePackage String
707 defaultHscTarget :: HscTarget
708 defaultHscTarget = defaultObjectTarget
710 -- | The 'HscTarget' value corresponding to the default way to create
711 -- object files on the current platform.
712 defaultObjectTarget :: HscTarget
714 | cGhcUnregisterised == "YES" = HscC
715 | cGhcWithNativeCodeGen == "YES" = HscAsm
716 | otherwise = HscLlvm
723 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
726 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
727 initDynFlags :: DynFlags -> IO DynFlags
728 initDynFlags dflags = do
729 -- someday these will be dynamic flags
730 ways <- readIORef v_Ways
731 refFilesToClean <- newIORef []
732 refDirsToClean <- newIORef Map.empty
735 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
736 rtsBuildTag = mkBuildTag ways,
737 filesToClean = refFilesToClean,
738 dirsToClean = refDirsToClean
741 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
742 -- and must be fully initialized by 'GHC.newSession' first.
743 defaultDynFlags :: Settings -> DynFlags
744 defaultDynFlags mySettings =
746 ghcMode = CompManager,
747 ghcLink = LinkBinary,
748 hscTarget = defaultHscTarget,
754 maxSimplIterations = 4,
755 shouldDumpSimplPhase = Nothing,
757 specConstrThreshold = Just 200,
758 specConstrCount = Just 3,
759 liberateCaseThreshold = Just 200,
760 floatLamArgs = Just 0, -- Default: float only if no fvs
761 strictnessBefore = [],
763 targetPlatform = defaultTargetPlatform,
764 cmdlineHcIncludes = [],
768 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
770 dphBackend = DPHNone,
772 thisPackage = mainPackageId,
775 dylibInstallName = Nothing,
779 objectSuf = phaseInputExt StopLn,
780 hcSuf = phaseInputExt HCc,
783 outputFile = Nothing,
785 dynLibLoader = SystemDependent,
786 dumpPrefix = Nothing,
787 dumpPrefixForce = Nothing,
791 cmdlineFrameworks = [],
793 rtsOptsEnabled = RtsOptsSafeOnly,
799 pkgDatabase = Nothing,
800 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
801 ways = panic "defaultDynFlags: No ways",
802 buildTag = panic "defaultDynFlags: No buildTag",
803 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
805 settings = mySettings,
807 depMakefile = "Makefile",
808 depIncludePkgDeps = False,
811 -- end of ghc -M values
812 filesToClean = panic "defaultDynFlags: No filesToClean",
813 dirsToClean = panic "defaultDynFlags: No dirsToClean",
814 haddockOptions = Nothing,
815 flags = defaultFlags,
818 extensionFlags = flattenExtensionFlags Nothing [],
820 log_action = \severity srcSpan style msg ->
822 SevOutput -> printSDoc msg style
823 SevInfo -> printErrs msg style
824 SevFatal -> printErrs msg style
827 printErrs (mkLocMessage srcSpan msg) style
828 -- careful (#2302): printErrs prints in UTF-8, whereas
829 -- converting to string first and using hPutStr would
830 -- just emit the low 8 bits of each unicode char.
834 Note [Verbosity levels]
835 ~~~~~~~~~~~~~~~~~~~~~~~
836 0 | print errors & warnings only
837 1 | minimal verbosity: print "compiling M ... done." for each module.
838 2 | equivalent to -dshow-passes
839 3 | equivalent to existing "ghc -v"
840 4 | "ghc -v -ddump-most"
841 5 | "ghc -v -ddump-all"
847 -- OnOffs accumulate in reverse order, so we use foldr in order to
848 -- process them in the right order
849 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
851 flattenExtensionFlags ml = foldr f defaultExtensionFlags
852 where f (On f) flags = f : delete f flags
853 f (Off f) flags = delete f flags
854 defaultExtensionFlags = languageExtensions ml
856 languageExtensions :: Maybe Language -> [ExtensionFlag]
858 languageExtensions Nothing
859 -- Nothing => the default case
860 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
861 -- behaviour the default, to see if anyone notices
863 -- In due course I'd like Opt_MonoLocalBinds to be on by default
864 -- But NB it's implied by GADTs etc
865 -- SLPJ September 2010
866 : Opt_NondecreasingIndentation -- This has been on by default for some time
867 : languageExtensions (Just Haskell2010)
869 languageExtensions (Just Haskell98)
870 = [Opt_ImplicitPrelude,
871 Opt_MonomorphismRestriction,
873 Opt_DatatypeContexts,
874 Opt_NondecreasingIndentation
875 -- strictly speaking non-standard, but we always had this
876 -- on implicitly before the option was added in 7.1, and
877 -- turning it off breaks code, so we're keeping it on for
878 -- backwards compatibility. Cabal uses -XHaskell98 by
879 -- default unless you specify another language.
882 languageExtensions (Just Haskell2010)
883 = [Opt_ImplicitPrelude,
884 Opt_MonomorphismRestriction,
885 Opt_DatatypeContexts,
887 Opt_ForeignFunctionInterface,
892 -- | Test whether a 'DynFlag' is set
893 dopt :: DynFlag -> DynFlags -> Bool
894 dopt f dflags = f `elem` (flags dflags)
897 dopt_set :: DynFlags -> DynFlag -> DynFlags
898 dopt_set dfs f = dfs{ flags = f : flags dfs }
900 -- | Unset a 'DynFlag'
901 dopt_unset :: DynFlags -> DynFlag -> DynFlags
902 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
904 -- | Test whether a 'ExtensionFlag' is set
905 xopt :: ExtensionFlag -> DynFlags -> Bool
906 xopt f dflags = f `elem` extensionFlags dflags
908 -- | Set a 'ExtensionFlag'
909 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
911 = let onoffs = On f : extensions dfs
912 in dfs { extensions = onoffs,
913 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
915 -- | Unset a 'ExtensionFlag'
916 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
918 = let onoffs = Off f : extensions dfs
919 in dfs { extensions = onoffs,
920 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
922 setLanguage :: Language -> DynP ()
923 setLanguage l = upd f
924 where f dfs = let mLang = Just l
925 oneoffs = extensions dfs
928 extensionFlags = flattenExtensionFlags mLang oneoffs
931 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
932 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
933 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
934 -> [a] -- ^ Correctly ordered extracted options
935 getOpts dflags opts = reverse (opts dflags)
936 -- We add to the options from the front, so we need to reverse the list
938 -- | Gets the verbosity flag for the current verbosity level. This is fed to
939 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
940 getVerbFlags :: DynFlags -> [String]
942 | verbosity dflags >= 4 = ["-v"]
945 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
946 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
947 setPgmP, addOptl, addOptP,
948 addCmdlineFramework, addHaddockOpts
949 :: String -> DynFlags -> DynFlags
950 setOutputFile, setOutputHi, setDumpPrefixForce
951 :: Maybe String -> DynFlags -> DynFlags
953 setObjectDir f d = d{ objectDir = Just f}
954 setHiDir f d = d{ hiDir = Just f}
955 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
956 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
957 -- \#included from the .hc file when compiling via C (i.e. unregisterised
959 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
960 setDylibInstallName f d = d{ dylibInstallName = Just f}
962 setObjectSuf f d = d{ objectSuf = f}
963 setHiSuf f d = d{ hiSuf = f}
964 setHcSuf f d = d{ hcSuf = f}
966 setOutputFile f d = d{ outputFile = f}
967 setOutputHi f d = d{ outputHi = f}
969 parseDynLibLoaderMode f d =
971 ("deploy", "") -> d{ dynLibLoader = Deployable }
972 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
973 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
975 setDumpPrefixForce f d = d { dumpPrefixForce = f}
977 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
978 -- Config.hs should really use Option.
979 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
980 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
981 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
984 setDepMakefile :: FilePath -> DynFlags -> DynFlags
985 setDepMakefile f d = d { depMakefile = deOptDep f }
987 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
988 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
990 addDepExcludeMod :: String -> DynFlags -> DynFlags
992 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
994 addDepSuffix :: FilePath -> DynFlags -> DynFlags
995 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
998 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
999 -- we need to strip the "-optdep" off of the arg
1000 deOptDep :: String -> String
1001 deOptDep x = case stripPrefix "-optdep" x of
1005 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1007 addHaddockOpts f d = d{ haddockOptions = Just f}
1009 -- -----------------------------------------------------------------------------
1010 -- Command-line options
1012 -- | When invoking external tools as part of the compilation pipeline, we
1013 -- pass these a sequence of options on the command-line. Rather than
1014 -- just using a list of Strings, we use a type that allows us to distinguish
1015 -- between filepaths and 'other stuff'. The reason for this is that
1016 -- this type gives us a handle on transforming filenames, and filenames only,
1017 -- to whatever format they're expected to be on a particular platform.
1019 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1020 String -- a non-filepath prefix that shouldn't be
1021 -- transformed (e.g., "/out=")
1022 String -- the filepath/filename portion
1025 showOpt :: Option -> String
1026 showOpt (FileOption pre f) = pre ++ f
1027 showOpt (Option s) = s
1029 -----------------------------------------------------------------------------
1030 -- Setting the optimisation level
1032 updOptLevel :: Int -> DynFlags -> DynFlags
1033 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1035 = dfs2{ optLevel = final_n }
1037 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1038 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1039 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1041 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1042 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1044 -- -----------------------------------------------------------------------------
1045 -- StgToDo: abstraction of stg-to-stg passes to run.
1048 = StgDoMassageForProfiling -- should be (next to) last
1049 -- There's also setStgVarInfo, but its absolute "lastness"
1050 -- is so critical that it is hardwired in (no flag).
1053 getStgToDo :: DynFlags -> [StgToDo]
1057 stg_stats = dopt Opt_StgStats dflags
1059 todo1 = if stg_stats then [D_stg_stats] else []
1061 todo2 | WayProf `elem` wayNames dflags
1062 = StgDoMassageForProfiling : todo1
1066 {- **********************************************************************
1070 %********************************************************************* -}
1072 -- -----------------------------------------------------------------------------
1073 -- Parsing the dynamic flags.
1075 -- | Parse dynamic flags from a list of command line arguments. Returns the
1076 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1077 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1078 -- flags or missing arguments).
1079 parseDynamicFlags :: Monad m =>
1080 DynFlags -> [Located String]
1081 -> m (DynFlags, [Located String], [Located String])
1082 -- ^ Updated 'DynFlags', left-over arguments, and
1083 -- list of warnings.
1084 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1086 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1087 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1088 parseDynamicNoPackageFlags :: Monad m =>
1089 DynFlags -> [Located String]
1090 -> m (DynFlags, [Located String], [Located String])
1091 -- ^ Updated 'DynFlags', left-over arguments, and
1092 -- list of warnings.
1093 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1095 parseDynamicFlags_ :: Monad m =>
1096 DynFlags -> [Located String] -> Bool
1097 -> m (DynFlags, [Located String], [Located String])
1098 parseDynamicFlags_ dflags0 args pkg_flags = do
1099 -- XXX Legacy support code
1100 -- We used to accept things like
1101 -- optdep-f -optdepdepend
1102 -- optdep-f -optdep depend
1103 -- optdep -f -optdepdepend
1104 -- optdep -f -optdep depend
1105 -- but the spaces trip up proper argument handling. So get rid of them.
1106 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1107 f (x : xs) = x : f xs
1111 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1112 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1113 | otherwise = dynamic_flags
1115 let ((leftover, errs, warns), dflags1)
1116 = runCmdLine (processArgs flag_spec args') dflags0
1117 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1119 return (dflags1, leftover, warns)
1122 {- **********************************************************************
1124 DynFlags specifications
1126 %********************************************************************* -}
1128 allFlags :: [String]
1129 allFlags = map ('-':) $
1130 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1131 map ("fno-"++) flags ++
1132 map ("f"++) flags ++
1133 map ("f"++) flags' ++
1134 map ("X"++) supportedExtensions
1135 where ok (PrefixPred _ _) = False
1137 flags = [ name | (name, _, _) <- fFlags ]
1138 flags' = [ name | (name, _, _) <- fLangFlags ]
1140 --------------- The main flags themselves ------------------
1141 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1143 Flag "n" (NoArg (setDynFlag Opt_DryRun))
1144 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1145 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1147 (HasArg (\s -> do { addCmdlineHCInclude s
1148 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1149 , Flag "v" (OptIntSuffix setVerbosity)
1151 ------- Specific phases --------------------------------------------
1152 -- need to appear before -pgmL to be parsed as LLVM flags.
1153 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1154 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1155 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1156 , Flag "pgmP" (hasArg setPgmP)
1157 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1158 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1159 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1160 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1161 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1162 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1163 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1164 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1166 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1167 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1168 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1169 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1170 , Flag "optP" (hasArg addOptP)
1171 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1172 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1173 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1174 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1175 , Flag "optl" (hasArg addOptl)
1176 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1179 (NoArg (if can_split
1180 then setDynFlag Opt_SplitObjs
1181 else addWarn "ignoring -fsplit-objs"))
1183 -------- ghc -M -----------------------------------------------------
1184 , Flag "dep-suffix" (hasArg addDepSuffix)
1185 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1186 , Flag "dep-makefile" (hasArg setDepMakefile)
1187 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1188 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1189 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1190 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1191 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1192 , Flag "exclude-module" (hasArg addDepExcludeMod)
1193 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1194 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1196 -------- Linking ----------------------------------------------------
1197 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1198 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1199 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1200 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1202 ------- Libraries ---------------------------------------------------
1203 , Flag "L" (Prefix addLibraryPath)
1204 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1206 ------- Frameworks --------------------------------------------------
1207 -- -framework-path should really be -F ...
1208 , Flag "framework-path" (HasArg addFrameworkPath)
1209 , Flag "framework" (hasArg addCmdlineFramework)
1211 ------- Output Redirection ------------------------------------------
1212 , Flag "odir" (hasArg setObjectDir)
1213 , Flag "o" (SepArg (upd . setOutputFile . Just))
1214 , Flag "ohi" (hasArg (setOutputHi . Just ))
1215 , Flag "osuf" (hasArg setObjectSuf)
1216 , Flag "hcsuf" (hasArg setHcSuf)
1217 , Flag "hisuf" (hasArg setHiSuf)
1218 , Flag "hidir" (hasArg setHiDir)
1219 , Flag "tmpdir" (hasArg setTmpDir)
1220 , Flag "stubdir" (hasArg setStubDir)
1221 , Flag "outputdir" (hasArg setOutputDir)
1222 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1224 ------- Keeping temporary files -------------------------------------
1225 -- These can be singular (think ghc -c) or plural (think ghc --make)
1226 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1227 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1228 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1229 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1230 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1231 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1232 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1233 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1234 -- This only makes sense as plural
1235 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1237 ------- Miscellaneous ----------------------------------------------
1238 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1239 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1240 , Flag "with-rtsopts" (HasArg setRtsOpts)
1241 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1242 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1243 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1244 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1245 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1246 , Flag "main-is" (SepArg setMainIs)
1247 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1248 , Flag "haddock-opts" (hasArg addHaddockOpts)
1249 , Flag "hpcdir" (SepArg setOptHpcDir)
1251 ------- recompilation checker --------------------------------------
1252 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1253 ; deprecate "Use -fno-force-recomp instead" }))
1254 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1255 ; deprecate "Use -fforce-recomp instead" }))
1257 ------ HsCpp opts ---------------------------------------------------
1258 , Flag "D" (AnySuffix (upd . addOptP))
1259 , Flag "U" (AnySuffix (upd . addOptP))
1261 ------- Include/Import Paths ----------------------------------------
1262 , Flag "I" (Prefix addIncludePath)
1263 , Flag "i" (OptPrefix addImportPath)
1265 ------ Debugging ----------------------------------------------------
1266 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1268 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1269 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1270 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1271 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1272 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1273 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1274 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1275 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1276 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1277 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1278 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1279 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1280 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1281 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1282 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1283 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1284 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1285 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1286 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1287 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1288 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1289 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1290 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1291 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1292 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1293 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1294 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1295 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1296 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1297 ; setDumpFlag' Opt_D_dump_llvm}))
1298 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1299 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1300 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1301 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1302 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1303 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1304 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1305 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1306 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1307 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1308 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1309 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1310 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1311 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1312 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1313 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1314 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1315 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1316 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1317 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1318 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1319 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1320 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1321 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1322 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1323 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1324 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1325 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1326 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1327 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1328 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1329 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1330 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1331 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1332 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1333 ; setVerboseCore2Core }))
1334 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1335 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1336 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1337 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1338 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1339 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1340 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1341 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1342 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1343 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1344 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1345 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1346 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1347 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1348 , Flag "dshow-passes" (NoArg (do forceRecompile
1349 setVerbosity (Just 2)))
1350 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1352 ------ Machine dependant (-m<blah>) stuff ---------------------------
1354 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1355 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1356 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1357 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1359 ------ Warning opts -------------------------------------------------
1360 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1361 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1362 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1363 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1364 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1365 ; deprecate "Use -w instead" }))
1366 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1368 ------ Optimisation flags ------------------------------------------
1369 , Flag "O" (noArgM (setOptLevel 1))
1370 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1371 setOptLevel 0 dflags))
1372 , Flag "Odph" (noArgM setDPHOpt)
1373 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1374 -- If the number is missing, use 1
1376 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1377 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1378 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1379 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1380 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1381 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1382 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1383 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1384 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1385 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1386 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1387 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1388 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1390 ------ Profiling ----------------------------------------------------
1392 -- XXX Should the -f* flags be deprecated?
1393 -- They don't seem to be documented
1394 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1395 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1396 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1397 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1398 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1399 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1400 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1401 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1402 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1404 ------ DPH flags ----------------------------------------------------
1406 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1407 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1408 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1409 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1411 ------ Compiler flags -----------------------------------------------
1413 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1414 , Flag "fvia-c" (NoArg
1415 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1416 , Flag "fvia-C" (NoArg
1417 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1418 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1420 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1421 setTarget HscNothing))
1422 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1423 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1424 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1425 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1427 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1428 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1429 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1430 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1431 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1432 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1433 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1435 package_flags :: [Flag (CmdLineP DynFlags)]
1437 ------- Packages ----------------------------------------------------
1438 Flag "package-conf" (HasArg extraPkgConf_)
1439 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1440 , Flag "package-name" (hasArg setPackageName)
1441 , Flag "package-id" (HasArg exposePackageId)
1442 , Flag "package" (HasArg exposePackage)
1443 , Flag "hide-package" (HasArg hidePackage)
1444 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1445 , Flag "ignore-package" (HasArg ignorePackage)
1446 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1447 ; deprecate "Use -package instead" }))
1450 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1451 -- False <=> we are turning the flag off
1452 turnOn :: TurnOnFlag; turnOn = True
1453 turnOff :: TurnOnFlag; turnOff = False
1456 = ( String -- Flag in string form
1457 , flag -- Flag in internal form
1458 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1459 -- Typically, emit a warning or error
1461 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1462 -> String -- ^ The flag prefix
1463 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1464 -> FlagSpec flag -- ^ Specification of this particular flag
1465 -> Flag (CmdLineP DynFlags)
1466 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1467 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1469 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1470 deprecatedForExtension lang turn_on
1471 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1473 flag | turn_on = lang
1474 | otherwise = "No"++lang
1476 useInstead :: String -> TurnOnFlag -> DynP ()
1477 useInstead flag turn_on
1478 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1480 no = if turn_on then "" else "no-"
1482 nop :: TurnOnFlag -> DynP ()
1485 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1486 fFlags :: [FlagSpec DynFlag]
1488 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1489 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1490 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1491 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1492 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1493 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1494 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1495 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1496 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1497 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1498 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1499 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1500 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1501 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1502 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1503 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1504 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1505 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1506 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1507 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1508 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1509 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1510 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1511 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1512 ( "warn-orphans", Opt_WarnOrphans, nop ),
1513 ( "warn-identities", Opt_WarnIdentities, nop ),
1514 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1515 ( "warn-tabs", Opt_WarnTabs, nop ),
1516 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1517 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1518 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1519 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1520 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1521 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1522 ( "strictness", Opt_Strictness, nop ),
1523 ( "specialise", Opt_Specialise, nop ),
1524 ( "float-in", Opt_FloatIn, nop ),
1525 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1526 ( "full-laziness", Opt_FullLaziness, nop ),
1527 ( "liberate-case", Opt_LiberateCase, nop ),
1528 ( "spec-constr", Opt_SpecConstr, nop ),
1529 ( "cse", Opt_CSE, nop ),
1530 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1531 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1532 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1533 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1534 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1535 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1536 ( "case-merge", Opt_CaseMerge, nop ),
1537 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1538 ( "method-sharing", Opt_MethodSharing,
1539 \_ -> deprecate "doesn't do anything any more"),
1540 -- Remove altogether in GHC 7.2
1541 ( "dicts-cheap", Opt_DictsCheap, nop ),
1542 ( "excess-precision", Opt_ExcessPrecision, nop ),
1543 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1544 ( "print-bind-result", Opt_PrintBindResult, nop ),
1545 ( "force-recomp", Opt_ForceRecomp, nop ),
1546 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1547 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1548 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1549 ( "break-on-exception", Opt_BreakOnException, nop ),
1550 ( "break-on-error", Opt_BreakOnError, nop ),
1551 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1552 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1553 ( "run-cps", Opt_RunCPS, nop ),
1554 ( "run-cpsz", Opt_RunCPSZ, nop ),
1555 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1556 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1557 ( "vectorise", Opt_Vectorise, nop ),
1558 ( "regs-graph", Opt_RegsGraph, nop ),
1559 ( "regs-iterative", Opt_RegsIterative, nop ),
1560 ( "gen-manifest", Opt_GenManifest, nop ),
1561 ( "embed-manifest", Opt_EmbedManifest, nop ),
1562 ( "ext-core", Opt_EmitExternalCore, nop ),
1563 ( "shared-implib", Opt_SharedImplib, nop ),
1564 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1565 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1566 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1567 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1570 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1571 fLangFlags :: [FlagSpec ExtensionFlag]
1573 ( "th", Opt_TemplateHaskell,
1574 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1575 ( "fi", Opt_ForeignFunctionInterface,
1576 deprecatedForExtension "ForeignFunctionInterface" ),
1577 ( "ffi", Opt_ForeignFunctionInterface,
1578 deprecatedForExtension "ForeignFunctionInterface" ),
1579 ( "arrows", Opt_Arrows,
1580 deprecatedForExtension "Arrows" ),
1581 ( "generics", Opt_Generics,
1582 deprecatedForExtension "Generics" ),
1583 ( "implicit-prelude", Opt_ImplicitPrelude,
1584 deprecatedForExtension "ImplicitPrelude" ),
1585 ( "bang-patterns", Opt_BangPatterns,
1586 deprecatedForExtension "BangPatterns" ),
1587 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1588 deprecatedForExtension "MonomorphismRestriction" ),
1589 ( "mono-pat-binds", Opt_MonoPatBinds,
1590 deprecatedForExtension "MonoPatBinds" ),
1591 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1592 deprecatedForExtension "ExtendedDefaultRules" ),
1593 ( "implicit-params", Opt_ImplicitParams,
1594 deprecatedForExtension "ImplicitParams" ),
1595 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1596 deprecatedForExtension "ScopedTypeVariables" ),
1597 ( "parr", Opt_ParallelArrays,
1598 deprecatedForExtension "ParallelArrays" ),
1599 ( "PArr", Opt_ParallelArrays,
1600 deprecatedForExtension "ParallelArrays" ),
1601 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1602 deprecatedForExtension "OverlappingInstances" ),
1603 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1604 deprecatedForExtension "UndecidableInstances" ),
1605 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1606 deprecatedForExtension "IncoherentInstances" )
1609 supportedLanguages :: [String]
1610 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1612 supportedExtensions :: [String]
1613 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1615 supportedLanguagesAndExtensions :: [String]
1616 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1618 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1619 languageFlags :: [FlagSpec Language]
1621 ( "Haskell98", Haskell98, nop ),
1622 ( "Haskell2010", Haskell2010, nop )
1625 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1626 xFlags :: [FlagSpec ExtensionFlag]
1628 ( "CPP", Opt_Cpp, nop ),
1629 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1630 ( "TupleSections", Opt_TupleSections, nop ),
1631 ( "PatternGuards", Opt_PatternGuards, nop ),
1632 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1633 ( "MagicHash", Opt_MagicHash, nop ),
1634 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1635 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1636 ( "KindSignatures", Opt_KindSignatures, nop ),
1637 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1638 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1639 ( "TransformListComp", Opt_TransformListComp, nop ),
1640 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1641 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1642 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1643 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1644 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1645 ( "Rank2Types", Opt_Rank2Types, nop ),
1646 ( "RankNTypes", Opt_RankNTypes, nop ),
1647 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1648 ( "TypeOperators", Opt_TypeOperators, nop ),
1649 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1650 deprecatedForExtension "DoRec"),
1651 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1652 ( "Arrows", Opt_Arrows, nop ),
1653 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1654 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1655 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1656 ( "Generics", Opt_Generics, nop ),
1657 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1658 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1659 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1660 ( "RecordPuns", Opt_RecordPuns,
1661 deprecatedForExtension "NamedFieldPuns" ),
1662 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1663 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1664 ( "GADTs", Opt_GADTs, nop ),
1665 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1666 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1667 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1668 ( "BangPatterns", Opt_BangPatterns, nop ),
1669 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1670 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1671 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1672 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1673 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1674 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1675 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1676 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1677 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1678 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1679 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1680 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1681 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1682 \ turn_on -> if not turn_on
1683 then deprecate "You can't turn off RelaxedPolyRec any more"
1685 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1686 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1687 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1689 ( "PatternSignatures", Opt_ScopedTypeVariables,
1690 deprecatedForExtension "ScopedTypeVariables" ),
1692 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1693 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1694 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1695 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1696 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1697 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1698 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1699 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1700 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1701 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1702 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1703 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1704 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1705 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1706 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1707 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1708 ( "PackageImports", Opt_PackageImports, nop )
1711 defaultFlags :: [DynFlag]
1713 = [ Opt_AutoLinkPackages,
1714 Opt_ReadUserPackageConf,
1718 #if GHC_DEFAULT_NEW_CODEGEN
1724 Opt_PrintBindContents,
1729 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1730 -- The default -O0 options
1734 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1736 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1737 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1738 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1739 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1740 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1741 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1742 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1743 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1745 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1747 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1748 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1749 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1751 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1752 -- all over the place
1754 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1756 -- Record wild-cards implies field disambiguation
1757 -- Otherwise if you write (C {..}) you may well get
1758 -- stuff like " 'a' not in scope ", which is a bit silly
1759 -- if the compiler has just filled in field 'a' of constructor 'C'
1760 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1762 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1765 optLevelFlags :: [([Int], DynFlag)]
1767 = [ ([0], Opt_IgnoreInterfacePragmas)
1768 , ([0], Opt_OmitInterfacePragmas)
1770 , ([1,2], Opt_IgnoreAsserts)
1771 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1773 , ([1,2], Opt_DoEtaReduction)
1774 , ([1,2], Opt_CaseMerge)
1775 , ([1,2], Opt_Strictness)
1777 , ([1,2], Opt_FullLaziness)
1778 , ([1,2], Opt_Specialise)
1779 , ([1,2], Opt_FloatIn)
1781 , ([2], Opt_LiberateCase)
1782 , ([2], Opt_SpecConstr)
1783 , ([2], Opt_RegsGraph)
1785 -- , ([2], Opt_StaticArgumentTransformation)
1786 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1787 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1788 -- several improvements to the heuristics, and I'm concerned that without
1789 -- those changes SAT will interfere with some attempts to write "high
1790 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1791 -- this year. In particular, the version in HEAD lacks the tail call
1792 -- criterion, so many things that look like reasonable loops will be
1793 -- turned into functions with extra (unneccesary) thunk creation.
1795 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1796 -- This one is important for a tiresome reason:
1797 -- we want to make sure that the bindings for data
1798 -- constructors are eta-expanded. This is probably
1799 -- a good thing anyway, but it seems fragile.
1802 -- -----------------------------------------------------------------------------
1803 -- Standard sets of warning options
1805 standardWarnings :: [DynFlag]
1807 = [ Opt_WarnWarningsDeprecations,
1808 Opt_WarnDeprecatedFlags,
1809 Opt_WarnUnrecognisedPragmas,
1810 Opt_WarnOverlappingPatterns,
1811 Opt_WarnMissingFields,
1812 Opt_WarnMissingMethods,
1813 Opt_WarnDuplicateExports,
1814 Opt_WarnLazyUnliftedBindings,
1815 Opt_WarnDodgyForeignImports,
1816 Opt_WarnWrongDoBind,
1817 Opt_WarnAlternativeLayoutRuleTransitional
1820 minusWOpts :: [DynFlag]
1821 -- Things you get with -W
1823 = standardWarnings ++
1824 [ Opt_WarnUnusedBinds,
1825 Opt_WarnUnusedMatches,
1826 Opt_WarnUnusedImports,
1827 Opt_WarnIncompletePatterns,
1828 Opt_WarnDodgyExports,
1829 Opt_WarnDodgyImports
1832 minusWallOpts :: [DynFlag]
1833 -- Things you get with -Wall
1836 [ Opt_WarnTypeDefaults,
1837 Opt_WarnNameShadowing,
1838 Opt_WarnMissingSigs,
1841 Opt_WarnUnusedDoBind
1844 minuswRemovesOpts :: [DynFlag]
1845 -- minuswRemovesOpts should be every warning option
1849 Opt_WarnIncompletePatternsRecUpd,
1850 Opt_WarnIncompleteUniPatterns,
1851 Opt_WarnMonomorphism,
1852 Opt_WarnUnrecognisedPragmas,
1853 Opt_WarnAutoOrphans,
1854 Opt_WarnImplicitPrelude
1857 enableGlasgowExts :: DynP ()
1858 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1859 mapM_ setExtensionFlag glasgowExtsFlags
1861 disableGlasgowExts :: DynP ()
1862 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1863 mapM_ unSetExtensionFlag glasgowExtsFlags
1865 glasgowExtsFlags :: [ExtensionFlag]
1866 glasgowExtsFlags = [
1867 Opt_ForeignFunctionInterface
1868 , Opt_UnliftedFFITypes
1869 , Opt_ImplicitParams
1870 , Opt_ScopedTypeVariables
1872 , Opt_TypeSynonymInstances
1873 , Opt_StandaloneDeriving
1874 , Opt_DeriveDataTypeable
1876 , Opt_DeriveFoldable
1877 , Opt_DeriveTraversable
1878 , Opt_FlexibleContexts
1879 , Opt_FlexibleInstances
1880 , Opt_ConstrainedClassMethods
1881 , Opt_MultiParamTypeClasses
1882 , Opt_FunctionalDependencies
1884 , Opt_PolymorphicComponents
1885 , Opt_ExistentialQuantification
1887 , Opt_PostfixOperators
1889 , Opt_LiberalTypeSynonyms
1893 , Opt_ParallelListComp
1894 , Opt_EmptyDataDecls
1895 , Opt_KindSignatures
1896 , Opt_GeneralizedNewtypeDeriving ]
1899 -- Consult the RTS to find whether GHC itself has been built profiled
1900 -- If so, you can't use Template Haskell
1901 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1903 rtsIsProfiled :: Bool
1904 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1907 checkTemplateHaskellOk :: Bool -> DynP ()
1909 checkTemplateHaskellOk turn_on
1910 | turn_on && rtsIsProfiled
1911 = addErr "You can't use Template Haskell with a profiled compiler"
1915 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1916 -- so we simply say "ok". It doesn't matter because TH isn't
1917 -- available in stage 1 anyway.
1918 checkTemplateHaskellOk _ = return ()
1921 {- **********************************************************************
1923 DynFlags constructors
1925 %********************************************************************* -}
1927 type DynP = EwM (CmdLineP DynFlags)
1929 upd :: (DynFlags -> DynFlags) -> DynP ()
1930 upd f = liftEwM (do dflags <- getCmdLineState
1931 putCmdLineState $! f dflags)
1933 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1934 updM f = do dflags <- liftEwM getCmdLineState
1936 liftEwM $ putCmdLineState $! dflags'
1938 --------------- Constructor functions for OptKind -----------------
1939 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1940 noArg fn = NoArg (upd fn)
1942 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1943 noArgM fn = NoArg (updM fn)
1945 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1946 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1948 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1949 hasArg fn = HasArg (upd . fn)
1951 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1952 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1953 ; deprecate deprec })
1955 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1956 intSuffix fn = IntSuffix (\n -> upd (fn n))
1958 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
1959 -> OptKind (CmdLineP DynFlags)
1960 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
1962 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
1963 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1965 --------------------------
1966 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1967 setDynFlag f = upd (\dfs -> dopt_set dfs f)
1968 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1970 --------------------------
1971 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
1972 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
1975 deps = [ if turn_on then setExtensionFlag d
1976 else unSetExtensionFlag d
1977 | (f', turn_on, d) <- impliedFlags, f' == f ]
1978 -- When you set f, set the ones it implies
1979 -- NB: use setExtensionFlag recursively, in case the implied flags
1980 -- implies further flags
1982 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
1983 -- When you un-set f, however, we don't un-set the things it implies
1984 -- (except for -fno-glasgow-exts, which is treated specially)
1986 --------------------------
1987 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
1988 alterSettings f dflags = dflags { settings = f (settings dflags) }
1990 --------------------------
1991 setDumpFlag' :: DynFlag -> DynP ()
1992 setDumpFlag' dump_flag
1993 = do { setDynFlag dump_flag
1994 ; when want_recomp forceRecompile }
1996 -- Certain dumpy-things are really interested in what's going
1997 -- on during recompilation checking, so in those cases we
1998 -- don't want to turn it off.
1999 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2000 Opt_D_dump_hi_diffs]
2002 forceRecompile :: DynP ()
2003 -- Whenver we -ddump, force recompilation (by switching off the
2004 -- recompilation checker), else you don't see the dump! However,
2005 -- don't switch it off in --make mode, else *everything* gets
2006 -- recompiled which probably isn't what you want
2007 forceRecompile = do { dfs <- liftEwM getCmdLineState
2008 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2010 force_recomp dfs = isOneShot (ghcMode dfs)
2012 setVerboseCore2Core :: DynP ()
2013 setVerboseCore2Core = do forceRecompile
2014 setDynFlag Opt_D_verbose_core2core
2015 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2017 setDumpSimplPhases :: String -> DynP ()
2018 setDumpSimplPhases s = do forceRecompile
2019 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2021 spec = case s of { ('=' : s') -> s'; _ -> s }
2023 setVerbosity :: Maybe Int -> DynP ()
2024 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2026 addCmdlineHCInclude :: String -> DynP ()
2027 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2029 extraPkgConf_ :: FilePath -> DynP ()
2030 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2032 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2034 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2036 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2038 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2040 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2042 setPackageName :: String -> DynFlags -> DynFlags
2043 setPackageName p s = s{ thisPackage = stringToPackageId p }
2045 -- If we're linking a binary, then only targets that produce object
2046 -- code are allowed (requests for other target types are ignored).
2047 setTarget :: HscTarget -> DynP ()
2048 setTarget l = upd set
2051 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2054 -- Changes the target only if we're compiling object code. This is
2055 -- used by -fasm and -fllvm, which switch from one to the other, but
2056 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2057 -- can be safely used in an OPTIONS_GHC pragma.
2058 setObjTarget :: HscTarget -> DynP ()
2059 setObjTarget l = updM set
2062 | isObjectTarget (hscTarget dflags)
2065 | cGhcUnregisterised /= "YES" ->
2066 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2069 | cGhcWithNativeCodeGen /= "YES" ->
2070 do addWarn ("Compiler has no native codegen, so ignoring " ++
2074 | cGhcUnregisterised == "YES" ->
2075 do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2077 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2078 (not opt_Static || opt_PIC)
2080 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2082 _ -> return $ dflags { hscTarget = l }
2083 | otherwise = return dflags
2084 where platform = targetPlatform dflags
2085 arch = platformArch platform
2086 os = platformOS platform
2087 flag = showHscTargetFlag l
2089 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2090 setOptLevel n dflags
2091 | hscTarget dflags == HscInterpreted && n > 0
2092 = do addWarn "-O conflicts with --interactive; -O ignored."
2095 = return (updOptLevel n dflags)
2098 -- -Odph is equivalent to
2100 -- -O2 optimise as much as possible
2101 -- -fmax-simplifier-iterations20 this is necessary sometimes
2102 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2104 setDPHOpt :: DynFlags -> DynP DynFlags
2105 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2109 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2110 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2111 -- vectoriser cannot be used.
2113 data DPHBackend = DPHPar -- "dph-par"
2114 | DPHSeq -- "dph-seq"
2115 | DPHThis -- the currently compiled package
2116 | DPHNone -- no DPH library available
2117 deriving(Eq, Ord, Enum, Show)
2119 setDPHBackend :: DPHBackend -> DynP ()
2120 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2122 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2124 dphPackageMaybe :: DynFlags -> Maybe PackageId
2125 dphPackageMaybe dflags
2126 = case dphBackend dflags of
2127 DPHPar -> Just dphParPackageId
2128 DPHSeq -> Just dphSeqPackageId
2129 DPHThis -> Just (thisPackage dflags)
2132 setMainIs :: String -> DynP ()
2134 | not (null main_fn) && isLower (head main_fn)
2135 -- The arg looked like "Foo.Bar.baz"
2136 = upd $ \d -> d{ mainFunIs = Just main_fn,
2137 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2139 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2140 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2142 | otherwise -- The arg looked like "baz"
2143 = upd $ \d -> d{ mainFunIs = Just arg }
2145 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2147 -----------------------------------------------------------------------------
2148 -- Paths & Libraries
2150 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2152 -- -i on its own deletes the import paths
2153 addImportPath "" = upd (\s -> s{importPaths = []})
2154 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2157 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2160 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2162 addFrameworkPath p =
2163 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2165 #ifndef mingw32_TARGET_OS
2166 split_marker :: Char
2167 split_marker = ':' -- not configurable (ToDo)
2170 splitPathList :: String -> [String]
2171 splitPathList s = filter notNull (splitUp s)
2172 -- empty paths are ignored: there might be a trailing
2173 -- ':' in the initial list, for example. Empty paths can
2174 -- cause confusion when they are translated into -I options
2175 -- for passing to gcc.
2177 #ifndef mingw32_TARGET_OS
2178 splitUp xs = split split_marker xs
2180 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2182 -- That is, if "foo:bar:baz" is used, this interpreted as
2183 -- consisting of three entries, 'foo', 'bar', 'baz'.
2184 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2185 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2187 -- Notice that no attempt is made to fully replace the 'standard'
2188 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2189 -- that this will cause too much breakage for users & ':' will
2190 -- work fine even with DOS paths, if you're not insisting on being silly.
2193 splitUp (x:':':div:xs) | div `elem` dir_markers
2194 = ((x:':':div:p): splitUp rs)
2196 (p,rs) = findNextPath xs
2197 -- we used to check for existence of the path here, but that
2198 -- required the IO monad to be threaded through the command-line
2199 -- parser which is quite inconvenient. The
2200 splitUp xs = cons p (splitUp rs)
2202 (p,rs) = findNextPath xs
2207 -- will be called either when we've consumed nought or the
2208 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2209 -- finding the next split marker.
2211 case break (`elem` split_markers) xs of
2212 (p, _:ds) -> (p, ds)
2215 split_markers :: [Char]
2216 split_markers = [':', ';']
2218 dir_markers :: [Char]
2219 dir_markers = ['/', '\\']
2222 -- -----------------------------------------------------------------------------
2223 -- tmpDir, where we store temporary files.
2225 setTmpDir :: FilePath -> DynFlags -> DynFlags
2226 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2227 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2228 -- seem necessary now --SDM 7/2/2008
2230 -----------------------------------------------------------------------------
2233 setRtsOpts :: String -> DynP ()
2234 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2236 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2237 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2239 -----------------------------------------------------------------------------
2242 setOptHpcDir :: String -> DynP ()
2243 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2245 -----------------------------------------------------------------------------
2246 -- Via-C compilation stuff
2248 -- There are some options that we need to pass to gcc when compiling
2249 -- Haskell code via C, but are only supported by recent versions of
2250 -- gcc. The configure script decides which of these options we need,
2251 -- and puts them in the "settings" file in $topdir. The advantage of
2252 -- having these in a separate file is that the file can be created at
2253 -- install-time depending on the available gcc version, and even
2254 -- re-generated later if gcc is upgraded.
2256 -- The options below are not dependent on the version of gcc, only the
2259 picCCOpts :: DynFlags -> [String]
2261 #if darwin_TARGET_OS
2262 -- Apple prefers to do things the other way round.
2263 -- PIC is on by default.
2264 -- -mdynamic-no-pic:
2265 -- Turn off PIC code generation.
2267 -- Don't generate "common" symbols - these are unwanted
2268 -- in dynamic libraries.
2271 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2273 = ["-mdynamic-no-pic"]
2274 #elif mingw32_TARGET_OS
2275 -- no -fPIC for Windows
2277 = ["-U __PIC__","-D__PIC__"]
2281 -- we need -fPIC for C files when we are compiling with -dynamic,
2282 -- otherwise things like stub.c files don't get compiled
2283 -- correctly. They need to reference data in the Haskell
2284 -- objects, but can't without -fPIC. See
2285 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2286 | opt_PIC || not opt_Static
2287 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2292 -- -----------------------------------------------------------------------------
2296 can_split = cSupportsSplitObjs == "YES"
2298 -- -----------------------------------------------------------------------------
2301 compilerInfo :: DynFlags -> [(String, String)]
2303 = -- We always make "Project name" be first to keep parsing in
2304 -- other languages simple, i.e. when looking for other fields,
2305 -- you don't have to worry whether there is a leading '[' or not
2306 ("Project name", cProjectName)
2307 -- Next come the settings, so anything else can be overridden
2308 -- in the settings file (as "lookup" uses the first match for the
2310 : rawSettings dflags
2311 ++ [("Project version", cProjectVersion),
2312 ("Booter version", cBooterVersion),
2314 ("Build platform", cBuildPlatformString),
2315 ("Host platform", cHostPlatformString),
2316 ("Target platform", cTargetPlatformString),
2317 ("Have interpreter", cGhcWithInterpreter),
2318 ("Object splitting supported", cSupportsSplitObjs),
2319 ("Have native code generator", cGhcWithNativeCodeGen),
2320 ("Support SMP", cGhcWithSMP),
2321 ("Unregisterised", cGhcUnregisterised),
2322 ("Tables next to code", cGhcEnableTablesNextToCode),
2323 ("RTS ways", cGhcRTSWays),
2324 ("Leading underscore", cLeadingUnderscore),
2325 ("Debug on", show debugIsOn),
2326 ("LibDir", topDir dflags),
2327 ("Global Package DB", systemPackageConfig dflags),
2328 ("Gcc Linker flags", show cGccLinkerOpts),
2329 ("Ld Linker flags", show cLdLinkerOpts)