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
63 machdepCCOpts, picCCOpts,
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"
80 #ifndef OMIT_NATIVE_CODEGEN
85 import PrelNames ( mAIN )
87 import {-# SOURCE #-} Packages (PackageState)
88 import DriverPhases ( Phase(..), phaseInputExt )
91 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
94 import Maybes ( orElse )
99 import Foreign.C ( CInt )
101 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
104 import System.IO.Unsafe ( unsafePerformIO )
107 import Control.Monad ( when )
111 import Data.Map (Map)
112 import qualified Data.Map as Map
114 import System.FilePath
115 import System.IO ( stderr, hPutChar )
117 -- -----------------------------------------------------------------------------
120 -- | Enumerates the simple on-or-off dynamic flags
127 | Opt_D_dump_cmmz_pretty
131 | Opt_D_dump_asm_native
132 | Opt_D_dump_asm_liveness
133 | Opt_D_dump_asm_coalesce
134 | Opt_D_dump_asm_regalloc
135 | Opt_D_dump_asm_regalloc_stages
136 | Opt_D_dump_asm_conflicts
137 | Opt_D_dump_asm_stats
138 | Opt_D_dump_asm_expanded
140 | Opt_D_dump_core_stats
146 | Opt_D_dump_inlinings
147 | Opt_D_dump_rule_firings
148 | Opt_D_dump_rule_rewrites
149 | Opt_D_dump_occur_anal
153 | Opt_D_dump_simpl_iterations
154 | Opt_D_dump_simpl_phases
163 | Opt_D_dump_worker_wrapper
164 | Opt_D_dump_rn_trace
165 | Opt_D_dump_rn_stats
167 | Opt_D_dump_simpl_stats
168 | Opt_D_dump_cs_trace -- Constraint solver in type checker
169 | Opt_D_dump_tc_trace
170 | Opt_D_dump_if_trace
171 | Opt_D_dump_vt_trace
178 | Opt_D_verbose_core2core
179 | Opt_D_verbose_stg2stg
181 | Opt_D_dump_hi_diffs
182 | Opt_D_dump_minimal_imports
183 | Opt_D_dump_mod_cycles
184 | Opt_D_dump_view_pattern_commoning
185 | Opt_D_faststring_stats
186 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
187 | Opt_D_no_debug_output
193 | Opt_F_coqpass -- run the core-to-core coqPass, but don't change anything (just "parse/unparse")
194 | Opt_F_skolemize -- run the core-to-core coqPass, skolemizing the proof
195 | Opt_F_flatten -- run the core-to-core coqPass, flattening the proof
196 | Opt_D_dump_proofs -- dump natural deduction typing proof of the coqpass input
197 | Opt_D_coqpass -- run the core-to-string coqPass and dumps the result
199 | Opt_WarnIsError -- -Werror; makes warnings fatal
200 | Opt_WarnDuplicateExports
202 | Opt_WarnImplicitPrelude
203 | Opt_WarnIncompletePatterns
204 | Opt_WarnIncompleteUniPatterns
205 | Opt_WarnIncompletePatternsRecUpd
206 | Opt_WarnMissingFields
207 | Opt_WarnMissingImportList
208 | Opt_WarnMissingMethods
209 | Opt_WarnMissingSigs
210 | Opt_WarnMissingLocalSigs
211 | Opt_WarnNameShadowing
212 | Opt_WarnOverlappingPatterns
213 | Opt_WarnTypeDefaults
214 | Opt_WarnMonomorphism
215 | Opt_WarnUnusedBinds
216 | Opt_WarnUnusedImports
217 | Opt_WarnUnusedMatches
218 | Opt_WarnWarningsDeprecations
219 | Opt_WarnDeprecatedFlags
220 | Opt_WarnDodgyExports
221 | Opt_WarnDodgyImports
223 | Opt_WarnAutoOrphans
226 | Opt_WarnUnrecognisedPragmas
227 | Opt_WarnDodgyForeignImports
228 | Opt_WarnLazyUnliftedBindings
229 | Opt_WarnUnusedDoBind
230 | Opt_WarnWrongDoBind
231 | Opt_WarnAlternativeLayoutRuleTransitional
233 | Opt_PrintExplicitForalls
240 | Opt_StaticArgumentTransformation
244 | Opt_DoLambdaEtaExpansion
248 | Opt_UnboxStrictFields
249 | Opt_MethodSharing -- Now a no-op; remove in GHC 7.2
251 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
253 | Opt_RegsGraph -- do graph coloring register allocation
254 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
257 | Opt_IgnoreInterfacePragmas
258 | Opt_OmitInterfacePragmas
259 | Opt_ExposeAllUnfoldings
262 | Opt_AutoSccsOnAllToplevs
263 | Opt_AutoSccsOnExportedToplevs
264 | Opt_AutoSccsOnIndividualCafs
270 | Opt_ExcessPrecision
271 | Opt_EagerBlackHoling
272 | Opt_ReadUserPackageConf
276 | Opt_HideAllPackages
277 | Opt_PrintBindResult
281 | Opt_BreakOnException
283 | Opt_PrintEvldWithShow
284 | Opt_PrintBindContents
287 | Opt_EmitExternalCore
289 | Opt_BuildingCabalPackage
297 | Opt_ConvertToZipCfgAndBack
298 | Opt_AutoLinkPackages
299 | Opt_ImplicitImportQualified
307 | Opt_KeepRawTokenStream
312 data Language = Haskell98 | Haskell2010
316 | Opt_OverlappingInstances
317 | Opt_UndecidableInstances
318 | Opt_IncoherentInstances
319 | Opt_MonomorphismRestriction
322 | Opt_RelaxedPolyRec -- Deprecated
323 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
324 | Opt_ForeignFunctionInterface
325 | Opt_UnliftedFFITypes
326 | Opt_GHCForeignImportPrim
327 | Opt_ParallelArrays -- Syntactic support for parallel arrays
328 | Opt_Arrows -- Arrow-notation syntax
329 | Opt_ModalTypes -- Heterogeneous Metaprogramming (modal types, brackets, escape, CSP)
330 | Opt_TemplateHaskell
333 | Opt_Generics -- "Derivable type classes"
334 | Opt_ImplicitPrelude
335 | Opt_ScopedTypeVariables
339 | Opt_OverloadedStrings
340 | Opt_DisambiguateRecordFields
341 | Opt_RecordWildCards
347 | Opt_DoAndIfThenElse
348 | Opt_RebindableSyntax
350 | Opt_StandaloneDeriving
351 | Opt_DeriveDataTypeable
353 | Opt_DeriveTraversable
356 | Opt_TypeSynonymInstances
357 | Opt_FlexibleContexts
358 | Opt_FlexibleInstances
359 | Opt_ConstrainedClassMethods
360 | Opt_MultiParamTypeClasses
361 | Opt_FunctionalDependencies
363 | Opt_PolymorphicComponents
364 | Opt_ExistentialQuantification
368 | Opt_ParallelListComp
369 | Opt_TransformListComp
370 | Opt_GeneralizedNewtypeDeriving
373 | Opt_PostfixOperators
376 | Opt_LiberalTypeSynonyms
379 | Opt_ImpredicativeTypes
383 | Opt_AlternativeLayoutRule
384 | Opt_AlternativeLayoutRuleTransitional
385 | Opt_DatatypeContexts
386 | Opt_NondecreasingIndentation
390 -- | Contains not only a collection of 'DynFlag's but also a plethora of
391 -- information relating to the compilation of a single file or GHC session
392 data DynFlags = DynFlags {
395 hscTarget :: HscTarget,
396 hscOutName :: String, -- ^ Name of the output file
397 extCoreName :: String, -- ^ Name of the .hcr output file
398 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
399 optLevel :: Int, -- ^ Optimisation level
400 simplPhases :: Int, -- ^ Number of simplifier phases
401 maxSimplIterations :: Int, -- ^ Max simplifier iterations
402 shouldDumpSimplPhase :: Maybe String,
403 ruleCheck :: Maybe String,
404 strictnessBefore :: [Int], -- ^ Additional demand analysis
406 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
407 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
408 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
409 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
410 -- See CoreMonad.FloatOutSwitches
412 #ifndef OMIT_NATIVE_CODEGEN
413 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
415 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
416 importPaths :: [FilePath],
418 mainFunIs :: Maybe String,
419 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
421 dphBackend :: DPHBackend,
423 thisPackage :: PackageId, -- ^ name of package currently being compiled
426 ways :: [Way], -- ^ Way flags from the command line
427 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
428 rtsBuildTag :: String, -- ^ The RTS \"way\"
430 -- For object splitting
431 splitInfo :: Maybe (String,Int),
434 objectDir :: Maybe String,
435 dylibInstallName :: Maybe String,
436 hiDir :: Maybe String,
437 stubDir :: Maybe String,
443 outputFile :: Maybe String,
444 outputHi :: Maybe String,
445 dynLibLoader :: DynLibLoader,
447 -- | This is set by 'DriverPipeline.runPipeline' based on where
448 -- its output is going.
449 dumpPrefix :: Maybe FilePath,
451 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
452 -- Set by @-ddump-file-prefix@
453 dumpPrefixForce :: Maybe FilePath,
455 includePaths :: [String],
456 libraryPaths :: [String],
457 frameworkPaths :: [String], -- used on darwin only
458 cmdlineFrameworks :: [String], -- ditto
460 rtsOpts :: Maybe String,
461 rtsOptsEnabled :: RtsOptsEnabled,
463 hpcDir :: String, -- ^ Path to store the .mix files
465 settings :: Settings,
468 depMakefile :: FilePath,
469 depIncludePkgDeps :: Bool,
470 depExcludeMods :: [ModuleName],
471 depSuffixes :: [String],
474 extraPkgConfs :: [FilePath],
475 -- ^ The @-package-conf@ flags given on the command line, in the order
478 packageFlags :: [PackageFlag],
479 -- ^ The @-package@ and @-hide-package@ flags from the command-line
482 -- NB. do not modify this field, it is calculated by
483 -- Packages.initPackages and Packages.updatePackages.
484 pkgDatabase :: Maybe [PackageConfig],
485 pkgState :: PackageState,
488 -- These have to be IORefs, because the defaultCleanupHandler needs to
489 -- know what to clean when an exception happens
490 filesToClean :: IORef [FilePath],
491 dirsToClean :: IORef (Map FilePath FilePath),
495 -- Don't change this without updating extensionFlags:
496 language :: Maybe Language,
497 -- Don't change this without updating extensionFlags:
498 extensions :: [OnOff ExtensionFlag],
499 -- extensionFlags should always be equal to
500 -- flattenExtensionFlags language extensions
501 extensionFlags :: [ExtensionFlag],
503 -- | Message output action: use "ErrUtils" instead of this if you can
504 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
506 haddockOptions :: Maybe String
509 data Settings = Settings {
510 sGhcUsagePath :: FilePath, -- Filled in by SysTools
511 sGhciUsagePath :: FilePath, -- ditto
513 sTmpDir :: String, -- no trailing '/'
514 -- You shouldn't need to look things up in rawSettings directly.
515 -- They should have their own fields instead.
516 sRawSettings :: [(String, String)],
517 sExtraGccViaCFlags :: [String],
518 sSystemPackageConfig :: FilePath,
519 -- commands for particular phases
521 sPgm_P :: (String,[Option]),
523 sPgm_c :: (String,[Option]),
524 sPgm_s :: (String,[Option]),
525 sPgm_a :: (String,[Option]),
526 sPgm_l :: (String,[Option]),
527 sPgm_dll :: (String,[Option]),
529 sPgm_sysman :: String,
530 sPgm_windres :: String,
531 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
532 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
533 -- options for particular phases
541 sOpt_windres :: [String],
542 sOpt_lo :: [String], -- LLVM: llvm optimiser
543 sOpt_lc :: [String] -- LLVM: llc static compiler
547 ghcUsagePath :: DynFlags -> FilePath
548 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
549 ghciUsagePath :: DynFlags -> FilePath
550 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
551 topDir :: DynFlags -> FilePath
552 topDir dflags = sTopDir (settings dflags)
553 tmpDir :: DynFlags -> String
554 tmpDir dflags = sTmpDir (settings dflags)
555 rawSettings :: DynFlags -> [(String, String)]
556 rawSettings dflags = sRawSettings (settings dflags)
557 extraGccViaCFlags :: DynFlags -> [String]
558 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
559 systemPackageConfig :: DynFlags -> FilePath
560 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
561 pgm_L :: DynFlags -> String
562 pgm_L dflags = sPgm_L (settings dflags)
563 pgm_P :: DynFlags -> (String,[Option])
564 pgm_P dflags = sPgm_P (settings dflags)
565 pgm_F :: DynFlags -> String
566 pgm_F dflags = sPgm_F (settings dflags)
567 pgm_c :: DynFlags -> (String,[Option])
568 pgm_c dflags = sPgm_c (settings dflags)
569 pgm_s :: DynFlags -> (String,[Option])
570 pgm_s dflags = sPgm_s (settings dflags)
571 pgm_a :: DynFlags -> (String,[Option])
572 pgm_a dflags = sPgm_a (settings dflags)
573 pgm_l :: DynFlags -> (String,[Option])
574 pgm_l dflags = sPgm_l (settings dflags)
575 pgm_dll :: DynFlags -> (String,[Option])
576 pgm_dll dflags = sPgm_dll (settings dflags)
577 pgm_T :: DynFlags -> String
578 pgm_T dflags = sPgm_T (settings dflags)
579 pgm_sysman :: DynFlags -> String
580 pgm_sysman dflags = sPgm_sysman (settings dflags)
581 pgm_windres :: DynFlags -> String
582 pgm_windres dflags = sPgm_windres (settings dflags)
583 pgm_lo :: DynFlags -> (String,[Option])
584 pgm_lo dflags = sPgm_lo (settings dflags)
585 pgm_lc :: DynFlags -> (String,[Option])
586 pgm_lc dflags = sPgm_lc (settings dflags)
587 opt_L :: DynFlags -> [String]
588 opt_L dflags = sOpt_L (settings dflags)
589 opt_P :: DynFlags -> [String]
590 opt_P dflags = sOpt_P (settings dflags)
591 opt_F :: DynFlags -> [String]
592 opt_F dflags = sOpt_F (settings dflags)
593 opt_c :: DynFlags -> [String]
594 opt_c dflags = sOpt_c (settings dflags)
595 opt_m :: DynFlags -> [String]
596 opt_m dflags = sOpt_m (settings dflags)
597 opt_a :: DynFlags -> [String]
598 opt_a dflags = sOpt_a (settings dflags)
599 opt_l :: DynFlags -> [String]
600 opt_l dflags = sOpt_l (settings dflags)
601 opt_windres :: DynFlags -> [String]
602 opt_windres dflags = sOpt_windres (settings dflags)
603 opt_lo :: DynFlags -> [String]
604 opt_lo dflags = sOpt_lo (settings dflags)
605 opt_lc :: DynFlags -> [String]
606 opt_lc dflags = sOpt_lc (settings dflags)
608 wayNames :: DynFlags -> [WayName]
609 wayNames = map wayName . ways
611 -- | The target code type of the compilation (if any).
613 -- Whenever you change the target, also make sure to set 'ghcLink' to
614 -- something sensible.
616 -- 'HscNothing' can be used to avoid generating any output, however, note
619 -- * This will not run the desugaring step, thus no warnings generated in
620 -- this step will be output. In particular, this includes warnings related
621 -- to pattern matching. You can run the desugarer manually using
622 -- 'GHC.desugarModule'.
624 -- * If a program uses Template Haskell the typechecker may try to run code
625 -- from an imported module. This will fail if no code has been generated
626 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
627 -- whether this might be the case and choose to either switch to a
628 -- different target or avoid typechecking such modules. (The latter may
629 -- preferable for security reasons.)
632 = HscC -- ^ Generate C code.
633 | HscAsm -- ^ Generate assembly using the native code generator.
634 | HscLlvm -- ^ Generate assembly using the llvm code generator.
635 | HscJava -- ^ Generate Java bytecode.
636 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
637 | HscNothing -- ^ Don't generate any code. See notes above.
640 -- | Will this target result in an object file on the disk?
641 isObjectTarget :: HscTarget -> Bool
642 isObjectTarget HscC = True
643 isObjectTarget HscAsm = True
644 isObjectTarget HscLlvm = True
645 isObjectTarget _ = False
647 -- | The 'GhcMode' tells us whether we're doing multi-module
648 -- compilation (controlled via the "GHC" API) or one-shot
649 -- (single-module) compilation. This makes a difference primarily to
650 -- the "Finder": in one-shot mode we look for interface files for
651 -- imported modules, but in multi-module mode we look for source files
652 -- in order to check whether they need to be recompiled.
654 = CompManager -- ^ @\-\-make@, GHCi, etc.
655 | OneShot -- ^ @ghc -c Foo.hs@
656 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
659 instance Outputable GhcMode where
660 ppr CompManager = ptext (sLit "CompManager")
661 ppr OneShot = ptext (sLit "OneShot")
662 ppr MkDepend = ptext (sLit "MkDepend")
664 isOneShot :: GhcMode -> Bool
665 isOneShot OneShot = True
666 isOneShot _other = False
668 -- | What to do in the link step, if there is one.
670 = NoLink -- ^ Don't link at all
671 | LinkBinary -- ^ Link object code into a binary
672 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
673 -- bytecode and object code).
674 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
677 isNoLink :: GhcLink -> Bool
678 isNoLink NoLink = True
681 -- Is it worth evaluating this Bool and caching it in the DynFlags value
682 -- during initDynFlags?
683 doingTickyProfiling :: DynFlags -> Bool
684 doingTickyProfiling _ = opt_Ticky
685 -- XXX -ticky is a static flag, because it implies -debug which is also
686 -- static. If the way flags were made dynamic, we could fix this.
689 = ExposePackage String
690 | ExposePackageId String
692 | IgnorePackage String
695 defaultHscTarget :: HscTarget
696 defaultHscTarget = defaultObjectTarget
698 -- | The 'HscTarget' value corresponding to the default way to create
699 -- object files on the current platform.
700 defaultObjectTarget :: HscTarget
702 | cGhcWithNativeCodeGen == "YES" = HscAsm
710 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
713 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
714 initDynFlags :: DynFlags -> IO DynFlags
715 initDynFlags dflags = do
716 -- someday these will be dynamic flags
717 ways <- readIORef v_Ways
718 refFilesToClean <- newIORef []
719 refDirsToClean <- newIORef Map.empty
722 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
723 rtsBuildTag = mkBuildTag ways,
724 filesToClean = refFilesToClean,
725 dirsToClean = refDirsToClean
728 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
729 -- and must be fully initialized by 'GHC.newSession' first.
730 defaultDynFlags :: Settings -> DynFlags
731 defaultDynFlags mySettings =
733 ghcMode = CompManager,
734 ghcLink = LinkBinary,
735 hscTarget = defaultHscTarget,
741 maxSimplIterations = 4,
742 shouldDumpSimplPhase = Nothing,
744 specConstrThreshold = Just 200,
745 specConstrCount = Just 3,
746 liberateCaseThreshold = Just 200,
747 floatLamArgs = Just 0, -- Default: float only if no fvs
748 strictnessBefore = [],
750 #ifndef OMIT_NATIVE_CODEGEN
751 targetPlatform = defaultTargetPlatform,
753 cmdlineHcIncludes = [],
757 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
759 dphBackend = DPHNone,
761 thisPackage = mainPackageId,
764 dylibInstallName = Nothing,
768 objectSuf = phaseInputExt StopLn,
769 hcSuf = phaseInputExt HCc,
772 outputFile = Nothing,
774 dynLibLoader = SystemDependent,
775 dumpPrefix = Nothing,
776 dumpPrefixForce = Nothing,
780 cmdlineFrameworks = [],
782 rtsOptsEnabled = RtsOptsSafeOnly,
788 pkgDatabase = Nothing,
789 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
790 ways = panic "defaultDynFlags: No ways",
791 buildTag = panic "defaultDynFlags: No buildTag",
792 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
794 settings = mySettings,
796 depMakefile = "Makefile",
797 depIncludePkgDeps = False,
800 -- end of ghc -M values
801 filesToClean = panic "defaultDynFlags: No filesToClean",
802 dirsToClean = panic "defaultDynFlags: No dirsToClean",
803 haddockOptions = Nothing,
804 flags = defaultFlags,
807 extensionFlags = flattenExtensionFlags Nothing [],
809 log_action = \severity srcSpan style msg ->
811 SevOutput -> printOutput (msg style)
812 SevInfo -> printErrs (msg style)
813 SevFatal -> printErrs (msg style)
816 printErrs ((mkLocMessage srcSpan msg) style)
817 -- careful (#2302): printErrs prints in UTF-8, whereas
818 -- converting to string first and using hPutStr would
819 -- just emit the low 8 bits of each unicode char.
823 Note [Verbosity levels]
824 ~~~~~~~~~~~~~~~~~~~~~~~
825 0 | print errors & warnings only
826 1 | minimal verbosity: print "compiling M ... done." for each module.
827 2 | equivalent to -dshow-passes
828 3 | equivalent to existing "ghc -v"
829 4 | "ghc -v -ddump-most"
830 5 | "ghc -v -ddump-all"
836 -- OnOffs accumulate in reverse order, so we use foldr in order to
837 -- process them in the right order
838 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
840 flattenExtensionFlags ml = foldr f defaultExtensionFlags
841 where f (On f) flags = f : delete f flags
842 f (Off f) flags = delete f flags
843 defaultExtensionFlags = languageExtensions ml
845 languageExtensions :: Maybe Language -> [ExtensionFlag]
847 languageExtensions Nothing
848 -- Nothing => the default case
849 = Opt_MonoPatBinds -- Experimentally, I'm making this non-standard
850 -- behaviour the default, to see if anyone notices
852 -- In due course I'd like Opt_MonoLocalBinds to be on by default
853 -- But NB it's implied by GADTs etc
854 -- SLPJ September 2010
855 : Opt_NondecreasingIndentation -- This has been on by default for some time
856 : languageExtensions (Just Haskell2010)
858 languageExtensions (Just Haskell98)
859 = [Opt_ImplicitPrelude,
860 Opt_MonomorphismRestriction,
862 Opt_DatatypeContexts,
863 Opt_NondecreasingIndentation
864 -- strictly speaking non-standard, but we always had this
865 -- on implicitly before the option was added in 7.1, and
866 -- turning it off breaks code, so we're keeping it on for
867 -- backwards compatibility. Cabal uses -XHaskell98 by
868 -- default unless you specify another language.
871 languageExtensions (Just Haskell2010)
872 = [Opt_ImplicitPrelude,
873 Opt_MonomorphismRestriction,
874 Opt_DatatypeContexts,
876 Opt_ForeignFunctionInterface,
881 -- | Test whether a 'DynFlag' is set
882 dopt :: DynFlag -> DynFlags -> Bool
883 dopt f dflags = f `elem` (flags dflags)
886 dopt_set :: DynFlags -> DynFlag -> DynFlags
887 dopt_set dfs f = dfs{ flags = f : flags dfs }
889 -- | Unset a 'DynFlag'
890 dopt_unset :: DynFlags -> DynFlag -> DynFlags
891 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
893 -- | Test whether a 'ExtensionFlag' is set
894 xopt :: ExtensionFlag -> DynFlags -> Bool
895 xopt f dflags = f `elem` extensionFlags dflags
897 -- | Set a 'ExtensionFlag'
898 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
900 = let onoffs = On f : extensions dfs
901 in dfs { extensions = onoffs,
902 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
904 -- | Unset a 'ExtensionFlag'
905 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
907 = let onoffs = Off f : extensions dfs
908 in dfs { extensions = onoffs,
909 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
911 setLanguage :: Language -> DynP ()
912 setLanguage l = upd f
913 where f dfs = let mLang = Just l
914 oneoffs = extensions dfs
917 extensionFlags = flattenExtensionFlags mLang oneoffs
920 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
921 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
922 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
923 -> [a] -- ^ Correctly ordered extracted options
924 getOpts dflags opts = reverse (opts dflags)
925 -- We add to the options from the front, so we need to reverse the list
927 -- | Gets the verbosity flag for the current verbosity level. This is fed to
928 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
929 getVerbFlags :: DynFlags -> [String]
931 | verbosity dflags >= 4 = ["-v"]
934 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
935 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
936 setPgmP, addOptl, addOptP,
937 addCmdlineFramework, addHaddockOpts
938 :: String -> DynFlags -> DynFlags
939 setOutputFile, setOutputHi, setDumpPrefixForce
940 :: Maybe String -> DynFlags -> DynFlags
942 setObjectDir f d = d{ objectDir = Just f}
943 setHiDir f d = d{ hiDir = Just f}
944 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
945 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
946 -- \#included from the .hc file when compiling via C (i.e. unregisterised
948 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
949 setDylibInstallName f d = d{ dylibInstallName = Just f}
951 setObjectSuf f d = d{ objectSuf = f}
952 setHiSuf f d = d{ hiSuf = f}
953 setHcSuf f d = d{ hcSuf = f}
955 setOutputFile f d = d{ outputFile = f}
956 setOutputHi f d = d{ outputHi = f}
958 parseDynLibLoaderMode f d =
960 ("deploy", "") -> d{ dynLibLoader = Deployable }
961 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
962 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
964 setDumpPrefixForce f d = d { dumpPrefixForce = f}
966 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
967 -- Config.hs should really use Option.
968 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
969 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
970 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
973 setDepMakefile :: FilePath -> DynFlags -> DynFlags
974 setDepMakefile f d = d { depMakefile = deOptDep f }
976 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
977 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
979 addDepExcludeMod :: String -> DynFlags -> DynFlags
981 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
983 addDepSuffix :: FilePath -> DynFlags -> DynFlags
984 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
987 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
988 -- we need to strip the "-optdep" off of the arg
989 deOptDep :: String -> String
990 deOptDep x = case stripPrefix "-optdep" x of
994 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
996 addHaddockOpts f d = d{ haddockOptions = Just f}
998 -- -----------------------------------------------------------------------------
999 -- Command-line options
1001 -- | When invoking external tools as part of the compilation pipeline, we
1002 -- pass these a sequence of options on the command-line. Rather than
1003 -- just using a list of Strings, we use a type that allows us to distinguish
1004 -- between filepaths and 'other stuff'. The reason for this is that
1005 -- this type gives us a handle on transforming filenames, and filenames only,
1006 -- to whatever format they're expected to be on a particular platform.
1008 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1009 String -- a non-filepath prefix that shouldn't be
1010 -- transformed (e.g., "/out=")
1011 String -- the filepath/filename portion
1014 showOpt :: Option -> String
1015 showOpt (FileOption pre f) = pre ++ f
1016 showOpt (Option s) = s
1018 -----------------------------------------------------------------------------
1019 -- Setting the optimisation level
1021 updOptLevel :: Int -> DynFlags -> DynFlags
1022 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1024 = dfs2{ optLevel = final_n }
1026 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1027 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1028 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1030 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1031 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1033 -- -----------------------------------------------------------------------------
1034 -- StgToDo: abstraction of stg-to-stg passes to run.
1037 = StgDoMassageForProfiling -- should be (next to) last
1038 -- There's also setStgVarInfo, but its absolute "lastness"
1039 -- is so critical that it is hardwired in (no flag).
1042 getStgToDo :: DynFlags -> [StgToDo]
1046 stg_stats = dopt Opt_StgStats dflags
1048 todo1 = if stg_stats then [D_stg_stats] else []
1050 todo2 | WayProf `elem` wayNames dflags
1051 = StgDoMassageForProfiling : todo1
1055 {- **********************************************************************
1059 %********************************************************************* -}
1061 -- -----------------------------------------------------------------------------
1062 -- Parsing the dynamic flags.
1064 -- | Parse dynamic flags from a list of command line arguments. Returns the
1065 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1066 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1067 -- flags or missing arguments).
1068 parseDynamicFlags :: Monad m =>
1069 DynFlags -> [Located String]
1070 -> m (DynFlags, [Located String], [Located String])
1071 -- ^ Updated 'DynFlags', left-over arguments, and
1072 -- list of warnings.
1073 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1075 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1076 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1077 parseDynamicNoPackageFlags :: Monad m =>
1078 DynFlags -> [Located String]
1079 -> m (DynFlags, [Located String], [Located String])
1080 -- ^ Updated 'DynFlags', left-over arguments, and
1081 -- list of warnings.
1082 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1084 parseDynamicFlags_ :: Monad m =>
1085 DynFlags -> [Located String] -> Bool
1086 -> m (DynFlags, [Located String], [Located String])
1087 parseDynamicFlags_ dflags0 args pkg_flags = do
1088 -- XXX Legacy support code
1089 -- We used to accept things like
1090 -- optdep-f -optdepdepend
1091 -- optdep-f -optdep depend
1092 -- optdep -f -optdepdepend
1093 -- optdep -f -optdep depend
1094 -- but the spaces trip up proper argument handling. So get rid of them.
1095 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1096 f (x : xs) = x : f xs
1100 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1101 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1102 | otherwise = dynamic_flags
1104 let ((leftover, errs, warns), dflags1)
1105 = runCmdLine (processArgs flag_spec args') dflags0
1106 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1108 let (pic_warns, dflags2)
1109 #if !(x86_64_TARGET_ARCH && linux_TARGET_OS)
1110 | (not opt_Static || opt_PIC) && hscTarget dflags1 == HscLlvm
1111 = ([L noSrcSpan $ "Warning: -fllvm is incompatible with -fPIC and -"
1112 ++ "dynamic on this platform;\n ignoring -fllvm"],
1113 dflags1{ hscTarget = HscAsm })
1115 | otherwise = ([], dflags1)
1117 return (dflags2, leftover, pic_warns ++ warns)
1120 {- **********************************************************************
1122 DynFlags specifications
1124 %********************************************************************* -}
1126 allFlags :: [String]
1127 allFlags = map ('-':) $
1128 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1129 map ("fno-"++) flags ++
1130 map ("f"++) flags ++
1131 map ("f"++) flags' ++
1132 map ("X"++) supportedExtensions
1133 where ok (PrefixPred _ _) = False
1135 flags = [ name | (name, _, _) <- fFlags ]
1136 flags' = [ name | (name, _, _) <- fLangFlags ]
1138 --------------- The main flags themselves ------------------
1139 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1141 Flag "n" (NoArg (setDynFlag Opt_DryRun))
1142 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1143 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1145 (HasArg (\s -> do { addCmdlineHCInclude s
1146 ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1147 , Flag "v" (OptIntSuffix setVerbosity)
1149 ------- Specific phases --------------------------------------------
1150 -- need to appear before -pgmL to be parsed as LLVM flags.
1151 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1152 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1153 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1154 , Flag "pgmP" (hasArg setPgmP)
1155 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1156 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1157 , Flag "pgmm" (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1158 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1159 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1160 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1161 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1162 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1164 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1165 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1166 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1167 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1168 , Flag "optP" (hasArg addOptP)
1169 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1170 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1171 , Flag "optm" (hasArg (\f -> alterSettings (\s -> s { sOpt_m = f : sOpt_m s})))
1172 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1173 , Flag "optl" (hasArg addOptl)
1174 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1177 (NoArg (if can_split
1178 then setDynFlag Opt_SplitObjs
1179 else addWarn "ignoring -fsplit-objs"))
1181 -------- ghc -M -----------------------------------------------------
1182 , Flag "dep-suffix" (hasArg addDepSuffix)
1183 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1184 , Flag "dep-makefile" (hasArg setDepMakefile)
1185 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1186 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1187 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1188 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1189 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1190 , Flag "exclude-module" (hasArg addDepExcludeMod)
1191 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1192 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1194 -------- Linking ----------------------------------------------------
1195 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1196 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1197 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1198 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1200 ------- Libraries ---------------------------------------------------
1201 , Flag "L" (Prefix addLibraryPath)
1202 , Flag "l" (AnySuffix (upd . addOptl))
1204 ------- Frameworks --------------------------------------------------
1205 -- -framework-path should really be -F ...
1206 , Flag "framework-path" (HasArg addFrameworkPath)
1207 , Flag "framework" (hasArg addCmdlineFramework)
1209 ------- Output Redirection ------------------------------------------
1210 , Flag "odir" (hasArg setObjectDir)
1211 , Flag "o" (SepArg (upd . setOutputFile . Just))
1212 , Flag "ohi" (hasArg (setOutputHi . Just ))
1213 , Flag "osuf" (hasArg setObjectSuf)
1214 , Flag "hcsuf" (hasArg setHcSuf)
1215 , Flag "hisuf" (hasArg setHiSuf)
1216 , Flag "hidir" (hasArg setHiDir)
1217 , Flag "tmpdir" (hasArg setTmpDir)
1218 , Flag "stubdir" (hasArg setStubDir)
1219 , Flag "outputdir" (hasArg setOutputDir)
1220 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1222 ------- Keeping temporary files -------------------------------------
1223 -- These can be singular (think ghc -c) or plural (think ghc --make)
1224 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1225 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1226 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1227 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1228 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1229 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1230 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1231 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles))
1232 -- This only makes sense as plural
1233 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1235 ------- Miscellaneous ----------------------------------------------
1236 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1237 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1238 , Flag "with-rtsopts" (HasArg setRtsOpts)
1239 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1240 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1241 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1242 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1243 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1244 , Flag "main-is" (SepArg setMainIs)
1245 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1246 , Flag "haddock-opts" (hasArg addHaddockOpts)
1247 , Flag "hpcdir" (SepArg setOptHpcDir)
1249 ------- recompilation checker --------------------------------------
1250 , Flag "recomp" (NoArg (do { unSetDynFlag Opt_ForceRecomp
1251 ; deprecate "Use -fno-force-recomp instead" }))
1252 , Flag "no-recomp" (NoArg (do { setDynFlag Opt_ForceRecomp
1253 ; deprecate "Use -fforce-recomp instead" }))
1255 ------ HsCpp opts ---------------------------------------------------
1256 , Flag "D" (AnySuffix (upd . addOptP))
1257 , Flag "U" (AnySuffix (upd . addOptP))
1259 ------- Include/Import Paths ----------------------------------------
1260 , Flag "I" (Prefix addIncludePath)
1261 , Flag "i" (OptPrefix addImportPath)
1263 ------ Debugging ----------------------------------------------------
1264 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1266 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1267 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1268 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1269 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1270 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1271 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1272 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1273 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1274 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1275 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1276 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1277 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1278 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1279 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1280 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1281 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1282 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1283 ; setDumpFlag' Opt_D_dump_llvm}))
1284 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1285 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1286 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1287 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1288 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1289 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1290 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1291 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1292 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1293 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1294 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1295 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1296 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1297 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1298 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1299 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1300 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1301 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1302 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1303 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1304 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1305 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1306 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1307 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1308 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1309 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1310 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1311 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1312 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1313 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1314 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1315 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1316 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1317 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1318 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1319 ; setVerboseCore2Core }))
1320 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1321 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1322 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1323 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1324 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1325 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1326 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1327 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1328 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1329 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1330 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1331 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1332 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1333 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1334 , Flag "dshow-passes" (NoArg (do forceRecompile
1335 setVerbosity (Just 2)))
1336 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1338 ------ Coq-in-GHC ---------------------------
1339 , Flag "ddump-proofs" (NoArg (setDynFlag Opt_D_dump_proofs))
1340 , Flag "ddump-coqpass" (NoArg (setDynFlag Opt_D_coqpass))
1341 , Flag "fcoqpass" (NoArg (setDynFlag Opt_F_coqpass))
1342 , Flag "fflatten" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten }))
1343 , Flag "funsafe-skolemize" (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten ; setDynFlag Opt_F_skolemize }))
1345 ------ Machine dependant (-m<blah>) stuff ---------------------------
1347 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1348 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1349 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1350 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1352 ------ Warning opts -------------------------------------------------
1353 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1354 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1355 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1356 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1357 , Flag "Wnot" (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1358 ; deprecate "Use -w instead" }))
1359 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1361 ------ Optimisation flags ------------------------------------------
1362 , Flag "O" (noArg (setOptLevel 1))
1363 , Flag "Onot" (noArgDF (setOptLevel 0) "Use -O0 instead")
1364 , Flag "Odph" (noArg setDPHOpt)
1365 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1366 -- If the number is missing, use 1
1368 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1369 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1370 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1371 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1372 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1373 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1374 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1375 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1376 , Flag "frule-check" (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1377 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1378 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1379 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1380 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1382 ------ Profiling ----------------------------------------------------
1384 -- XXX Should the -f* flags be deprecated?
1385 -- They don't seem to be documented
1386 , Flag "fauto-sccs-on-all-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1387 , Flag "auto-all" (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1388 , Flag "no-auto-all" (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1389 , Flag "fauto-sccs-on-exported-toplevs" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1390 , Flag "auto" (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1391 , Flag "no-auto" (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1392 , Flag "fauto-sccs-on-individual-cafs" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1393 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1394 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1396 ------ DPH flags ----------------------------------------------------
1398 , Flag "fdph-seq" (NoArg (setDPHBackend DPHSeq))
1399 , Flag "fdph-par" (NoArg (setDPHBackend DPHPar))
1400 , Flag "fdph-this" (NoArg (setDPHBackend DPHThis))
1401 , Flag "fdph-none" (NoArg (setDPHBackend DPHNone))
1403 ------ Compiler flags -----------------------------------------------
1405 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1406 , Flag "fvia-c" (NoArg
1407 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1408 , Flag "fvia-C" (NoArg
1409 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1410 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1412 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1413 setTarget HscNothing))
1414 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1415 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1416 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1417 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1419 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1420 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1421 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1422 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1423 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1424 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1425 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1427 package_flags :: [Flag (CmdLineP DynFlags)]
1429 ------- Packages ----------------------------------------------------
1430 Flag "package-conf" (HasArg extraPkgConf_)
1431 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1432 , Flag "package-name" (hasArg setPackageName)
1433 , Flag "package-id" (HasArg exposePackageId)
1434 , Flag "package" (HasArg exposePackage)
1435 , Flag "hide-package" (HasArg hidePackage)
1436 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1437 , Flag "ignore-package" (HasArg ignorePackage)
1438 , Flag "syslib" (HasArg (\s -> do { exposePackage s
1439 ; deprecate "Use -package instead" }))
1442 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1443 -- False <=> we are turning the flag off
1444 turnOn :: TurnOnFlag; turnOn = True
1445 turnOff :: TurnOnFlag; turnOff = False
1448 = ( String -- Flag in string form
1449 , flag -- Flag in internal form
1450 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1451 -- Typically, emit a warning or error
1453 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1454 -> String -- ^ The flag prefix
1455 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1456 -> FlagSpec flag -- ^ Specification of this particular flag
1457 -> Flag (CmdLineP DynFlags)
1458 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1459 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1461 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1462 deprecatedForExtension lang turn_on
1463 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1465 flag | turn_on = lang
1466 | otherwise = "No"++lang
1468 useInstead :: String -> TurnOnFlag -> DynP ()
1469 useInstead flag turn_on
1470 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1472 no = if turn_on then "" else "no-"
1474 nop :: TurnOnFlag -> DynP ()
1477 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1478 fFlags :: [FlagSpec DynFlag]
1480 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1481 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1482 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1483 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1484 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1485 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1486 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1487 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1488 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1489 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1490 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1491 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1492 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1493 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1494 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1495 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1496 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1497 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1498 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1499 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1500 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1501 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1502 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1503 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1504 ( "warn-orphans", Opt_WarnOrphans, nop ),
1505 ( "warn-identities", Opt_WarnIdentities, nop ),
1506 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1507 ( "warn-tabs", Opt_WarnTabs, nop ),
1508 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1509 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop),
1510 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1511 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1512 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1513 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1514 ( "strictness", Opt_Strictness, nop ),
1515 ( "specialise", Opt_Specialise, nop ),
1516 ( "float-in", Opt_FloatIn, nop ),
1517 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1518 ( "full-laziness", Opt_FullLaziness, nop ),
1519 ( "liberate-case", Opt_LiberateCase, nop ),
1520 ( "spec-constr", Opt_SpecConstr, nop ),
1521 ( "cse", Opt_CSE, nop ),
1522 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1523 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1524 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1525 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1526 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1527 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1528 ( "case-merge", Opt_CaseMerge, nop ),
1529 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1530 ( "method-sharing", Opt_MethodSharing,
1531 \_ -> deprecate "doesn't do anything any more"),
1532 -- Remove altogether in GHC 7.2
1533 ( "dicts-cheap", Opt_DictsCheap, nop ),
1534 ( "excess-precision", Opt_ExcessPrecision, nop ),
1535 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1536 ( "print-bind-result", Opt_PrintBindResult, nop ),
1537 ( "force-recomp", Opt_ForceRecomp, nop ),
1538 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1539 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1540 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1541 ( "break-on-exception", Opt_BreakOnException, nop ),
1542 ( "break-on-error", Opt_BreakOnError, nop ),
1543 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1544 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1545 ( "run-cps", Opt_RunCPS, nop ),
1546 ( "run-cpsz", Opt_RunCPSZ, nop ),
1547 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1548 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, nop ),
1549 ( "vectorise", Opt_Vectorise, nop ),
1550 ( "regs-graph", Opt_RegsGraph, nop ),
1551 ( "regs-iterative", Opt_RegsIterative, nop ),
1552 ( "gen-manifest", Opt_GenManifest, nop ),
1553 ( "embed-manifest", Opt_EmbedManifest, nop ),
1554 ( "ext-core", Opt_EmitExternalCore, nop ),
1555 ( "shared-implib", Opt_SharedImplib, nop ),
1556 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1557 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1558 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1559 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop )
1562 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1563 fLangFlags :: [FlagSpec ExtensionFlag]
1565 ( "th", Opt_TemplateHaskell,
1566 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1567 ( "fi", Opt_ForeignFunctionInterface,
1568 deprecatedForExtension "ForeignFunctionInterface" ),
1569 ( "ffi", Opt_ForeignFunctionInterface,
1570 deprecatedForExtension "ForeignFunctionInterface" ),
1571 ( "arrows", Opt_Arrows,
1572 deprecatedForExtension "Arrows" ),
1573 ( "generics", Opt_Generics,
1574 deprecatedForExtension "Generics" ),
1575 ( "implicit-prelude", Opt_ImplicitPrelude,
1576 deprecatedForExtension "ImplicitPrelude" ),
1577 ( "bang-patterns", Opt_BangPatterns,
1578 deprecatedForExtension "BangPatterns" ),
1579 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1580 deprecatedForExtension "MonomorphismRestriction" ),
1581 ( "mono-pat-binds", Opt_MonoPatBinds,
1582 deprecatedForExtension "MonoPatBinds" ),
1583 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1584 deprecatedForExtension "ExtendedDefaultRules" ),
1585 ( "implicit-params", Opt_ImplicitParams,
1586 deprecatedForExtension "ImplicitParams" ),
1587 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1588 deprecatedForExtension "ScopedTypeVariables" ),
1589 ( "parr", Opt_ParallelArrays,
1590 deprecatedForExtension "ParallelArrays" ),
1591 ( "PArr", Opt_ParallelArrays,
1592 deprecatedForExtension "ParallelArrays" ),
1593 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1594 deprecatedForExtension "OverlappingInstances" ),
1595 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1596 deprecatedForExtension "UndecidableInstances" ),
1597 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1598 deprecatedForExtension "IncoherentInstances" )
1601 supportedLanguages :: [String]
1602 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1604 supportedExtensions :: [String]
1605 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1607 supportedLanguagesAndExtensions :: [String]
1608 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1610 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1611 languageFlags :: [FlagSpec Language]
1613 ( "Haskell98", Haskell98, nop ),
1614 ( "Haskell2010", Haskell2010, nop )
1617 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1618 xFlags :: [FlagSpec ExtensionFlag]
1620 ( "CPP", Opt_Cpp, nop ),
1621 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1622 ( "TupleSections", Opt_TupleSections, nop ),
1623 ( "PatternGuards", Opt_PatternGuards, nop ),
1624 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1625 ( "MagicHash", Opt_MagicHash, nop ),
1626 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1627 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1628 ( "KindSignatures", Opt_KindSignatures, nop ),
1629 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1630 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1631 ( "TransformListComp", Opt_TransformListComp, nop ),
1632 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1633 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1634 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1635 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1636 ( "Rank2Types", Opt_Rank2Types, nop ),
1637 ( "RankNTypes", Opt_RankNTypes, nop ),
1638 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1639 ( "TypeOperators", Opt_TypeOperators, nop ),
1640 ( "RecursiveDo", Opt_RecursiveDo,
1641 deprecatedForExtension "DoRec"),
1642 ( "DoRec", Opt_DoRec, nop ),
1643 ( "Arrows", Opt_Arrows, nop ),
1644 ( "ModalTypes", Opt_ModalTypes, nop ),
1645 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1646 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1647 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1648 ( "Generics", Opt_Generics, nop ),
1649 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1650 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1651 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1652 ( "RecordPuns", Opt_RecordPuns,
1653 deprecatedForExtension "NamedFieldPuns" ),
1654 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1655 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1656 ( "GADTs", Opt_GADTs, nop ),
1657 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1658 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1659 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1660 ( "BangPatterns", Opt_BangPatterns, nop ),
1661 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1662 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1663 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1664 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1665 ( "MonoPatBinds", Opt_MonoPatBinds, nop ),
1666 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1667 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1668 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1669 ( "DatatypeContexts", Opt_DatatypeContexts, nop ),
1670 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1671 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1672 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1673 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1674 \ turn_on -> if not turn_on
1675 then deprecate "You can't turn off RelaxedPolyRec any more"
1677 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1678 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1679 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1681 ( "PatternSignatures", Opt_ScopedTypeVariables,
1682 deprecatedForExtension "ScopedTypeVariables" ),
1684 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1685 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1686 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1687 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1688 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1689 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1690 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1691 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1692 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1693 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1694 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1695 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1696 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, nop ),
1697 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1698 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1699 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1700 ( "PackageImports", Opt_PackageImports, nop )
1703 defaultFlags :: [DynFlag]
1705 = [ Opt_AutoLinkPackages,
1706 Opt_ReadUserPackageConf,
1710 #if GHC_DEFAULT_NEW_CODEGEN
1716 Opt_PrintBindContents,
1721 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1722 -- The default -O0 options
1726 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1728 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
1729 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
1730 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
1731 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
1732 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1733 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
1734 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
1735 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
1737 , (Opt_ModalTypes, turnOn, Opt_RankNTypes)
1738 , (Opt_ModalTypes, turnOn, Opt_ExplicitForAll)
1739 --, (Opt_ModalTypes, turnOn, Opt_RebindableSyntax)
1740 , (Opt_ModalTypes, turnOff, Opt_MonomorphismRestriction)
1742 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
1744 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
1745 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
1746 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
1748 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
1749 -- all over the place
1751 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
1753 -- Record wild-cards implies field disambiguation
1754 -- Otherwise if you write (C {..}) you may well get
1755 -- stuff like " 'a' not in scope ", which is a bit silly
1756 -- if the compiler has just filled in field 'a' of constructor 'C'
1757 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
1759 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1762 optLevelFlags :: [([Int], DynFlag)]
1764 = [ ([0], Opt_IgnoreInterfacePragmas)
1765 , ([0], Opt_OmitInterfacePragmas)
1767 , ([1,2], Opt_IgnoreAsserts)
1768 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
1770 , ([1,2], Opt_DoEtaReduction)
1771 , ([1,2], Opt_CaseMerge)
1772 , ([1,2], Opt_Strictness)
1774 , ([1,2], Opt_FullLaziness)
1775 , ([1,2], Opt_Specialise)
1776 , ([1,2], Opt_FloatIn)
1778 , ([2], Opt_LiberateCase)
1779 , ([2], Opt_SpecConstr)
1780 , ([2], Opt_RegsGraph)
1782 -- , ([2], Opt_StaticArgumentTransformation)
1783 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1784 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1785 -- several improvements to the heuristics, and I'm concerned that without
1786 -- those changes SAT will interfere with some attempts to write "high
1787 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1788 -- this year. In particular, the version in HEAD lacks the tail call
1789 -- criterion, so many things that look like reasonable loops will be
1790 -- turned into functions with extra (unneccesary) thunk creation.
1792 , ([0,1,2], Opt_DoLambdaEtaExpansion)
1793 -- This one is important for a tiresome reason:
1794 -- we want to make sure that the bindings for data
1795 -- constructors are eta-expanded. This is probably
1796 -- a good thing anyway, but it seems fragile.
1799 -- -----------------------------------------------------------------------------
1800 -- Standard sets of warning options
1802 standardWarnings :: [DynFlag]
1804 = [ Opt_WarnWarningsDeprecations,
1805 Opt_WarnDeprecatedFlags,
1806 Opt_WarnUnrecognisedPragmas,
1807 Opt_WarnOverlappingPatterns,
1808 Opt_WarnMissingFields,
1809 Opt_WarnMissingMethods,
1810 Opt_WarnDuplicateExports,
1811 Opt_WarnLazyUnliftedBindings,
1812 Opt_WarnDodgyForeignImports,
1813 Opt_WarnWrongDoBind,
1814 Opt_WarnAlternativeLayoutRuleTransitional
1817 minusWOpts :: [DynFlag]
1818 -- Things you get with -W
1820 = standardWarnings ++
1821 [ Opt_WarnUnusedBinds,
1822 Opt_WarnUnusedMatches,
1823 Opt_WarnUnusedImports,
1824 Opt_WarnIncompletePatterns,
1825 Opt_WarnDodgyExports,
1826 Opt_WarnDodgyImports
1829 minusWallOpts :: [DynFlag]
1830 -- Things you get with -Wall
1833 [ Opt_WarnTypeDefaults,
1834 Opt_WarnNameShadowing,
1835 Opt_WarnMissingSigs,
1838 Opt_WarnUnusedDoBind
1841 minuswRemovesOpts :: [DynFlag]
1842 -- minuswRemovesOpts should be every warning option
1846 Opt_WarnIncompletePatternsRecUpd,
1847 Opt_WarnIncompleteUniPatterns,
1848 Opt_WarnMonomorphism,
1849 Opt_WarnUnrecognisedPragmas,
1850 Opt_WarnAutoOrphans,
1851 Opt_WarnImplicitPrelude
1854 enableGlasgowExts :: DynP ()
1855 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1856 mapM_ setExtensionFlag glasgowExtsFlags
1858 disableGlasgowExts :: DynP ()
1859 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1860 mapM_ unSetExtensionFlag glasgowExtsFlags
1862 glasgowExtsFlags :: [ExtensionFlag]
1863 glasgowExtsFlags = [
1864 Opt_ForeignFunctionInterface
1865 , Opt_UnliftedFFITypes
1866 , Opt_ImplicitParams
1867 , Opt_ScopedTypeVariables
1869 , Opt_TypeSynonymInstances
1870 , Opt_StandaloneDeriving
1871 , Opt_DeriveDataTypeable
1873 , Opt_DeriveFoldable
1874 , Opt_DeriveTraversable
1875 , Opt_FlexibleContexts
1876 , Opt_FlexibleInstances
1877 , Opt_ConstrainedClassMethods
1878 , Opt_MultiParamTypeClasses
1879 , Opt_FunctionalDependencies
1881 , Opt_PolymorphicComponents
1882 , Opt_ExistentialQuantification
1884 , Opt_PostfixOperators
1886 , Opt_LiberalTypeSynonyms
1890 , Opt_ParallelListComp
1891 , Opt_EmptyDataDecls
1892 , Opt_KindSignatures
1893 , Opt_GeneralizedNewtypeDeriving ]
1896 -- Consult the RTS to find whether GHC itself has been built profiled
1897 -- If so, you can't use Template Haskell
1898 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1900 rtsIsProfiled :: Bool
1901 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1904 checkTemplateHaskellOk :: Bool -> DynP ()
1906 checkTemplateHaskellOk turn_on
1907 | turn_on && rtsIsProfiled
1908 = addErr "You can't use Template Haskell with a profiled compiler"
1912 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1913 -- so we simply say "ok". It doesn't matter because TH isn't
1914 -- available in stage 1 anyway.
1915 checkTemplateHaskellOk _ = return ()
1918 {- **********************************************************************
1920 DynFlags constructors
1922 %********************************************************************* -}
1924 type DynP = EwM (CmdLineP DynFlags)
1926 upd :: (DynFlags -> DynFlags) -> DynP ()
1927 upd f = liftEwM (do { dfs <- getCmdLineState
1928 ; putCmdLineState $! (f dfs) })
1930 --------------- Constructor functions for OptKind -----------------
1931 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1932 noArg fn = NoArg (upd fn)
1934 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1935 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1937 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1938 hasArg fn = HasArg (upd . fn)
1940 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1941 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1942 ; deprecate deprec })
1944 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1945 intSuffix fn = IntSuffix (\n -> upd (fn n))
1947 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
1948 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1950 --------------------------
1951 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1952 setDynFlag f = upd (\dfs -> dopt_set dfs f)
1953 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1955 --------------------------
1956 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
1957 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
1960 deps = [ if turn_on then setExtensionFlag d
1961 else unSetExtensionFlag d
1962 | (f', turn_on, d) <- impliedFlags, f' == f ]
1963 -- When you set f, set the ones it implies
1964 -- NB: use setExtensionFlag recursively, in case the implied flags
1965 -- implies further flags
1967 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
1968 -- When you un-set f, however, we don't un-set the things it implies
1969 -- (except for -fno-glasgow-exts, which is treated specially)
1971 --------------------------
1972 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
1973 alterSettings f dflags = dflags { settings = f (settings dflags) }
1975 --------------------------
1976 setDumpFlag' :: DynFlag -> DynP ()
1977 setDumpFlag' dump_flag
1978 = do { setDynFlag dump_flag
1979 ; when want_recomp forceRecompile }
1981 -- Certain dumpy-things are really interested in what's going
1982 -- on during recompilation checking, so in those cases we
1983 -- don't want to turn it off.
1984 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1985 Opt_D_dump_hi_diffs]
1987 forceRecompile :: DynP ()
1988 -- Whenver we -ddump, force recompilation (by switching off the
1989 -- recompilation checker), else you don't see the dump! However,
1990 -- don't switch it off in --make mode, else *everything* gets
1991 -- recompiled which probably isn't what you want
1992 forceRecompile = do { dfs <- liftEwM getCmdLineState
1993 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1995 force_recomp dfs = isOneShot (ghcMode dfs)
1997 setVerboseCore2Core :: DynP ()
1998 setVerboseCore2Core = do forceRecompile
1999 setDynFlag Opt_D_verbose_core2core
2000 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2003 setDumpSimplPhases :: String -> DynP ()
2004 setDumpSimplPhases s = do forceRecompile
2005 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2007 spec = case s of { ('=' : s') -> s'; _ -> s }
2009 setVerbosity :: Maybe Int -> DynP ()
2010 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2012 addCmdlineHCInclude :: String -> DynP ()
2013 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2015 extraPkgConf_ :: FilePath -> DynP ()
2016 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2018 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2020 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2022 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2024 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2026 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2028 setPackageName :: String -> DynFlags -> DynFlags
2029 setPackageName p s = s{ thisPackage = stringToPackageId p }
2031 -- If we're linking a binary, then only targets that produce object
2032 -- code are allowed (requests for other target types are ignored).
2033 setTarget :: HscTarget -> DynP ()
2034 setTarget l = upd set
2037 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2040 -- Changes the target only if we're compiling object code. This is
2041 -- used by -fasm and -fllvm, which switch from one to the other, but
2042 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2043 -- can be safely used in an OPTIONS_GHC pragma.
2044 setObjTarget :: HscTarget -> DynP ()
2045 setObjTarget l = upd set
2048 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2051 setOptLevel :: Int -> DynFlags -> DynFlags
2052 setOptLevel n dflags
2053 | hscTarget dflags == HscInterpreted && n > 0
2055 -- not in IO any more, oh well:
2056 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2058 = updOptLevel n dflags
2061 -- -Odph is equivalent to
2063 -- -O2 optimise as much as possible
2064 -- -fmax-simplifier-iterations20 this is necessary sometimes
2065 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2067 setDPHOpt :: DynFlags -> DynFlags
2068 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2072 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2073 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2074 -- vectoriser cannot be used.
2076 data DPHBackend = DPHPar -- "dph-par"
2077 | DPHSeq -- "dph-seq"
2078 | DPHThis -- the currently compiled package
2079 | DPHNone -- no DPH library available
2080 deriving(Eq, Ord, Enum, Show)
2082 setDPHBackend :: DPHBackend -> DynP ()
2083 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2085 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2087 dphPackageMaybe :: DynFlags -> Maybe PackageId
2088 dphPackageMaybe dflags
2089 = case dphBackend dflags of
2090 DPHPar -> Just dphParPackageId
2091 DPHSeq -> Just dphSeqPackageId
2092 DPHThis -> Just (thisPackage dflags)
2095 setMainIs :: String -> DynP ()
2097 | not (null main_fn) && isLower (head main_fn)
2098 -- The arg looked like "Foo.Bar.baz"
2099 = upd $ \d -> d{ mainFunIs = Just main_fn,
2100 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2102 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2103 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2105 | otherwise -- The arg looked like "baz"
2106 = upd $ \d -> d{ mainFunIs = Just arg }
2108 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2110 -----------------------------------------------------------------------------
2111 -- Paths & Libraries
2113 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2115 -- -i on its own deletes the import paths
2116 addImportPath "" = upd (\s -> s{importPaths = []})
2117 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2121 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2124 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2126 addFrameworkPath p =
2127 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2129 #ifndef mingw32_TARGET_OS
2130 split_marker :: Char
2131 split_marker = ':' -- not configurable (ToDo)
2134 splitPathList :: String -> [String]
2135 splitPathList s = filter notNull (splitUp s)
2136 -- empty paths are ignored: there might be a trailing
2137 -- ':' in the initial list, for example. Empty paths can
2138 -- cause confusion when they are translated into -I options
2139 -- for passing to gcc.
2141 #ifndef mingw32_TARGET_OS
2142 splitUp xs = split split_marker xs
2144 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2146 -- That is, if "foo:bar:baz" is used, this interpreted as
2147 -- consisting of three entries, 'foo', 'bar', 'baz'.
2148 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2149 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2151 -- Notice that no attempt is made to fully replace the 'standard'
2152 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2153 -- that this will cause too much breakage for users & ':' will
2154 -- work fine even with DOS paths, if you're not insisting on being silly.
2157 splitUp (x:':':div:xs) | div `elem` dir_markers
2158 = ((x:':':div:p): splitUp rs)
2160 (p,rs) = findNextPath xs
2161 -- we used to check for existence of the path here, but that
2162 -- required the IO monad to be threaded through the command-line
2163 -- parser which is quite inconvenient. The
2164 splitUp xs = cons p (splitUp rs)
2166 (p,rs) = findNextPath xs
2171 -- will be called either when we've consumed nought or the
2172 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2173 -- finding the next split marker.
2175 case break (`elem` split_markers) xs of
2176 (p, _:ds) -> (p, ds)
2179 split_markers :: [Char]
2180 split_markers = [':', ';']
2182 dir_markers :: [Char]
2183 dir_markers = ['/', '\\']
2186 -- -----------------------------------------------------------------------------
2187 -- tmpDir, where we store temporary files.
2189 setTmpDir :: FilePath -> DynFlags -> DynFlags
2190 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2191 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2192 -- seem necessary now --SDM 7/2/2008
2194 -----------------------------------------------------------------------------
2197 setRtsOpts :: String -> DynP ()
2198 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2200 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2201 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2203 -----------------------------------------------------------------------------
2206 setOptHpcDir :: String -> DynP ()
2207 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2209 -----------------------------------------------------------------------------
2210 -- Via-C compilation stuff
2212 -- There are some options that we need to pass to gcc when compiling
2213 -- Haskell code via C, but are only supported by recent versions of
2214 -- gcc. The configure script decides which of these options we need,
2215 -- and puts them in the "settings" file in $topdir. The advantage of
2216 -- having these in a separate file is that the file can be created at
2217 -- install-time depending on the available gcc version, and even
2218 -- re-generated later if gcc is upgraded.
2220 -- The options below are not dependent on the version of gcc, only the
2223 machdepCCOpts :: DynFlags -> [String] -- flags for all C compilations
2224 machdepCCOpts _ = cCcOpts ++ machdepCCOpts'
2226 machdepCCOpts' :: [String] -- flags for all C compilations
2228 #if alpha_TARGET_ARCH
2230 #ifdef HAVE_THREADED_RTS_SUPPORT
2234 -- For now, to suppress the gcc warning "call-clobbered
2235 -- register used for global register variable", we simply
2236 -- disable all warnings altogether using the -w flag. Oh well.
2238 #elif hppa_TARGET_ARCH
2239 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2240 -- (very nice, but too bad the HP /usr/include files don't agree.)
2241 = ["-D_HPUX_SOURCE"]
2243 #elif i386_TARGET_ARCH
2244 -- -fno-defer-pop : basically the same game as for m68k
2246 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2247 -- the fp (%ebp) for our register maps.
2248 = if opt_Static then ["-DDONT_WANT_WIN32_DLL_SUPPORT"] else []
2254 picCCOpts :: DynFlags -> [String]
2256 #if darwin_TARGET_OS
2257 -- Apple prefers to do things the other way round.
2258 -- PIC is on by default.
2259 -- -mdynamic-no-pic:
2260 -- Turn off PIC code generation.
2262 -- Don't generate "common" symbols - these are unwanted
2263 -- in dynamic libraries.
2266 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2268 = ["-mdynamic-no-pic"]
2269 #elif mingw32_TARGET_OS
2270 -- no -fPIC for Windows
2272 = ["-U __PIC__","-D__PIC__"]
2276 -- we need -fPIC for C files when we are compiling with -dynamic,
2277 -- otherwise things like stub.c files don't get compiled
2278 -- correctly. They need to reference data in the Haskell
2279 -- objects, but can't without -fPIC. See
2280 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2281 | opt_PIC || not opt_Static
2282 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2287 -- -----------------------------------------------------------------------------
2291 can_split = cSupportsSplitObjs == "YES"
2293 -- -----------------------------------------------------------------------------
2296 compilerInfo :: DynFlags -> [(String, String)]
2298 = -- We always make "Project name" be first to keep parsing in
2299 -- other languages simple, i.e. when looking for other fields,
2300 -- you don't have to worry whether there is a leading '[' or not
2301 ("Project name", cProjectName)
2302 -- Next come the settings, so anything else can be overridden
2303 -- in the settings file (as "lookup" uses the first match for the
2305 : rawSettings dflags
2306 ++ [("Project version", cProjectVersion),
2307 ("Booter version", cBooterVersion),
2309 ("Build platform", cBuildPlatformString),
2310 ("Host platform", cHostPlatformString),
2311 ("Target platform", cTargetPlatformString),
2312 ("Have interpreter", cGhcWithInterpreter),
2313 ("Object splitting supported", cSupportsSplitObjs),
2314 ("Have native code generator", cGhcWithNativeCodeGen),
2315 ("Support SMP", cGhcWithSMP),
2316 ("Unregisterised", cGhcUnregisterised),
2317 ("Tables next to code", cGhcEnableTablesNextToCode),
2318 ("RTS ways", cGhcRTSWays),
2319 ("Leading underscore", cLeadingUnderscore),
2320 ("Debug on", show debugIsOn),
2321 ("LibDir", topDir dflags),
2322 ("Global Package DB", systemPackageConfig dflags),
2323 ("C compiler flags", show cCcOpts),
2324 ("Gcc Linker flags", show cGccLinkerOpts),
2325 ("Ld Linker flags", show cLdLinkerOpts)