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 : delete Opt_DatatypeContexts -- The Haskell' committee decided to
878 -- remove datatype contexts from the
880 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
881 (languageExtensions (Just Haskell2010))
883 languageExtensions (Just Haskell98)
884 = [Opt_ImplicitPrelude,
885 Opt_MonomorphismRestriction,
887 Opt_DatatypeContexts,
888 Opt_NondecreasingIndentation
889 -- strictly speaking non-standard, but we always had this
890 -- on implicitly before the option was added in 7.1, and
891 -- turning it off breaks code, so we're keeping it on for
892 -- backwards compatibility. Cabal uses -XHaskell98 by
893 -- default unless you specify another language.
896 languageExtensions (Just Haskell2010)
897 = [Opt_ImplicitPrelude,
898 Opt_MonomorphismRestriction,
899 Opt_DatatypeContexts,
901 Opt_ForeignFunctionInterface,
906 -- | Test whether a 'DynFlag' is set
907 dopt :: DynFlag -> DynFlags -> Bool
908 dopt f dflags = f `elem` (flags dflags)
911 dopt_set :: DynFlags -> DynFlag -> DynFlags
912 dopt_set dfs f = dfs{ flags = f : flags dfs }
914 -- | Unset a 'DynFlag'
915 dopt_unset :: DynFlags -> DynFlag -> DynFlags
916 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
918 -- | Test whether a 'ExtensionFlag' is set
919 xopt :: ExtensionFlag -> DynFlags -> Bool
920 xopt f dflags = f `elem` extensionFlags dflags
922 -- | Set a 'ExtensionFlag'
923 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
925 = let onoffs = On f : extensions dfs
926 in dfs { extensions = onoffs,
927 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
929 -- | Unset a 'ExtensionFlag'
930 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
932 = let onoffs = Off f : extensions dfs
933 in dfs { extensions = onoffs,
934 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
936 setLanguage :: Language -> DynP ()
937 setLanguage l = upd f
938 where f dfs = let mLang = Just l
939 oneoffs = extensions dfs
942 extensionFlags = flattenExtensionFlags mLang oneoffs
945 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
946 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
947 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
948 -> [a] -- ^ Correctly ordered extracted options
949 getOpts dflags opts = reverse (opts dflags)
950 -- We add to the options from the front, so we need to reverse the list
952 -- | Gets the verbosity flag for the current verbosity level. This is fed to
953 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
954 getVerbFlags :: DynFlags -> [String]
956 | verbosity dflags >= 4 = ["-v"]
959 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
960 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
961 setPgmP, addOptl, addOptP,
962 addCmdlineFramework, addHaddockOpts
963 :: String -> DynFlags -> DynFlags
964 setOutputFile, setOutputHi, setDumpPrefixForce
965 :: Maybe String -> DynFlags -> DynFlags
967 setObjectDir f d = d{ objectDir = Just f}
968 setHiDir f d = d{ hiDir = Just f}
969 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
970 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
971 -- \#included from the .hc file when compiling via C (i.e. unregisterised
973 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
974 setDylibInstallName f d = d{ dylibInstallName = Just f}
976 setObjectSuf f d = d{ objectSuf = f}
977 setHiSuf f d = d{ hiSuf = f}
978 setHcSuf f d = d{ hcSuf = f}
980 setOutputFile f d = d{ outputFile = f}
981 setOutputHi f d = d{ outputHi = f}
983 parseDynLibLoaderMode f d =
985 ("deploy", "") -> d{ dynLibLoader = Deployable }
986 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
987 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
989 setDumpPrefixForce f d = d { dumpPrefixForce = f}
991 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
992 -- Config.hs should really use Option.
993 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
994 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
995 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
998 setDepMakefile :: FilePath -> DynFlags -> DynFlags
999 setDepMakefile f d = d { depMakefile = deOptDep f }
1001 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1002 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1004 addDepExcludeMod :: String -> DynFlags -> DynFlags
1005 addDepExcludeMod m d
1006 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1008 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1009 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1012 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1013 -- we need to strip the "-optdep" off of the arg
1014 deOptDep :: String -> String
1015 deOptDep x = case stripPrefix "-optdep" x of
1019 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1021 addHaddockOpts f d = d{ haddockOptions = Just f}
1023 -- -----------------------------------------------------------------------------
1024 -- Command-line options
1026 -- | When invoking external tools as part of the compilation pipeline, we
1027 -- pass these a sequence of options on the command-line. Rather than
1028 -- just using a list of Strings, we use a type that allows us to distinguish
1029 -- between filepaths and 'other stuff'. The reason for this is that
1030 -- this type gives us a handle on transforming filenames, and filenames only,
1031 -- to whatever format they're expected to be on a particular platform.
1033 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1034 String -- a non-filepath prefix that shouldn't be
1035 -- transformed (e.g., "/out=")
1036 String -- the filepath/filename portion
1039 showOpt :: Option -> String
1040 showOpt (FileOption pre f) = pre ++ f
1041 showOpt (Option s) = s
1043 -----------------------------------------------------------------------------
1044 -- Setting the optimisation level
1046 updOptLevel :: Int -> DynFlags -> DynFlags
1047 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1049 = dfs2{ optLevel = final_n }
1051 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1052 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1053 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1055 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1056 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1058 -- -----------------------------------------------------------------------------
1059 -- StgToDo: abstraction of stg-to-stg passes to run.
1062 = StgDoMassageForProfiling -- should be (next to) last
1063 -- There's also setStgVarInfo, but its absolute "lastness"
1064 -- is so critical that it is hardwired in (no flag).
1067 getStgToDo :: DynFlags -> [StgToDo]
1071 stg_stats = dopt Opt_StgStats dflags
1073 todo1 = if stg_stats then [D_stg_stats] else []
1075 todo2 | WayProf `elem` wayNames dflags
1076 = StgDoMassageForProfiling : todo1
1080 {- **********************************************************************
1084 %********************************************************************* -}
1086 -- -----------------------------------------------------------------------------
1087 -- Parsing the dynamic flags.
1089 -- | Parse dynamic flags from a list of command line arguments. Returns the
1090 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1091 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1092 -- flags or missing arguments).
1093 parseDynamicFlags :: Monad m =>
1094 DynFlags -> [Located String]
1095 -> m (DynFlags, [Located String], [Located String])
1096 -- ^ Updated 'DynFlags', left-over arguments, and
1097 -- list of warnings.
1098 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1100 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1101 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1102 parseDynamicNoPackageFlags :: Monad m =>
1103 DynFlags -> [Located String]
1104 -> m (DynFlags, [Located String], [Located String])
1105 -- ^ Updated 'DynFlags', left-over arguments, and
1106 -- list of warnings.
1107 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1109 parseDynamicFlags_ :: Monad m =>
1110 DynFlags -> [Located String] -> Bool
1111 -> m (DynFlags, [Located String], [Located String])
1112 parseDynamicFlags_ dflags0 args pkg_flags = do
1113 -- XXX Legacy support code
1114 -- We used to accept things like
1115 -- optdep-f -optdepdepend
1116 -- optdep-f -optdep depend
1117 -- optdep -f -optdepdepend
1118 -- optdep -f -optdep depend
1119 -- but the spaces trip up proper argument handling. So get rid of them.
1120 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1121 f (x : xs) = x : f xs
1125 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1126 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1127 | otherwise = dynamic_flags
1129 let ((leftover, errs, warns), dflags1)
1130 = runCmdLine (processArgs flag_spec args') dflags0
1131 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1133 return (dflags1, leftover, warns)
1136 {- **********************************************************************
1138 DynFlags specifications
1140 %********************************************************************* -}
1142 allFlags :: [String]
1143 allFlags = map ('-':) $
1144 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1145 map ("fno-"++) flags ++
1146 map ("f"++) flags ++
1147 map ("f"++) flags' ++
1148 map ("X"++) supportedExtensions
1149 where ok (PrefixPred _ _) = False
1151 flags = [ name | (name, _, _) <- fFlags ]
1152 flags' = [ name | (name, _, _) <- fLangFlags ]
1154 --------------- The main flags themselves ------------------
1155 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1157 Flag "n" (NoArg (setDynFlag Opt_DryRun))
1158 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1159 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1161 (HasArg (\s -> do { addCmdlineHCInclude s
1162 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1163 , Flag "v" (OptIntSuffix setVerbosity)
1165 ------- Specific phases --------------------------------------------
1166 -- need to appear before -pgmL to be parsed as LLVM flags.
1167 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1168 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1169 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1170 , Flag "pgmP" (hasArg setPgmP)
1171 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1172 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1173 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1174 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1175 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1176 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1177 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1178 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1180 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1181 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1182 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1183 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1184 , Flag "optP" (hasArg addOptP)
1185 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1186 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1187 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1188 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1189 , Flag "optl" (hasArg addOptl)
1190 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1193 (NoArg (if can_split
1194 then setDynFlag Opt_SplitObjs
1195 else addWarn "ignoring -fsplit-objs"))
1197 -------- ghc -M -----------------------------------------------------
1198 , Flag "dep-suffix" (hasArg addDepSuffix)
1199 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1200 , Flag "dep-makefile" (hasArg setDepMakefile)
1201 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1202 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1203 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1204 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1205 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1206 , Flag "exclude-module" (hasArg addDepExcludeMod)
1207 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1208 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1210 -------- Linking ----------------------------------------------------
1211 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1212 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1213 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1214 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1216 ------- Libraries ---------------------------------------------------
1217 , Flag "L" (Prefix addLibraryPath)
1218 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1220 ------- Frameworks --------------------------------------------------
1221 -- -framework-path should really be -F ...
1222 , Flag "framework-path" (HasArg addFrameworkPath)
1223 , Flag "framework" (hasArg addCmdlineFramework)
1225 ------- Output Redirection ------------------------------------------
1226 , Flag "odir" (hasArg setObjectDir)
1227 , Flag "o" (SepArg (upd . setOutputFile . Just))
1228 , Flag "ohi" (hasArg (setOutputHi . Just ))
1229 , Flag "osuf" (hasArg setObjectSuf)
1230 , Flag "hcsuf" (hasArg setHcSuf)
1231 , Flag "hisuf" (hasArg setHiSuf)
1232 , Flag "hidir" (hasArg setHiDir)
1233 , Flag "tmpdir" (hasArg setTmpDir)
1234 , Flag "stubdir" (hasArg setStubDir)
1235 , Flag "outputdir" (hasArg setOutputDir)
1236 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1238 ------- Keeping temporary files -------------------------------------
1239 -- These can be singular (think ghc -c) or plural (think ghc --make)
1240 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1241 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1242 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1243 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1244 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1245 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1246 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1247 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1248 -- This only makes sense as plural
1249 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1251 ------- Miscellaneous ----------------------------------------------
1252 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1253 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1254 , Flag "with-rtsopts" (HasArg setRtsOpts)
1255 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1256 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1257 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1258 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1259 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1260 , Flag "main-is" (SepArg setMainIs)
1261 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1262 , Flag "haddock-opts" (hasArg addHaddockOpts)
1263 , Flag "hpcdir" (SepArg setOptHpcDir)
1265 ------- recompilation checker --------------------------------------
1266 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1267 ; deprecate "Use -fno-force-recomp instead" }))
1268 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1269 ; deprecate "Use -fforce-recomp instead" }))
1271 ------ HsCpp opts ---------------------------------------------------
1272 , Flag "D" (AnySuffix (upd . addOptP))
1273 , Flag "U" (AnySuffix (upd . addOptP))
1275 ------- Include/Import Paths ----------------------------------------
1276 , Flag "I" (Prefix addIncludePath)
1277 , Flag "i" (OptPrefix addImportPath)
1279 ------ Debugging ----------------------------------------------------
1280 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1282 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1283 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1284 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1285 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1286 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1287 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1288 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1289 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1290 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1291 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1292 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1293 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1294 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1295 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1296 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1297 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1298 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1299 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1300 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1301 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1302 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1303 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1304 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1305 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1306 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1307 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1308 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1309 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1310 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1311 ; setDumpFlag' Opt_D_dump_llvm}))
1312 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1313 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1314 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1315 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1316 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1317 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1318 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1319 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1320 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1321 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1322 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1323 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1324 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1325 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1326 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1327 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1328 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1329 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1330 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1331 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1332 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1333 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1334 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1335 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1336 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1337 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1338 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1339 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1340 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1341 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1342 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1343 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1344 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1345 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1346 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1347 ; setVerboseCore2Core }))
1348 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1349 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1350 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1351 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1352 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1353 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1354 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1355 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1356 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1357 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1358 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1359 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1360 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1361 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1362 , Flag "dshow-passes" (NoArg (do forceRecompile
1363 setVerbosity (Just 2)))
1364 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1366 ------ Machine dependant (-m<blah>) stuff ---------------------------
1368 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1369 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1370 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1371 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1373 ------ Warning opts -------------------------------------------------
1374 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1375 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1376 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1377 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1378 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1379 ; deprecate "Use -w instead" }))
1380 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1382 ------ Optimisation flags ------------------------------------------
1383 , Flag "O" (noArgM (setOptLevel 1))
1384 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1385 setOptLevel 0 dflags))
1386 , Flag "Odph" (noArgM setDPHOpt)
1387 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1388 -- If the number is missing, use 1
1390 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1391 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1392 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1393 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1394 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1395 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1396 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1397 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1398 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1399 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1400 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1401 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1402 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1404 ------ Profiling ----------------------------------------------------
1406 -- XXX Should the -f* flags be deprecated?
1407 -- They don't seem to be documented
1408 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1409 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1410 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1411 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1412 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1413 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1414 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1415 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1416 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1418 ------ DPH flags ----------------------------------------------------
1420 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1421 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1422 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1423 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1425 ------ Compiler flags -----------------------------------------------
1427 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1428 , Flag "fvia-c" (NoArg
1429 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1430 , Flag "fvia-C" (NoArg
1431 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1432 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1434 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1435 setTarget HscNothing))
1436 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1437 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1438 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1439 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1441 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1442 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1443 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1444 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1445 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1446 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1447 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1449 package_flags :: [Flag (CmdLineP DynFlags)]
1451 ------- Packages ----------------------------------------------------
1452 Flag "package-conf" (HasArg extraPkgConf_)
1453 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1454 , Flag "package-name" (hasArg setPackageName)
1455 , Flag "package-id" (HasArg exposePackageId)
1456 , Flag "package" (HasArg exposePackage)
1457 , Flag "hide-package" (HasArg hidePackage)
1458 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1459 , Flag "ignore-package" (HasArg ignorePackage)
1460 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1461 ; deprecate "Use -package instead" }))
1464 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1465 -- False <=> we are turning the flag off
1466 turnOn :: TurnOnFlag; turnOn = True
1467 turnOff :: TurnOnFlag; turnOff = False
1470 = ( String -- Flag in string form
1471 , flag -- Flag in internal form
1472 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1473 -- Typically, emit a warning or error
1475 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1476 -> String -- ^ The flag prefix
1477 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1478 -> FlagSpec flag -- ^ Specification of this particular flag
1479 -> Flag (CmdLineP DynFlags)
1480 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1481 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1483 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1484 deprecatedForExtension lang turn_on
1485 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1487 flag | turn_on = lang
1488 | otherwise = "No"++lang
1490 useInstead :: String -> TurnOnFlag -> DynP ()
1491 useInstead flag turn_on
1492 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1494 no = if turn_on then "" else "no-"
1496 nop :: TurnOnFlag -> DynP ()
1499 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1500 fFlags :: [FlagSpec DynFlag]
1502 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1503 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1504 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1505 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1506 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1507 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1508 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1509 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1510 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1511 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1512 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1513 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1514 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1515 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1516 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1517 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1518 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1519 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1520 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1521 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1522 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1523 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1524 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1525 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1526 ( "warn-orphans", Opt_WarnOrphans, nop ),
1527 ( "warn-identities", Opt_WarnIdentities, nop ),
1528 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1529 ( "warn-tabs", Opt_WarnTabs, nop ),
1530 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1531 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1532 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1533 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1534 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1535 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1536 ( "strictness", Opt_Strictness, nop ),
1537 ( "specialise", Opt_Specialise, nop ),
1538 ( "float-in", Opt_FloatIn, nop ),
1539 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1540 ( "full-laziness", Opt_FullLaziness, nop ),
1541 ( "liberate-case", Opt_LiberateCase, nop ),
1542 ( "spec-constr", Opt_SpecConstr, nop ),
1543 ( "cse", Opt_CSE, nop ),
1544 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1545 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1546 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1547 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1548 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1549 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1550 ( "case-merge", Opt_CaseMerge, nop ),
1551 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1552 ( "method-sharing", Opt_MethodSharing,
1553 \_ -> deprecate "doesn't do anything any more"),
1554 -- Remove altogether in GHC 7.2
1555 ( "dicts-cheap", Opt_DictsCheap, nop ),
1556 ( "excess-precision", Opt_ExcessPrecision, nop ),
1557 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1558 ( "print-bind-result", Opt_PrintBindResult, nop ),
1559 ( "force-recomp", Opt_ForceRecomp, nop ),
1560 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1561 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1562 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1563 ( "break-on-exception", Opt_BreakOnException, nop ),
1564 ( "break-on-error", Opt_BreakOnError, nop ),
1565 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1566 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1567 ( "run-cps", Opt_RunCPS, nop ),
1568 ( "run-cpsz", Opt_RunCPSZ, nop ),
1569 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1570 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1571 ( "vectorise", Opt_Vectorise, nop ),
1572 ( "regs-graph", Opt_RegsGraph, nop ),
1573 ( "regs-iterative", Opt_RegsIterative, nop ),
1574 ( "gen-manifest", Opt_GenManifest, nop ),
1575 ( "embed-manifest", Opt_EmbedManifest, nop ),
1576 ( "ext-core", Opt_EmitExternalCore, nop ),
1577 ( "shared-implib", Opt_SharedImplib, nop ),
1578 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1579 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1580 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1581 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1584 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1585 fLangFlags :: [FlagSpec ExtensionFlag]
1587 ( "th", Opt_TemplateHaskell,
1588 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1589 ( "fi", Opt_ForeignFunctionInterface,
1590 deprecatedForExtension "ForeignFunctionInterface" ),
1591 ( "ffi", Opt_ForeignFunctionInterface,
1592 deprecatedForExtension "ForeignFunctionInterface" ),
1593 ( "arrows", Opt_Arrows,
1594 deprecatedForExtension "Arrows" ),
1595 ( "generics", Opt_Generics,
1596 deprecatedForExtension "Generics" ),
1597 ( "implicit-prelude", Opt_ImplicitPrelude,
1598 deprecatedForExtension "ImplicitPrelude" ),
1599 ( "bang-patterns", Opt_BangPatterns,
1600 deprecatedForExtension "BangPatterns" ),
1601 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1602 deprecatedForExtension "MonomorphismRestriction" ),
1603 ( "mono-pat-binds", Opt_MonoPatBinds,
1604 deprecatedForExtension "MonoPatBinds" ),
1605 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1606 deprecatedForExtension "ExtendedDefaultRules" ),
1607 ( "implicit-params", Opt_ImplicitParams,
1608 deprecatedForExtension "ImplicitParams" ),
1609 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1610 deprecatedForExtension "ScopedTypeVariables" ),
1611 ( "parr", Opt_ParallelArrays,
1612 deprecatedForExtension "ParallelArrays" ),
1613 ( "PArr", Opt_ParallelArrays,
1614 deprecatedForExtension "ParallelArrays" ),
1615 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1616 deprecatedForExtension "OverlappingInstances" ),
1617 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1618 deprecatedForExtension "UndecidableInstances" ),
1619 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1620 deprecatedForExtension "IncoherentInstances" )
1623 supportedLanguages :: [String]
1624 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1626 supportedExtensions :: [String]
1627 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1629 supportedLanguagesAndExtensions :: [String]
1630 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1632 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1633 languageFlags :: [FlagSpec Language]
1635 ( "Haskell98", Haskell98, nop ),
1636 ( "Haskell2010", Haskell2010, nop )
1639 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1640 xFlags :: [FlagSpec ExtensionFlag]
1642 ( "CPP", Opt_Cpp, nop ),
1643 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1644 ( "TupleSections", Opt_TupleSections, nop ),
1645 ( "PatternGuards", Opt_PatternGuards, nop ),
1646 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1647 ( "MagicHash", Opt_MagicHash, nop ),
1648 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1649 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1650 ( "KindSignatures", Opt_KindSignatures, nop ),
1651 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1652 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1653 ( "TransformListComp", Opt_TransformListComp, nop ),
1654 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1655 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1656 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1657 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1658 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1659 ( "Rank2Types", Opt_Rank2Types, nop ),
1660 ( "RankNTypes", Opt_RankNTypes, nop ),
1661 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1662 ( "TypeOperators", Opt_TypeOperators, nop ),
1663 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1664 deprecatedForExtension "DoRec"),
1665 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1666 ( "Arrows", Opt_Arrows, nop ),
1667 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1668 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1669 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1670 ( "Generics", Opt_Generics, nop ),
1671 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1672 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1673 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1674 ( "RecordPuns", Opt_RecordPuns,
1675 deprecatedForExtension "NamedFieldPuns" ),
1676 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1677 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1678 ( "GADTs", Opt_GADTs, nop ),
1679 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1680 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1681 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1682 ( "BangPatterns", Opt_BangPatterns, nop ),
1683 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1684 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1685 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1686 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1687 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1688 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1689 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1690 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1691 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1692 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1693 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1694 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1695 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1696 \ turn_on -> if not turn_on
1697 then deprecate "You can't turn off RelaxedPolyRec any more"
1699 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1700 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1701 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1703 ( "PatternSignatures", Opt_ScopedTypeVariables,
1704 deprecatedForExtension "ScopedTypeVariables" ),
1706 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1707 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1708 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1709 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1710 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1711 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1712 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1713 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1714 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1715 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1716 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1717 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1718 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1719 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1720 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1721 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1722 ( "PackageImports", Opt_PackageImports, nop )
1725 defaultFlags :: [DynFlag]
1727 = [ Opt_AutoLinkPackages,
1728 Opt_ReadUserPackageConf,
1732 #if GHC_DEFAULT_NEW_CODEGEN
1738 Opt_PrintBindContents,
1743 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1744 -- The default -O0 options
1748 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1750 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1751 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1752 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1753 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1754 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1755 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1756 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1757 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1759 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1761 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1762 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1763 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1765 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1766 -- all over the place
1768 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1770 -- Record wild-cards implies field disambiguation
1771 -- Otherwise if you write (C {..}) you may well get
1772 -- stuff like " 'a' not in scope ", which is a bit silly
1773 -- if the compiler has just filled in field 'a' of constructor 'C'
1774 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1776 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1779 optLevelFlags :: [([Int], DynFlag)]
1781 = [ ([0], Opt_IgnoreInterfacePragmas)
1782 , ([0], Opt_OmitInterfacePragmas)
1784 , ([1,2], Opt_IgnoreAsserts)
1785 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1787 , ([1,2], Opt_DoEtaReduction)
1788 , ([1,2], Opt_CaseMerge)
1789 , ([1,2], Opt_Strictness)
1791 , ([1,2], Opt_FullLaziness)
1792 , ([1,2], Opt_Specialise)
1793 , ([1,2], Opt_FloatIn)
1795 , ([2], Opt_LiberateCase)
1796 , ([2], Opt_SpecConstr)
1797 , ([2], Opt_RegsGraph)
1799 -- , ([2], Opt_StaticArgumentTransformation)
1800 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1801 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1802 -- several improvements to the heuristics, and I'm concerned that without
1803 -- those changes SAT will interfere with some attempts to write "high
1804 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1805 -- this year. In particular, the version in HEAD lacks the tail call
1806 -- criterion, so many things that look like reasonable loops will be
1807 -- turned into functions with extra (unneccesary) thunk creation.
1809 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1810 -- This one is important for a tiresome reason:
1811 -- we want to make sure that the bindings for data
1812 -- constructors are eta-expanded. This is probably
1813 -- a good thing anyway, but it seems fragile.
1816 -- -----------------------------------------------------------------------------
1817 -- Standard sets of warning options
1819 standardWarnings :: [DynFlag]
1821 = [ Opt_WarnWarningsDeprecations,
1822 Opt_WarnDeprecatedFlags,
1823 Opt_WarnUnrecognisedPragmas,
1824 Opt_WarnOverlappingPatterns,
1825 Opt_WarnMissingFields,
1826 Opt_WarnMissingMethods,
1827 Opt_WarnDuplicateExports,
1828 Opt_WarnLazyUnliftedBindings,
1829 Opt_WarnDodgyForeignImports,
1830 Opt_WarnWrongDoBind,
1831 Opt_WarnAlternativeLayoutRuleTransitional
1834 minusWOpts :: [DynFlag]
1835 -- Things you get with -W
1837 = standardWarnings ++
1838 [ Opt_WarnUnusedBinds,
1839 Opt_WarnUnusedMatches,
1840 Opt_WarnUnusedImports,
1841 Opt_WarnIncompletePatterns,
1842 Opt_WarnDodgyExports,
1843 Opt_WarnDodgyImports
1846 minusWallOpts :: [DynFlag]
1847 -- Things you get with -Wall
1850 [ Opt_WarnTypeDefaults,
1851 Opt_WarnNameShadowing,
1852 Opt_WarnMissingSigs,
1855 Opt_WarnUnusedDoBind
1858 minuswRemovesOpts :: [DynFlag]
1859 -- minuswRemovesOpts should be every warning option
1863 Opt_WarnIncompletePatternsRecUpd,
1864 Opt_WarnIncompleteUniPatterns,
1865 Opt_WarnMonomorphism,
1866 Opt_WarnUnrecognisedPragmas,
1867 Opt_WarnAutoOrphans,
1868 Opt_WarnImplicitPrelude
1871 enableGlasgowExts :: DynP ()
1872 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1873 mapM_ setExtensionFlag glasgowExtsFlags
1875 disableGlasgowExts :: DynP ()
1876 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1877 mapM_ unSetExtensionFlag glasgowExtsFlags
1879 glasgowExtsFlags :: [ExtensionFlag]
1880 glasgowExtsFlags = [
1881 Opt_ForeignFunctionInterface
1882 , Opt_UnliftedFFITypes
1883 , Opt_ImplicitParams
1884 , Opt_ScopedTypeVariables
1886 , Opt_TypeSynonymInstances
1887 , Opt_StandaloneDeriving
1888 , Opt_DeriveDataTypeable
1890 , Opt_DeriveFoldable
1891 , Opt_DeriveTraversable
1892 , Opt_FlexibleContexts
1893 , Opt_FlexibleInstances
1894 , Opt_ConstrainedClassMethods
1895 , Opt_MultiParamTypeClasses
1896 , Opt_FunctionalDependencies
1898 , Opt_PolymorphicComponents
1899 , Opt_ExistentialQuantification
1901 , Opt_PostfixOperators
1903 , Opt_LiberalTypeSynonyms
1907 , Opt_ParallelListComp
1908 , Opt_EmptyDataDecls
1909 , Opt_KindSignatures
1910 , Opt_GeneralizedNewtypeDeriving ]
1913 -- Consult the RTS to find whether GHC itself has been built profiled
1914 -- If so, you can't use Template Haskell
1915 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1917 rtsIsProfiled :: Bool
1918 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1921 checkTemplateHaskellOk :: Bool -> DynP ()
1923 checkTemplateHaskellOk turn_on
1924 | turn_on && rtsIsProfiled
1925 = addErr "You can't use Template Haskell with a profiled compiler"
1929 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1930 -- so we simply say "ok". It doesn't matter because TH isn't
1931 -- available in stage 1 anyway.
1932 checkTemplateHaskellOk _ = return ()
1935 {- **********************************************************************
1937 DynFlags constructors
1939 %********************************************************************* -}
1941 type DynP = EwM (CmdLineP DynFlags)
1943 upd :: (DynFlags -> DynFlags) -> DynP ()
1944 upd f = liftEwM (do dflags <- getCmdLineState
1945 putCmdLineState $! f dflags)
1947 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1948 updM f = do dflags <- liftEwM getCmdLineState
1950 liftEwM $ putCmdLineState $! dflags'
1952 --------------- Constructor functions for OptKind -----------------
1953 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1954 noArg fn = NoArg (upd fn)
1956 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1957 noArgM fn = NoArg (updM fn)
1959 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1960 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1962 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1963 hasArg fn = HasArg (upd . fn)
1965 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1966 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1967 ; deprecate deprec })
1969 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1970 intSuffix fn = IntSuffix (\n -> upd (fn n))
1972 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
1973 -> OptKind (CmdLineP DynFlags)
1974 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
1976 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
1977 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1979 --------------------------
1980 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1981 setDynFlag f = upd (\dfs -> dopt_set dfs f)
1982 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1984 --------------------------
1985 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
1986 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
1989 deps = [ if turn_on then setExtensionFlag d
1990 else unSetExtensionFlag d
1991 | (f', turn_on, d) <- impliedFlags, f' == f ]
1992 -- When you set f, set the ones it implies
1993 -- NB: use setExtensionFlag recursively, in case the implied flags
1994 -- implies further flags
1996 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
1997 -- When you un-set f, however, we don't un-set the things it implies
1998 -- (except for -fno-glasgow-exts, which is treated specially)
2000 --------------------------
2001 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2002 alterSettings f dflags = dflags { settings = f (settings dflags) }
2004 --------------------------
2005 setDumpFlag' :: DynFlag -> DynP ()
2006 setDumpFlag' dump_flag
2007 = do { setDynFlag dump_flag
2008 ; when want_recomp forceRecompile }
2010 -- Certain dumpy-things are really interested in what's going
2011 -- on during recompilation checking, so in those cases we
2012 -- don't want to turn it off.
2013 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2014 Opt_D_dump_hi_diffs]
2016 forceRecompile :: DynP ()
2017 -- Whenver we -ddump, force recompilation (by switching off the
2018 -- recompilation checker), else you don't see the dump! However,
2019 -- don't switch it off in --make mode, else *everything* gets
2020 -- recompiled which probably isn't what you want
2021 forceRecompile = do { dfs <- liftEwM getCmdLineState
2022 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2024 force_recomp dfs = isOneShot (ghcMode dfs)
2026 setVerboseCore2Core :: DynP ()
2027 setVerboseCore2Core = do forceRecompile
2028 setDynFlag Opt_D_verbose_core2core
2029 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2031 setDumpSimplPhases :: String -> DynP ()
2032 setDumpSimplPhases s = do forceRecompile
2033 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2035 spec = case s of { ('=' : s') -> s'; _ -> s }
2037 setVerbosity :: Maybe Int -> DynP ()
2038 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2040 addCmdlineHCInclude :: String -> DynP ()
2041 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2043 extraPkgConf_ :: FilePath -> DynP ()
2044 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2046 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2048 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2050 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2052 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2054 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2056 setPackageName :: String -> DynFlags -> DynFlags
2057 setPackageName p s = s{ thisPackage = stringToPackageId p }
2059 -- If we're linking a binary, then only targets that produce object
2060 -- code are allowed (requests for other target types are ignored).
2061 setTarget :: HscTarget -> DynP ()
2062 setTarget l = upd set
2065 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2068 -- Changes the target only if we're compiling object code. This is
2069 -- used by -fasm and -fllvm, which switch from one to the other, but
2070 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2071 -- can be safely used in an OPTIONS_GHC pragma.
2072 setObjTarget :: HscTarget -> DynP ()
2073 setObjTarget l = updM set
2076 | isObjectTarget (hscTarget dflags)
2079 | cGhcUnregisterised /= "YES" ->
2080 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2083 | cGhcWithNativeCodeGen /= "YES" ->
2084 do addWarn ("Compiler has no native codegen, so ignoring " ++
2088 | cGhcUnregisterised == "YES" ->
2089 do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2091 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2092 (not opt_Static || opt_PIC)
2094 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2096 _ -> return $ dflags { hscTarget = l }
2097 | otherwise = return dflags
2098 where platform = targetPlatform dflags
2099 arch = platformArch platform
2100 os = platformOS platform
2101 flag = showHscTargetFlag l
2103 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2104 setOptLevel n dflags
2105 | hscTarget dflags == HscInterpreted && n > 0
2106 = do addWarn "-O conflicts with --interactive; -O ignored."
2109 = return (updOptLevel n dflags)
2112 -- -Odph is equivalent to
2114 -- -O2 optimise as much as possible
2115 -- -fmax-simplifier-iterations20 this is necessary sometimes
2116 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2118 setDPHOpt :: DynFlags -> DynP DynFlags
2119 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2123 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2124 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2125 -- vectoriser cannot be used.
2127 data DPHBackend = DPHPar -- "dph-par"
2128 | DPHSeq -- "dph-seq"
2129 | DPHThis -- the currently compiled package
2130 | DPHNone -- no DPH library available
2131 deriving(Eq, Ord, Enum, Show)
2133 setDPHBackend :: DPHBackend -> DynP ()
2134 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2136 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2138 dphPackageMaybe :: DynFlags -> Maybe PackageId
2139 dphPackageMaybe dflags
2140 = case dphBackend dflags of
2141 DPHPar -> Just dphParPackageId
2142 DPHSeq -> Just dphSeqPackageId
2143 DPHThis -> Just (thisPackage dflags)
2146 setMainIs :: String -> DynP ()
2148 | not (null main_fn) && isLower (head main_fn)
2149 -- The arg looked like "Foo.Bar.baz"
2150 = upd $ \d -> d{ mainFunIs = Just main_fn,
2151 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2153 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2154 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2156 | otherwise -- The arg looked like "baz"
2157 = upd $ \d -> d{ mainFunIs = Just arg }
2159 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2161 -----------------------------------------------------------------------------
2162 -- Paths & Libraries
2164 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2166 -- -i on its own deletes the import paths
2167 addImportPath "" = upd (\s -> s{importPaths = []})
2168 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2171 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2174 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2176 addFrameworkPath p =
2177 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2179 #ifndef mingw32_TARGET_OS
2180 split_marker :: Char
2181 split_marker = ':' -- not configurable (ToDo)
2184 splitPathList :: String -> [String]
2185 splitPathList s = filter notNull (splitUp s)
2186 -- empty paths are ignored: there might be a trailing
2187 -- ':' in the initial list, for example. Empty paths can
2188 -- cause confusion when they are translated into -I options
2189 -- for passing to gcc.
2191 #ifndef mingw32_TARGET_OS
2192 splitUp xs = split split_marker xs
2194 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2196 -- That is, if "foo:bar:baz" is used, this interpreted as
2197 -- consisting of three entries, 'foo', 'bar', 'baz'.
2198 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2199 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2201 -- Notice that no attempt is made to fully replace the 'standard'
2202 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2203 -- that this will cause too much breakage for users & ':' will
2204 -- work fine even with DOS paths, if you're not insisting on being silly.
2207 splitUp (x:':':div:xs) | div `elem` dir_markers
2208 = ((x:':':div:p): splitUp rs)
2210 (p,rs) = findNextPath xs
2211 -- we used to check for existence of the path here, but that
2212 -- required the IO monad to be threaded through the command-line
2213 -- parser which is quite inconvenient. The
2214 splitUp xs = cons p (splitUp rs)
2216 (p,rs) = findNextPath xs
2221 -- will be called either when we've consumed nought or the
2222 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2223 -- finding the next split marker.
2225 case break (`elem` split_markers) xs of
2226 (p, _:ds) -> (p, ds)
2229 split_markers :: [Char]
2230 split_markers = [':', ';']
2232 dir_markers :: [Char]
2233 dir_markers = ['/', '\\']
2236 -- -----------------------------------------------------------------------------
2237 -- tmpDir, where we store temporary files.
2239 setTmpDir :: FilePath -> DynFlags -> DynFlags
2240 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2241 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2242 -- seem necessary now --SDM 7/2/2008
2244 -----------------------------------------------------------------------------
2247 setRtsOpts :: String -> DynP ()
2248 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2250 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2251 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2253 -----------------------------------------------------------------------------
2256 setOptHpcDir :: String -> DynP ()
2257 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2259 -----------------------------------------------------------------------------
2260 -- Via-C compilation stuff
2262 -- There are some options that we need to pass to gcc when compiling
2263 -- Haskell code via C, but are only supported by recent versions of
2264 -- gcc. The configure script decides which of these options we need,
2265 -- and puts them in the "settings" file in $topdir. The advantage of
2266 -- having these in a separate file is that the file can be created at
2267 -- install-time depending on the available gcc version, and even
2268 -- re-generated later if gcc is upgraded.
2270 -- The options below are not dependent on the version of gcc, only the
2273 picCCOpts :: DynFlags -> [String]
2275 #if darwin_TARGET_OS
2276 -- Apple prefers to do things the other way round.
2277 -- PIC is on by default.
2278 -- -mdynamic-no-pic:
2279 -- Turn off PIC code generation.
2281 -- Don't generate "common" symbols - these are unwanted
2282 -- in dynamic libraries.
2285 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2287 = ["-mdynamic-no-pic"]
2288 #elif mingw32_TARGET_OS
2289 -- no -fPIC for Windows
2291 = ["-U __PIC__","-D__PIC__"]
2295 -- we need -fPIC for C files when we are compiling with -dynamic,
2296 -- otherwise things like stub.c files don't get compiled
2297 -- correctly. They need to reference data in the Haskell
2298 -- objects, but can't without -fPIC. See
2299 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2300 | opt_PIC || not opt_Static
2301 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2306 -- -----------------------------------------------------------------------------
2310 can_split = cSupportsSplitObjs == "YES"
2312 -- -----------------------------------------------------------------------------
2315 compilerInfo :: DynFlags -> [(String, String)]
2317 = -- We always make "Project name" be first to keep parsing in
2318 -- other languages simple, i.e. when looking for other fields,
2319 -- you don't have to worry whether there is a leading '[' or not
2320 ("Project name", cProjectName)
2321 -- Next come the settings, so anything else can be overridden
2322 -- in the settings file (as "lookup" uses the first match for the
2324 : rawSettings dflags
2325 ++ [("Project version", cProjectVersion),
2326 ("Booter version", cBooterVersion),
2328 ("Build platform", cBuildPlatformString),
2329 ("Host platform", cHostPlatformString),
2330 ("Target platform", cTargetPlatformString),
2331 ("Have interpreter", cGhcWithInterpreter),
2332 ("Object splitting supported", cSupportsSplitObjs),
2333 ("Have native code generator", cGhcWithNativeCodeGen),
2334 ("Support SMP", cGhcWithSMP),
2335 ("Unregisterised", cGhcUnregisterised),
2336 ("Tables next to code", cGhcEnableTablesNextToCode),
2337 ("RTS ways", cGhcRTSWays),
2338 ("Leading underscore", cLeadingUnderscore),
2339 ("Debug on", show debugIsOn),
2340 ("LibDir", topDir dflags),
2341 ("Global Package DB", systemPackageConfig dflags),
2342 ("Gcc Linker flags", show cGccLinkerOpts),
2343 ("Ld Linker flags", show cLdLinkerOpts)
projects / ghc-hetmet.git / blob