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
16 HscTarget(..), isObjectTarget, defaultObjectTarget,
17 GhcMode(..), isOneShot,
18 GhcLink(..), isNoLink,
26 -- ** Manipulating DynFlags
27 defaultDynFlags, -- DynFlags
28 initDynFlags, -- DynFlags -> IO DynFlags
30 dopt, -- DynFlag -> DynFlags -> Bool
31 dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
32 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
39 -- ** Parsing DynFlags
41 parseDynamicNoPackageFlags,
44 supportedLanguages, languageOptions,
46 -- ** DynFlag C compiler options
47 machdepCCOpts, picCCOpts,
49 -- * Configuration of the stg-to-stg passes
53 -- * Compiler configuration suitable for display to the user
58 #include "HsVersions.h"
60 #ifndef OMIT_NATIVE_CODEGEN
65 import PrelNames ( mAIN )
67 import {-# SOURCE #-} Packages (PackageState)
68 import DriverPhases ( Phase(..), phaseInputExt )
71 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
74 import Maybes ( orElse )
79 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
82 import Control.Monad ( when )
86 import System.FilePath
87 import System.IO ( stderr, hPutChar )
89 -- -----------------------------------------------------------------------------
92 -- | Enumerates the simple on-or-off dynamic flags
98 | Opt_D_dump_cmmz_pretty
102 | Opt_D_dump_asm_native
103 | Opt_D_dump_asm_liveness
104 | Opt_D_dump_asm_coalesce
105 | Opt_D_dump_asm_regalloc
106 | Opt_D_dump_asm_regalloc_stages
107 | Opt_D_dump_asm_conflicts
108 | Opt_D_dump_asm_stats
109 | Opt_D_dump_asm_expanded
116 | Opt_D_dump_inlinings
117 | Opt_D_dump_rule_firings
118 | Opt_D_dump_occur_anal
122 | Opt_D_dump_simpl_iterations
123 | Opt_D_dump_simpl_phases
132 | Opt_D_dump_worker_wrapper
133 | Opt_D_dump_rn_trace
134 | Opt_D_dump_rn_stats
136 | Opt_D_dump_simpl_stats
137 | Opt_D_dump_tc_trace
138 | Opt_D_dump_if_trace
145 | Opt_D_verbose_core2core
146 | Opt_D_verbose_stg2stg
148 | Opt_D_dump_hi_diffs
149 | Opt_D_dump_minimal_imports
150 | Opt_D_dump_mod_cycles
151 | Opt_D_dump_view_pattern_commoning
152 | Opt_D_faststring_stats
153 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
154 | Opt_D_no_debug_output
160 | Opt_WarnIsError -- -Werror; makes warnings fatal
161 | Opt_WarnDuplicateExports
163 | Opt_WarnImplicitPrelude
164 | Opt_WarnIncompletePatterns
165 | Opt_WarnIncompletePatternsRecUpd
166 | Opt_WarnMissingFields
167 | Opt_WarnMissingMethods
168 | Opt_WarnMissingSigs
169 | Opt_WarnNameShadowing
170 | Opt_WarnOverlappingPatterns
171 | Opt_WarnSimplePatterns
172 | Opt_WarnTypeDefaults
173 | Opt_WarnMonomorphism
174 | Opt_WarnUnusedBinds
175 | Opt_WarnUnusedImports
176 | Opt_WarnUnusedMatches
177 | Opt_WarnWarningsDeprecations
178 | Opt_WarnDeprecatedFlags
179 | Opt_WarnDodgyExports
180 | Opt_WarnDodgyImports
183 | Opt_WarnUnrecognisedPragmas
184 | Opt_WarnDodgyForeignImports
185 | Opt_WarnLazyUnliftedBindings
186 | Opt_WarnUnusedDoBind
187 | Opt_WarnWrongDoBind
188 | Opt_WarnAlternativeLayoutRuleTransitional
192 | Opt_OverlappingInstances
193 | Opt_UndecidableInstances
194 | Opt_IncoherentInstances
195 | Opt_MonomorphismRestriction
198 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
199 | Opt_ForeignFunctionInterface
200 | Opt_UnliftedFFITypes
201 | Opt_GHCForeignImportPrim
202 | Opt_PArr -- Syntactic support for parallel arrays
203 | Opt_Arrows -- Arrow-notation syntax
204 | Opt_TemplateHaskell
207 | Opt_Generics -- "Derivable type classes"
208 | Opt_ImplicitPrelude
209 | Opt_ScopedTypeVariables
213 | Opt_OverloadedStrings
214 | Opt_DisambiguateRecordFields
215 | Opt_RecordWildCards
222 | Opt_StandaloneDeriving
223 | Opt_DeriveDataTypeable
225 | Opt_DeriveTraversable
228 | Opt_TypeSynonymInstances
229 | Opt_FlexibleContexts
230 | Opt_FlexibleInstances
231 | Opt_ConstrainedClassMethods
232 | Opt_MultiParamTypeClasses
233 | Opt_FunctionalDependencies
235 | Opt_PolymorphicComponents
236 | Opt_ExistentialQuantification
240 | Opt_ParallelListComp
241 | Opt_TransformListComp
242 | Opt_GeneralizedNewtypeDeriving
245 | Opt_PostfixOperators
248 | Opt_LiberalTypeSynonyms
251 | Opt_ImpredicativeTypes
254 | Opt_NewQualifiedOperators
256 | Opt_AlternativeLayoutRule
257 | Opt_AlternativeLayoutRuleTransitional
259 | Opt_PrintExplicitForalls
266 | Opt_StaticArgumentTransformation
270 | Opt_DoLambdaEtaExpansion
274 | Opt_UnboxStrictFields
277 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
279 | Opt_RegsGraph -- do graph coloring register allocation
280 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
283 | Opt_IgnoreInterfacePragmas
284 | Opt_OmitInterfacePragmas
285 | Opt_ExposeAllUnfoldings
288 | Opt_AutoSccsOnAllToplevs
289 | Opt_AutoSccsOnExportedToplevs
290 | Opt_AutoSccsOnIndividualCafs
298 | Opt_ExcessPrecision
299 | Opt_EagerBlackHoling
300 | Opt_ReadUserPackageConf
305 | Opt_HideAllPackages
306 | Opt_PrintBindResult
310 | Opt_BreakOnException
312 | Opt_PrintEvldWithShow
313 | Opt_PrintBindContents
316 | Opt_EmitExternalCore
318 | Opt_BuildingCabalPackage
324 | Opt_ConvertToZipCfgAndBack
325 | Opt_AutoLinkPackages
326 | Opt_ImplicitImportQualified
335 | Opt_KeepRawTokenStream
340 -- | Contains not only a collection of 'DynFlag's but also a plethora of
341 -- information relating to the compilation of a single file or GHC session
342 data DynFlags = DynFlags {
345 hscTarget :: HscTarget,
346 hscOutName :: String, -- ^ Name of the output file
347 extCoreName :: String, -- ^ Name of the .hcr output file
348 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
349 optLevel :: Int, -- ^ Optimisation level
350 simplPhases :: Int, -- ^ Number of simplifier phases
351 maxSimplIterations :: Int, -- ^ Max simplifier iterations
352 shouldDumpSimplPhase :: Maybe String,
353 ruleCheck :: Maybe String,
354 strictnessBefore :: [Int], -- ^ Additional demand analysis
356 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
357 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
358 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
360 #ifndef OMIT_NATIVE_CODEGEN
361 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
363 stolen_x86_regs :: Int,
364 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
365 importPaths :: [FilePath],
367 mainFunIs :: Maybe String,
368 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
370 dphBackend :: DPHBackend,
372 thisPackage :: PackageId, -- ^ name of package currently being compiled
375 ways :: [Way], -- ^ Way flags from the command line
376 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
377 rtsBuildTag :: String, -- ^ The RTS \"way\"
379 -- For object splitting
380 splitInfo :: Maybe (String,Int),
383 objectDir :: Maybe String,
384 dylibInstallName :: Maybe String,
385 hiDir :: Maybe String,
386 stubDir :: Maybe String,
392 outputFile :: Maybe String,
393 outputHi :: Maybe String,
394 dynLibLoader :: DynLibLoader,
396 -- | This is set by 'DriverPipeline.runPipeline' based on where
397 -- its output is going.
398 dumpPrefix :: Maybe FilePath,
400 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
401 -- Set by @-ddump-file-prefix@
402 dumpPrefixForce :: Maybe FilePath,
404 includePaths :: [String],
405 libraryPaths :: [String],
406 frameworkPaths :: [String], -- used on darwin only
407 cmdlineFrameworks :: [String], -- ditto
408 tmpDir :: String, -- no trailing '/'
410 ghcUsagePath :: FilePath, -- Filled in by SysTools
411 ghciUsagePath :: FilePath, -- ditto
412 rtsOpts :: Maybe String,
414 hpcDir :: String, -- ^ Path to store the .mix files
416 -- options for particular phases
424 opt_windres :: [String],
425 opt_la :: [String], -- LLVM: llvm-as assembler
426 opt_lo :: [String], -- LLVM: llvm optimiser
427 opt_lc :: [String], -- LLVM: llc static compiler
429 -- commands for particular phases
431 pgm_P :: (String,[Option]),
433 pgm_c :: (String,[Option]),
434 pgm_m :: (String,[Option]),
435 pgm_s :: (String,[Option]),
436 pgm_a :: (String,[Option]),
437 pgm_l :: (String,[Option]),
438 pgm_dll :: (String,[Option]),
440 pgm_sysman :: String,
441 pgm_windres :: String,
442 pgm_la :: (String,[Option]), -- LLVM: llvm-as assembler
443 pgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
444 pgm_lc :: (String,[Option]), -- LLVM: llc static compiler
447 depMakefile :: FilePath,
448 depIncludePkgDeps :: Bool,
449 depExcludeMods :: [ModuleName],
450 depSuffixes :: [String],
453 extraPkgConfs :: [FilePath],
454 topDir :: FilePath, -- filled in by SysTools
455 systemPackageConfig :: FilePath, -- ditto
456 -- ^ The @-package-conf@ flags given on the command line, in the order
459 packageFlags :: [PackageFlag],
460 -- ^ The @-package@ and @-hide-package@ flags from the command-line
463 -- NB. do not modify this field, it is calculated by
464 -- Packages.initPackages and Packages.updatePackages.
465 pkgDatabase :: Maybe [PackageConfig],
466 pkgState :: PackageState,
469 -- These have to be IORefs, because the defaultCleanupHandler needs to
470 -- know what to clean when an exception happens
471 filesToClean :: IORef [FilePath],
472 dirsToClean :: IORef (FiniteMap FilePath FilePath),
477 -- | Message output action: use "ErrUtils" instead of this if you can
478 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
480 haddockOptions :: Maybe String
483 wayNames :: DynFlags -> [WayName]
484 wayNames = map wayName . ways
486 -- | The target code type of the compilation (if any).
488 -- Whenever you change the target, also make sure to set 'ghcLink' to
489 -- something sensible.
491 -- 'HscNothing' can be used to avoid generating any output, however, note
494 -- * This will not run the desugaring step, thus no warnings generated in
495 -- this step will be output. In particular, this includes warnings related
496 -- to pattern matching. You can run the desugarer manually using
497 -- 'GHC.desugarModule'.
499 -- * If a program uses Template Haskell the typechecker may try to run code
500 -- from an imported module. This will fail if no code has been generated
501 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
502 -- whether this might be the case and choose to either switch to a
503 -- different target or avoid typechecking such modules. (The latter may
504 -- preferable for security reasons.)
507 = HscC -- ^ Generate C code.
508 | HscAsm -- ^ Generate assembly using the native code generator.
509 | HscLlvm -- ^ Generate assembly using the llvm code generator.
510 | HscJava -- ^ Generate Java bytecode.
511 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
512 | HscNothing -- ^ Don't generate any code. See notes above.
515 -- | Will this target result in an object file on the disk?
516 isObjectTarget :: HscTarget -> Bool
517 isObjectTarget HscC = True
518 isObjectTarget HscAsm = True
519 isObjectTarget HscLlvm = True
520 isObjectTarget _ = False
522 -- | The 'GhcMode' tells us whether we're doing multi-module
523 -- compilation (controlled via the "GHC" API) or one-shot
524 -- (single-module) compilation. This makes a difference primarily to
525 -- the "Finder": in one-shot mode we look for interface files for
526 -- imported modules, but in multi-module mode we look for source files
527 -- in order to check whether they need to be recompiled.
529 = CompManager -- ^ @\-\-make@, GHCi, etc.
530 | OneShot -- ^ @ghc -c Foo.hs@
531 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
534 instance Outputable GhcMode where
535 ppr CompManager = ptext (sLit "CompManager")
536 ppr OneShot = ptext (sLit "OneShot")
537 ppr MkDepend = ptext (sLit "MkDepend")
539 isOneShot :: GhcMode -> Bool
540 isOneShot OneShot = True
541 isOneShot _other = False
543 -- | What to do in the link step, if there is one.
545 = NoLink -- ^ Don't link at all
546 | LinkBinary -- ^ Link object code into a binary
547 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
548 -- bytecode and object code).
549 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
552 isNoLink :: GhcLink -> Bool
553 isNoLink NoLink = True
556 -- Is it worth evaluating this Bool and caching it in the DynFlags value
557 -- during initDynFlags?
558 doingTickyProfiling :: DynFlags -> Bool
559 doingTickyProfiling _ = opt_Ticky
560 -- XXX -ticky is a static flag, because it implies -debug which is also
561 -- static. If the way flags were made dynamic, we could fix this.
564 = ExposePackage String
565 | ExposePackageId String
567 | IgnorePackage String
570 defaultHscTarget :: HscTarget
571 defaultHscTarget = defaultObjectTarget
573 -- | The 'HscTarget' value corresponding to the default way to create
574 -- object files on the current platform.
575 defaultObjectTarget :: HscTarget
577 | cGhcWithNativeCodeGen == "YES" = HscAsm
582 | Wrapped (Maybe String)
586 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
587 initDynFlags :: DynFlags -> IO DynFlags
588 initDynFlags dflags = do
589 -- someday these will be dynamic flags
590 ways <- readIORef v_Ways
591 refFilesToClean <- newIORef []
592 refDirsToClean <- newIORef emptyFM
595 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
596 rtsBuildTag = mkBuildTag ways,
597 filesToClean = refFilesToClean,
598 dirsToClean = refDirsToClean
601 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
602 -- and must be fully initialized by 'GHC.newSession' first.
603 defaultDynFlags :: DynFlags
606 ghcMode = CompManager,
607 ghcLink = LinkBinary,
608 hscTarget = defaultHscTarget,
614 maxSimplIterations = 4,
615 shouldDumpSimplPhase = Nothing,
617 specConstrThreshold = Just 200,
618 specConstrCount = Just 3,
619 liberateCaseThreshold = Just 200,
620 strictnessBefore = [],
622 #ifndef OMIT_NATIVE_CODEGEN
623 targetPlatform = defaultTargetPlatform,
626 cmdlineHcIncludes = [],
630 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
634 thisPackage = mainPackageId,
637 dylibInstallName = Nothing,
641 objectSuf = phaseInputExt StopLn,
642 hcSuf = phaseInputExt HCc,
645 outputFile = Nothing,
647 dynLibLoader = SystemDependent,
648 dumpPrefix = Nothing,
649 dumpPrefixForce = Nothing,
653 cmdlineFrameworks = [],
654 tmpDir = cDEFAULT_TMPDIR,
661 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
675 pkgDatabase = Nothing,
676 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
677 ways = panic "defaultDynFlags: No ways",
678 buildTag = panic "defaultDynFlags: No buildTag",
679 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
681 -- initSysTools fills all these in
682 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
683 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
684 topDir = panic "defaultDynFlags: No topDir",
685 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
686 pgm_L = panic "defaultDynFlags: No pgm_L",
687 pgm_P = panic "defaultDynFlags: No pgm_P",
688 pgm_F = panic "defaultDynFlags: No pgm_F",
689 pgm_c = panic "defaultDynFlags: No pgm_c",
690 pgm_m = panic "defaultDynFlags: No pgm_m",
691 pgm_s = panic "defaultDynFlags: No pgm_s",
692 pgm_a = panic "defaultDynFlags: No pgm_a",
693 pgm_l = panic "defaultDynFlags: No pgm_l",
694 pgm_dll = panic "defaultDynFlags: No pgm_dll",
695 pgm_T = panic "defaultDynFlags: No pgm_T",
696 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
697 pgm_windres = panic "defaultDynFlags: No pgm_windres",
698 pgm_la = panic "defaultDynFlags: No pgm_la",
699 pgm_lo = panic "defaultDynFlags: No pgm_lo",
700 pgm_lc = panic "defaultDynFlags: No pgm_lc",
701 -- end of initSysTools values
703 depMakefile = "Makefile",
704 depIncludePkgDeps = False,
707 -- end of ghc -M values
708 filesToClean = panic "defaultDynFlags: No filesToClean",
709 dirsToClean = panic "defaultDynFlags: No dirsToClean",
710 haddockOptions = Nothing,
712 Opt_AutoLinkPackages,
713 Opt_ReadUserPackageConf,
715 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
716 -- behaviour the default, to see if anyone notices
720 Opt_MonomorphismRestriction,
731 Opt_PrintBindContents
733 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
734 -- The default -O0 options
737 log_action = \severity srcSpan style msg ->
739 SevInfo -> printErrs (msg style)
740 SevFatal -> printErrs (msg style)
743 printErrs ((mkLocMessage srcSpan msg) style)
744 -- careful (#2302): printErrs prints in UTF-8, whereas
745 -- converting to string first and using hPutStr would
746 -- just emit the low 8 bits of each unicode char.
750 Note [Verbosity levels]
751 ~~~~~~~~~~~~~~~~~~~~~~~
752 0 | print errors & warnings only
753 1 | minimal verbosity: print "compiling M ... done." for each module.
754 2 | equivalent to -dshow-passes
755 3 | equivalent to existing "ghc -v"
756 4 | "ghc -v -ddump-most"
757 5 | "ghc -v -ddump-all"
760 -- | Test whether a 'DynFlag' is set
761 dopt :: DynFlag -> DynFlags -> Bool
762 dopt f dflags = f `elem` (flags dflags)
765 dopt_set :: DynFlags -> DynFlag -> DynFlags
766 dopt_set dfs f = dfs{ flags = f : flags dfs }
768 -- | Unset a 'DynFlag'
769 dopt_unset :: DynFlags -> DynFlag -> DynFlags
770 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
772 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
773 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
774 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
775 -> [a] -- ^ Correctly ordered extracted options
776 getOpts dflags opts = reverse (opts dflags)
777 -- We add to the options from the front, so we need to reverse the list
779 -- | Gets the verbosity flag for the current verbosity level. This is fed to
780 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
781 getVerbFlag :: DynFlags -> String
783 | verbosity dflags >= 3 = "-v"
786 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
787 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
788 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
789 setPgmla, setPgmlo, setPgmlc,
790 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres, addOptla, addOptlo,
791 addOptlc, addCmdlineFramework, addHaddockOpts
792 :: String -> DynFlags -> DynFlags
793 setOutputFile, setOutputHi, setDumpPrefixForce
794 :: Maybe String -> DynFlags -> DynFlags
796 setObjectDir f d = d{ objectDir = Just f}
797 setHiDir f d = d{ hiDir = Just f}
798 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
799 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
800 -- \#included from the .hc file when compiling with -fvia-C.
801 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
802 setDylibInstallName f d = d{ dylibInstallName = Just f}
804 setObjectSuf f d = d{ objectSuf = f}
805 setHiSuf f d = d{ hiSuf = f}
806 setHcSuf f d = d{ hcSuf = f}
808 setOutputFile f d = d{ outputFile = f}
809 setOutputHi f d = d{ outputHi = f}
811 parseDynLibLoaderMode f d =
813 ("deploy", "") -> d{ dynLibLoader = Deployable }
814 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
815 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
816 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
817 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
818 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
820 setDumpPrefixForce f d = d { dumpPrefixForce = f}
822 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
823 -- Config.hs should really use Option.
824 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
826 setPgmL f d = d{ pgm_L = f}
827 setPgmF f d = d{ pgm_F = f}
828 setPgmc f d = d{ pgm_c = (f,[])}
829 setPgmm f d = d{ pgm_m = (f,[])}
830 setPgms f d = d{ pgm_s = (f,[])}
831 setPgma f d = d{ pgm_a = (f,[])}
832 setPgml f d = d{ pgm_l = (f,[])}
833 setPgmdll f d = d{ pgm_dll = (f,[])}
834 setPgmwindres f d = d{ pgm_windres = f}
835 setPgmla f d = d{ pgm_la = (f,[])}
836 setPgmlo f d = d{ pgm_lo = (f,[])}
837 setPgmlc f d = d{ pgm_lc = (f,[])}
839 addOptL f d = d{ opt_L = f : opt_L d}
840 addOptP f d = d{ opt_P = f : opt_P d}
841 addOptF f d = d{ opt_F = f : opt_F d}
842 addOptc f d = d{ opt_c = f : opt_c d}
843 addOptm f d = d{ opt_m = f : opt_m d}
844 addOpta f d = d{ opt_a = f : opt_a d}
845 addOptl f d = d{ opt_l = f : opt_l d}
846 addOptwindres f d = d{ opt_windres = f : opt_windres d}
847 addOptla f d = d{ opt_la = f : opt_la d}
848 addOptlo f d = d{ opt_lo = f : opt_lo d}
849 addOptlc f d = d{ opt_lc = f : opt_lc d}
851 setDepMakefile :: FilePath -> DynFlags -> DynFlags
852 setDepMakefile f d = d { depMakefile = deOptDep f }
854 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
855 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
857 addDepExcludeMod :: String -> DynFlags -> DynFlags
859 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
861 addDepSuffix :: FilePath -> DynFlags -> DynFlags
862 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
865 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
866 -- we need to strip the "-optdep" off of the arg
867 deOptDep :: String -> String
868 deOptDep x = case stripPrefix "-optdep" x of
872 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
874 addHaddockOpts f d = d{ haddockOptions = Just f}
876 -- -----------------------------------------------------------------------------
877 -- Command-line options
879 -- | When invoking external tools as part of the compilation pipeline, we
880 -- pass these a sequence of options on the command-line. Rather than
881 -- just using a list of Strings, we use a type that allows us to distinguish
882 -- between filepaths and 'other stuff'. The reason for this is that
883 -- this type gives us a handle on transforming filenames, and filenames only,
884 -- to whatever format they're expected to be on a particular platform.
886 = FileOption -- an entry that _contains_ filename(s) / filepaths.
887 String -- a non-filepath prefix that shouldn't be
888 -- transformed (e.g., "/out=")
889 String -- the filepath/filename portion
892 showOpt :: Option -> String
893 showOpt (FileOption pre f) = pre ++ f
894 showOpt (Option s) = s
896 -----------------------------------------------------------------------------
897 -- Setting the optimisation level
899 updOptLevel :: Int -> DynFlags -> DynFlags
900 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
902 = dfs2{ optLevel = final_n }
904 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
905 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
906 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
908 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
909 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
911 optLevelFlags :: [([Int], DynFlag)]
913 = [ ([0], Opt_IgnoreInterfacePragmas)
914 , ([0], Opt_OmitInterfacePragmas)
916 , ([1,2], Opt_IgnoreAsserts)
917 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
919 , ([1,2], Opt_DoEtaReduction)
920 , ([1,2], Opt_CaseMerge)
921 , ([1,2], Opt_Strictness)
923 , ([1,2], Opt_FullLaziness)
924 , ([1,2], Opt_Specialise)
925 , ([1,2], Opt_FloatIn)
927 , ([2], Opt_LiberateCase)
928 , ([2], Opt_SpecConstr)
930 -- , ([2], Opt_StaticArgumentTransformation)
931 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
932 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
933 -- several improvements to the heuristics, and I'm concerned that without
934 -- those changes SAT will interfere with some attempts to write "high
935 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
936 -- this year. In particular, the version in HEAD lacks the tail call
937 -- criterion, so many things that look like reasonable loops will be
938 -- turned into functions with extra (unneccesary) thunk creation.
940 , ([0,1,2], Opt_DoLambdaEtaExpansion)
941 -- This one is important for a tiresome reason:
942 -- we want to make sure that the bindings for data
943 -- constructors are eta-expanded. This is probably
944 -- a good thing anyway, but it seems fragile.
947 -- -----------------------------------------------------------------------------
948 -- Standard sets of warning options
950 standardWarnings :: [DynFlag]
952 = [ Opt_WarnWarningsDeprecations,
953 Opt_WarnDeprecatedFlags,
954 Opt_WarnUnrecognisedPragmas,
955 Opt_WarnOverlappingPatterns,
956 Opt_WarnMissingFields,
957 Opt_WarnMissingMethods,
958 Opt_WarnDuplicateExports,
959 Opt_WarnLazyUnliftedBindings,
960 Opt_WarnDodgyForeignImports,
962 Opt_WarnAlternativeLayoutRuleTransitional
965 minusWOpts :: [DynFlag]
967 = standardWarnings ++
968 [ Opt_WarnUnusedBinds,
969 Opt_WarnUnusedMatches,
970 Opt_WarnUnusedImports,
971 Opt_WarnIncompletePatterns,
972 Opt_WarnDodgyExports,
976 minusWallOpts :: [DynFlag]
979 [ Opt_WarnTypeDefaults,
980 Opt_WarnNameShadowing,
987 -- minuswRemovesOpts should be every warning option
988 minuswRemovesOpts :: [DynFlag]
991 [Opt_WarnImplicitPrelude,
992 Opt_WarnIncompletePatternsRecUpd,
993 Opt_WarnSimplePatterns,
994 Opt_WarnMonomorphism,
995 Opt_WarnUnrecognisedPragmas,
999 -- -----------------------------------------------------------------------------
1000 -- StgToDo: abstraction of stg-to-stg passes to run.
1003 = StgDoMassageForProfiling -- should be (next to) last
1004 -- There's also setStgVarInfo, but its absolute "lastness"
1005 -- is so critical that it is hardwired in (no flag).
1008 getStgToDo :: DynFlags -> [StgToDo]
1012 stg_stats = dopt Opt_StgStats dflags
1014 todo1 = if stg_stats then [D_stg_stats] else []
1016 todo2 | WayProf `elem` wayNames dflags
1017 = StgDoMassageForProfiling : todo1
1021 -- -----------------------------------------------------------------------------
1024 allFlags :: [String]
1025 allFlags = map ('-':) $
1026 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1027 map ("fno-"++) flags ++
1028 map ("f"++) flags ++
1029 map ("X"++) supportedLanguages
1030 where ok (PrefixPred _ _) = False
1032 flags = [ name | (name, _, _) <- fFlags ]
1034 dynamic_flags :: [Flag DynP]
1036 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1037 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1038 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1039 , Flag "#include" (HasArg (addCmdlineHCInclude))
1040 (DeprecatedFullText "-#include and INCLUDE pragmas are deprecated: They no longer have any effect")
1041 , Flag "v" (OptIntSuffix setVerbosity) Supported
1043 ------- Specific phases --------------------------------------------
1044 -- need to appear before -pgmL to be parsed as LLVM flags.
1045 , Flag "pgmla" (HasArg (upd . setPgmla)) Supported
1046 , Flag "pgmlo" (HasArg (upd . setPgmlo)) Supported
1047 , Flag "pgmlc" (HasArg (upd . setPgmlc)) Supported
1049 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1050 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1051 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1052 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1053 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1054 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1055 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1056 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1057 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1058 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1060 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1061 , Flag "optla" (HasArg (upd . addOptla)) Supported
1062 , Flag "optlo" (HasArg (upd . addOptlo)) Supported
1063 , Flag "optlc" (HasArg (upd . addOptlc)) Supported
1065 , Flag "optL" (HasArg (upd . addOptL)) Supported
1066 , Flag "optP" (HasArg (upd . addOptP)) Supported
1067 , Flag "optF" (HasArg (upd . addOptF)) Supported
1068 , Flag "optc" (HasArg (upd . addOptc)) Supported
1069 , Flag "optm" (HasArg (upd . addOptm)) Supported
1070 , Flag "opta" (HasArg (upd . addOpta)) Supported
1071 , Flag "optl" (HasArg (upd . addOptl)) Supported
1072 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1075 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1078 -------- ghc -M -----------------------------------------------------
1079 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1080 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1081 (Deprecated "Use -dep-suffix instead")
1082 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1083 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1084 (Deprecated "Use -dep-makefile instead")
1085 , Flag "optdep-w" (NoArg (return ()))
1086 (Deprecated "-optdep-w doesn't do anything")
1087 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1088 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1089 (Deprecated "Use -include-pkg-deps instead")
1090 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1091 (Deprecated "Use -include-pkg-deps instead")
1092 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1093 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1094 (Deprecated "Use -exclude-module instead")
1095 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1096 (Deprecated "Use -exclude-module instead")
1098 -------- Linking ----------------------------------------------------
1099 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1101 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1103 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1105 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1107 ------- Libraries ---------------------------------------------------
1108 , Flag "L" (Prefix addLibraryPath ) Supported
1109 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1111 ------- Frameworks --------------------------------------------------
1112 -- -framework-path should really be -F ...
1113 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1114 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1116 ------- Output Redirection ------------------------------------------
1117 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1118 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1119 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1120 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1121 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1122 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1123 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1124 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1125 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1126 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1127 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1130 ------- Keeping temporary files -------------------------------------
1131 -- These can be singular (think ghc -c) or plural (think ghc --make)
1132 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1133 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1134 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1135 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1136 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1137 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1138 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1139 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1140 -- This only makes sense as plural
1141 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1143 ------- Miscellaneous ----------------------------------------------
1144 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1145 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1146 , Flag "with-rtsopts" (HasArg setRtsOpts) Supported
1147 , Flag "rtsopts" (NoArg (setDynFlag Opt_RtsOptsEnabled)) Supported
1148 , Flag "no-rtsopts" (NoArg (unSetDynFlag Opt_RtsOptsEnabled)) Supported
1149 , Flag "main-is" (SepArg setMainIs ) Supported
1150 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1151 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1152 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1154 ------- recompilation checker --------------------------------------
1155 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1156 (Deprecated "Use -fno-force-recomp instead")
1157 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1158 (Deprecated "Use -fforce-recomp instead")
1160 ------ HsCpp opts ---------------------------------------------------
1161 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1162 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1164 ------- Include/Import Paths ----------------------------------------
1165 , Flag "I" (Prefix addIncludePath) Supported
1166 , Flag "i" (OptPrefix addImportPath ) Supported
1168 ------ Debugging ----------------------------------------------------
1169 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1171 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1173 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1175 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1177 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1179 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1181 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1183 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1185 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1187 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1189 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1191 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1193 , Flag "ddump-asm-regalloc-stages"
1194 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1196 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1198 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1200 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1201 ; setDumpFlag' Opt_D_dump_llvm}))
1203 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1205 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1207 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1209 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1211 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1213 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1215 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1217 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1219 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1221 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1223 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1225 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1227 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1229 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1231 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1233 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1235 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1237 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1239 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1241 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1243 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1245 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1247 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1249 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1251 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1253 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1255 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1257 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1259 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1261 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1263 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1265 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1266 ; setVerboseCore2Core }))
1268 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1270 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1272 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1274 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1276 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1278 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1280 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1282 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1284 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1286 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1289 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1291 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1293 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1295 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1297 , Flag "dshow-passes"
1298 (NoArg (do forceRecompile
1299 setVerbosity (Just 2)))
1301 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1304 ------ Machine dependant (-m<blah>) stuff ---------------------------
1306 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1308 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1310 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1313 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1316 ------ Warning opts -------------------------------------------------
1317 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1319 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1321 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1323 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1325 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1326 (Deprecated "Use -w instead")
1327 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1330 ------ Optimisation flags ------------------------------------------
1331 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1332 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1333 (Deprecated "Use -O0 instead")
1334 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1335 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1337 -- If the number is missing, use 1
1339 , Flag "fsimplifier-phases"
1340 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1342 , Flag "fmax-simplifier-iterations"
1343 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1346 , Flag "fspec-constr-threshold"
1347 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1349 , Flag "fno-spec-constr-threshold"
1350 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1352 , Flag "fspec-constr-count"
1353 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1355 , Flag "fno-spec-constr-count"
1356 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1358 , Flag "fliberate-case-threshold"
1359 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1361 , Flag "fno-liberate-case-threshold"
1362 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1365 , Flag "frule-check"
1366 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1368 , Flag "fcontext-stack"
1369 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1372 , Flag "fstrictness-before"
1373 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1376 ------ Profiling ----------------------------------------------------
1378 -- XXX Should the -f* flags be deprecated?
1379 -- They don't seem to be documented
1380 , Flag "fauto-sccs-on-all-toplevs"
1381 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1384 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1386 , Flag "no-auto-all"
1387 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1389 , Flag "fauto-sccs-on-exported-toplevs"
1390 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1393 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1396 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1398 , Flag "fauto-sccs-on-individual-cafs"
1399 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1402 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1405 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1408 ------ DPH flags ----------------------------------------------------
1411 (NoArg (setDPHBackend DPHSeq))
1414 (NoArg (setDPHBackend DPHPar))
1417 (NoArg (setDPHBackend DPHThis))
1420 ------ Compiler flags -----------------------------------------------
1422 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1423 , Flag "fvia-c" (NoArg (setObjTarget HscC))
1424 (Deprecated "The -fvia-c flag will be removed in a future GHC release")
1425 , Flag "fvia-C" (NoArg (setObjTarget HscC))
1426 (Deprecated "The -fvia-C flag will be removed in a future GHC release")
1427 , Flag "fllvm" (NoArg (setObjTarget HscLlvm)) Supported
1429 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1430 setTarget HscNothing))
1432 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1433 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1435 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1437 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1440 ++ map (mkFlag True "f" setDynFlag ) fFlags
1441 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1442 ++ map (mkFlag True "X" setDynFlag ) xFlags
1443 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1445 package_flags :: [Flag DynP]
1447 ------- Packages ----------------------------------------------------
1448 Flag "package-conf" (HasArg extraPkgConf_) Supported
1449 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1451 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1452 , Flag "package-id" (HasArg exposePackageId) Supported
1453 , Flag "package" (HasArg exposePackage) Supported
1454 , Flag "hide-package" (HasArg hidePackage) Supported
1455 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1457 , Flag "ignore-package" (HasArg ignorePackage)
1459 , Flag "syslib" (HasArg exposePackage)
1460 (Deprecated "Use -package instead")
1463 mkFlag :: Bool -- ^ True <=> it should be turned on
1464 -> String -- ^ The flag prefix
1465 -> (DynFlag -> DynP ())
1466 -> (String, DynFlag, Bool -> Deprecated)
1468 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1469 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1471 deprecatedForLanguage :: String -> Bool -> Deprecated
1472 deprecatedForLanguage lang turn_on
1473 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1475 flag | turn_on = lang
1476 | otherwise = "No"++lang
1478 useInstead :: String -> Bool -> Deprecated
1479 useInstead flag turn_on
1480 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1482 no = if turn_on then "" else "no-"
1484 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1485 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1487 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1488 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1489 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1490 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1491 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1492 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1493 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1494 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1495 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1496 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1497 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1498 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1499 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1500 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1501 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1502 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1503 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1504 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1505 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1506 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1507 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1508 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1509 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1510 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1511 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1512 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1513 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1514 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1515 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1516 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, const Supported ),
1517 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1518 ( "strictness", Opt_Strictness, const Supported ),
1519 ( "specialise", Opt_Specialise, const Supported ),
1520 ( "float-in", Opt_FloatIn, const Supported ),
1521 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1522 ( "full-laziness", Opt_FullLaziness, const Supported ),
1523 ( "liberate-case", Opt_LiberateCase, const Supported ),
1524 ( "spec-constr", Opt_SpecConstr, const Supported ),
1525 ( "cse", Opt_CSE, const Supported ),
1526 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1527 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1528 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1529 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1530 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1531 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1532 ( "case-merge", Opt_CaseMerge, const Supported ),
1533 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1534 ( "method-sharing", Opt_MethodSharing, const Supported ),
1535 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1536 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1537 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1538 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1539 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1540 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1541 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1542 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1543 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1544 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1545 ( "break-on-error", Opt_BreakOnError, const Supported ),
1546 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1547 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1548 ( "run-cps", Opt_RunCPS, const Supported ),
1549 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1550 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1551 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1552 ( "vectorise", Opt_Vectorise, const Supported ),
1553 ( "regs-graph", Opt_RegsGraph, const Supported ),
1554 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1555 ( "th", Opt_TemplateHaskell,
1556 deprecatedForLanguage "TemplateHaskell" ),
1557 ( "fi", Opt_ForeignFunctionInterface,
1558 deprecatedForLanguage "ForeignFunctionInterface" ),
1559 ( "ffi", Opt_ForeignFunctionInterface,
1560 deprecatedForLanguage "ForeignFunctionInterface" ),
1561 ( "arrows", Opt_Arrows,
1562 deprecatedForLanguage "Arrows" ),
1563 ( "generics", Opt_Generics,
1564 deprecatedForLanguage "Generics" ),
1565 ( "implicit-prelude", Opt_ImplicitPrelude,
1566 deprecatedForLanguage "ImplicitPrelude" ),
1567 ( "bang-patterns", Opt_BangPatterns,
1568 deprecatedForLanguage "BangPatterns" ),
1569 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1570 deprecatedForLanguage "MonomorphismRestriction" ),
1571 ( "mono-pat-binds", Opt_MonoPatBinds,
1572 deprecatedForLanguage "MonoPatBinds" ),
1573 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1574 deprecatedForLanguage "ExtendedDefaultRules" ),
1575 ( "implicit-params", Opt_ImplicitParams,
1576 deprecatedForLanguage "ImplicitParams" ),
1577 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1578 deprecatedForLanguage "ScopedTypeVariables" ),
1580 deprecatedForLanguage "PArr" ),
1581 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1582 deprecatedForLanguage "OverlappingInstances" ),
1583 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1584 deprecatedForLanguage "UndecidableInstances" ),
1585 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1586 deprecatedForLanguage "IncoherentInstances" ),
1587 ( "gen-manifest", Opt_GenManifest, const Supported ),
1588 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1589 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1590 ( "shared-implib", Opt_SharedImplib, const Supported ),
1591 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1592 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1595 supportedLanguages :: [String]
1596 supportedLanguages = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1598 -- This may contain duplicates
1599 languageOptions :: [DynFlag]
1600 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1602 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1603 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1605 ( "CPP", Opt_Cpp, const Supported ),
1606 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1607 ( "TupleSections", Opt_TupleSections, const Supported ),
1608 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1609 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1610 ( "MagicHash", Opt_MagicHash, const Supported ),
1611 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1612 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1613 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1614 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1615 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1616 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1617 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1618 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1619 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1620 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1621 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1622 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1623 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1624 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1625 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1626 ( "RecursiveDo", Opt_RecursiveDo,
1627 deprecatedForLanguage "DoRec"),
1628 ( "DoRec", Opt_DoRec, const Supported ),
1629 ( "Arrows", Opt_Arrows, const Supported ),
1630 ( "PArr", Opt_PArr, const Supported ),
1631 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1632 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1633 ( "Generics", Opt_Generics, const Supported ),
1635 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1636 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1637 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1638 ( "RecordPuns", Opt_RecordPuns,
1639 deprecatedForLanguage "NamedFieldPuns" ),
1640 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1641 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1642 ( "GADTs", Opt_GADTs, const Supported ),
1643 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1644 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1645 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1647 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1649 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1650 -- On by default (which is not strictly H98):
1651 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1652 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1653 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1654 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, const Supported ),
1655 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1656 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1657 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1658 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1659 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1661 ( "PatternSignatures", Opt_ScopedTypeVariables,
1662 deprecatedForLanguage "ScopedTypeVariables" ),
1664 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1665 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1666 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1667 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1668 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1669 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1670 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1671 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1672 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1673 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1674 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1675 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1676 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1677 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1678 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1679 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1680 ( "PackageImports", Opt_PackageImports, const Supported ),
1681 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1684 impliedFlags :: [(DynFlag, DynFlag)]
1686 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1687 , (Opt_Rank2Types, Opt_ExplicitForAll)
1688 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1689 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1690 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1691 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1693 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1694 -- be completely rigid for GADTs
1696 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1697 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1698 -- all over the place
1700 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1701 -- Note [Scoped tyvars] in TcBinds
1702 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1704 -- Record wild-cards implies field disambiguation
1705 -- Otherwise if you write (C {..}) you may well get
1706 -- stuff like " 'a' not in scope ", which is a bit silly
1707 -- if the compiler has just filled in field 'a' of constructor 'C'
1708 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1711 glasgowExtsFlags :: [DynFlag]
1712 glasgowExtsFlags = [
1713 Opt_PrintExplicitForalls
1714 , Opt_ForeignFunctionInterface
1715 , Opt_UnliftedFFITypes
1717 , Opt_ImplicitParams
1718 , Opt_ScopedTypeVariables
1720 , Opt_TypeSynonymInstances
1721 , Opt_StandaloneDeriving
1722 , Opt_DeriveDataTypeable
1724 , Opt_DeriveFoldable
1725 , Opt_DeriveTraversable
1726 , Opt_FlexibleContexts
1727 , Opt_FlexibleInstances
1728 , Opt_ConstrainedClassMethods
1729 , Opt_MultiParamTypeClasses
1730 , Opt_FunctionalDependencies
1732 , Opt_PolymorphicComponents
1733 , Opt_ExistentialQuantification
1735 , Opt_PostfixOperators
1737 , Opt_LiberalTypeSynonyms
1741 , Opt_ParallelListComp
1742 , Opt_EmptyDataDecls
1743 , Opt_KindSignatures
1744 , Opt_GeneralizedNewtypeDeriving
1745 , Opt_TypeFamilies ]
1747 -- -----------------------------------------------------------------------------
1748 -- Parsing the dynamic flags.
1750 -- | Parse dynamic flags from a list of command line arguments. Returns the
1751 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1752 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1753 -- flags or missing arguments).
1754 parseDynamicFlags :: Monad m =>
1755 DynFlags -> [Located String]
1756 -> m (DynFlags, [Located String], [Located String])
1757 -- ^ Updated 'DynFlags', left-over arguments, and
1758 -- list of warnings.
1759 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1761 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1762 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1763 parseDynamicNoPackageFlags :: Monad m =>
1764 DynFlags -> [Located String]
1765 -> m (DynFlags, [Located String], [Located String])
1766 -- ^ Updated 'DynFlags', left-over arguments, and
1767 -- list of warnings.
1768 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1770 parseDynamicFlags_ :: Monad m =>
1771 DynFlags -> [Located String] -> Bool
1772 -> m (DynFlags, [Located String], [Located String])
1773 parseDynamicFlags_ dflags0 args pkg_flags = do
1774 -- XXX Legacy support code
1775 -- We used to accept things like
1776 -- optdep-f -optdepdepend
1777 -- optdep-f -optdep depend
1778 -- optdep -f -optdepdepend
1779 -- optdep -f -optdep depend
1780 -- but the spaces trip up proper argument handling. So get rid of them.
1781 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1782 f (x : xs) = x : f xs
1786 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1787 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1788 | otherwise = dynamic_flags
1790 let ((leftover, errs, warns), dflags1)
1791 = runCmdLine (processArgs flag_spec args') dflags0
1792 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1794 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1795 -- isn't up to the job. We know that if hscTarget == HscC, then the
1796 -- user has explicitly used -fvia-C, because -fasm is the default,
1797 -- unless there is no NCG on this platform. The latter case is
1798 -- checked when the -fPIC flag is parsed.
1800 let (pic_warns, dflags2) =
1801 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1802 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1803 dflags1{ hscTarget = HscAsm })
1806 return (dflags2, leftover, pic_warns ++ warns)
1808 type DynP = CmdLineP DynFlags
1810 upd :: (DynFlags -> DynFlags) -> DynP ()
1812 dfs <- getCmdLineState
1813 putCmdLineState $! (f dfs)
1815 --------------------------
1816 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1817 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1818 ; mapM_ setDynFlag deps }
1820 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1821 -- When you set f, set the ones it implies
1822 -- NB: use setDynFlag recursively, in case the implied flags
1823 -- implies further flags
1824 -- When you un-set f, however, we don't un-set the things it implies
1825 -- (except for -fno-glasgow-exts, which is treated specially)
1827 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1829 --------------------------
1830 setDumpFlag :: DynFlag -> OptKind DynP
1831 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1833 setDumpFlag' :: DynFlag -> DynP ()
1834 setDumpFlag' dump_flag
1835 = do { setDynFlag dump_flag
1836 ; when want_recomp forceRecompile }
1838 -- Certain dumpy-things are really interested in what's going
1839 -- on during recompilation checking, so in those cases we
1840 -- don't want to turn it off.
1841 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1842 Opt_D_dump_hi_diffs]
1844 forceRecompile :: DynP ()
1845 -- Whenver we -ddump, force recompilation (by switching off the
1846 -- recompilation checker), else you don't see the dump! However,
1847 -- don't switch it off in --make mode, else *everything* gets
1848 -- recompiled which probably isn't what you want
1849 forceRecompile = do { dfs <- getCmdLineState
1850 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1852 force_recomp dfs = isOneShot (ghcMode dfs)
1854 setVerboseCore2Core :: DynP ()
1855 setVerboseCore2Core = do forceRecompile
1856 setDynFlag Opt_D_verbose_core2core
1857 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
1860 setDumpSimplPhases :: String -> DynP ()
1861 setDumpSimplPhases s = do forceRecompile
1862 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
1864 spec = case s of { ('=' : s') -> s'; _ -> s }
1866 setVerbosity :: Maybe Int -> DynP ()
1867 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1869 addCmdlineHCInclude :: String -> DynP ()
1870 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
1872 extraPkgConf_ :: FilePath -> DynP ()
1873 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1875 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
1877 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
1879 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
1881 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
1883 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
1885 setPackageName :: String -> DynFlags -> DynFlags
1886 setPackageName p s = s{ thisPackage = stringToPackageId p }
1888 -- If we're linking a binary, then only targets that produce object
1889 -- code are allowed (requests for other target types are ignored).
1890 setTarget :: HscTarget -> DynP ()
1891 setTarget l = upd set
1894 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
1897 -- Changes the target only if we're compiling object code. This is
1898 -- used by -fasm and -fvia-C, which switch from one to the other, but
1899 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
1900 -- can be safely used in an OPTIONS_GHC pragma.
1901 setObjTarget :: HscTarget -> DynP ()
1902 setObjTarget l = upd set
1905 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1908 setOptLevel :: Int -> DynFlags -> DynFlags
1909 setOptLevel n dflags
1910 | hscTarget dflags == HscInterpreted && n > 0
1912 -- not in IO any more, oh well:
1913 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1915 = updOptLevel n dflags
1918 -- -Odph is equivalent to
1920 -- -O2 optimise as much as possible
1921 -- -fno-method-sharing sharing specialisation defeats fusion
1923 -- -fdicts-cheap always inline dictionaries
1924 -- -fmax-simplifier-iterations20 this is necessary sometimes
1925 -- -fsimplifier-phases=3 we use an additional simplifier phase
1927 -- -fno-spec-constr-threshold run SpecConstr even for big loops
1928 -- -fno-spec-constr-count SpecConstr as much as possible
1929 -- -finline-enough-args hack to prevent excessive inlining
1931 setDPHOpt :: DynFlags -> DynFlags
1932 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
1934 , specConstrThreshold = Nothing
1935 , specConstrCount = Nothing
1937 `dopt_set` Opt_DictsCheap
1938 `dopt_unset` Opt_MethodSharing
1940 data DPHBackend = DPHPar
1943 deriving(Eq, Ord, Enum, Show)
1945 setDPHBackend :: DPHBackend -> DynP ()
1946 setDPHBackend backend
1948 upd $ \dflags -> dflags { dphBackend = backend }
1949 mapM_ exposePackage (dph_packages backend)
1951 dph_packages DPHThis = []
1952 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
1953 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
1955 dphPackage :: DynFlags -> PackageId
1956 dphPackage dflags = case dphBackend dflags of
1957 DPHPar -> dphParPackageId
1958 DPHSeq -> dphSeqPackageId
1959 DPHThis -> thisPackage dflags
1961 setMainIs :: String -> DynP ()
1963 | not (null main_fn) && isLower (head main_fn)
1964 -- The arg looked like "Foo.Bar.baz"
1965 = upd $ \d -> d{ mainFunIs = Just main_fn,
1966 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1968 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
1969 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1971 | otherwise -- The arg looked like "baz"
1972 = upd $ \d -> d{ mainFunIs = Just arg }
1974 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1976 -----------------------------------------------------------------------------
1977 -- Paths & Libraries
1979 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1981 -- -i on its own deletes the import paths
1982 addImportPath "" = upd (\s -> s{importPaths = []})
1983 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1987 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1990 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1992 addFrameworkPath p =
1993 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1995 #ifndef mingw32_TARGET_OS
1996 split_marker :: Char
1997 split_marker = ':' -- not configurable (ToDo)
2000 splitPathList :: String -> [String]
2001 splitPathList s = filter notNull (splitUp s)
2002 -- empty paths are ignored: there might be a trailing
2003 -- ':' in the initial list, for example. Empty paths can
2004 -- cause confusion when they are translated into -I options
2005 -- for passing to gcc.
2007 #ifndef mingw32_TARGET_OS
2008 splitUp xs = split split_marker xs
2010 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2012 -- That is, if "foo:bar:baz" is used, this interpreted as
2013 -- consisting of three entries, 'foo', 'bar', 'baz'.
2014 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2015 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2017 -- Notice that no attempt is made to fully replace the 'standard'
2018 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2019 -- that this will cause too much breakage for users & ':' will
2020 -- work fine even with DOS paths, if you're not insisting on being silly.
2023 splitUp (x:':':div:xs) | div `elem` dir_markers
2024 = ((x:':':div:p): splitUp rs)
2026 (p,rs) = findNextPath xs
2027 -- we used to check for existence of the path here, but that
2028 -- required the IO monad to be threaded through the command-line
2029 -- parser which is quite inconvenient. The
2030 splitUp xs = cons p (splitUp rs)
2032 (p,rs) = findNextPath xs
2037 -- will be called either when we've consumed nought or the
2038 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2039 -- finding the next split marker.
2041 case break (`elem` split_markers) xs of
2042 (p, _:ds) -> (p, ds)
2045 split_markers :: [Char]
2046 split_markers = [':', ';']
2048 dir_markers :: [Char]
2049 dir_markers = ['/', '\\']
2052 -- -----------------------------------------------------------------------------
2053 -- tmpDir, where we store temporary files.
2055 setTmpDir :: FilePath -> DynFlags -> DynFlags
2056 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2057 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2058 -- seem necessary now --SDM 7/2/2008
2060 -----------------------------------------------------------------------------
2063 setRtsOpts :: String -> DynP ()
2064 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2066 -----------------------------------------------------------------------------
2069 setOptHpcDir :: String -> DynP ()
2070 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2072 -----------------------------------------------------------------------------
2073 -- Via-C compilation stuff
2075 -- There are some options that we need to pass to gcc when compiling
2076 -- Haskell code via C, but are only supported by recent versions of
2077 -- gcc. The configure script decides which of these options we need,
2078 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2079 -- read before each via-C compilation. The advantage of having these
2080 -- in a separate file is that the file can be created at install-time
2081 -- depending on the available gcc version, and even re-generated later
2082 -- if gcc is upgraded.
2084 -- The options below are not dependent on the version of gcc, only the
2087 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2088 [String]) -- for registerised HC compilations
2089 machdepCCOpts _dflags
2090 #if alpha_TARGET_ARCH
2092 #ifdef HAVE_THREADED_RTS_SUPPORT
2096 -- For now, to suppress the gcc warning "call-clobbered
2097 -- register used for global register variable", we simply
2098 -- disable all warnings altogether using the -w flag. Oh well.
2100 #elif hppa_TARGET_ARCH
2101 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2102 -- (very nice, but too bad the HP /usr/include files don't agree.)
2103 = ( ["-D_HPUX_SOURCE"], [] )
2105 #elif m68k_TARGET_ARCH
2106 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2107 -- popping of args to routines to be explicit; if we let things
2108 -- be deferred 'til after an STGJUMP, imminent death is certain!
2110 -- -fomit-frame-pointer : *don't*
2111 -- It's better to have a6 completely tied up being a frame pointer
2112 -- rather than let GCC pick random things to do with it.
2113 -- (If we want to steal a6, then we would try to do things
2114 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2115 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2117 #elif i386_TARGET_ARCH
2118 -- -fno-defer-pop : basically the same game as for m68k
2120 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2121 -- the fp (%ebp) for our register maps.
2122 = let n_regs = stolen_x86_regs _dflags
2125 #if darwin_TARGET_OS
2126 -- By default, gcc on OS X will generate SSE
2127 -- instructions, which need things 16-byte aligned,
2128 -- but we don't 16-byte align things. Thus drop
2129 -- back to generic i686 compatibility. Trac #2983.
2131 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2132 ["-march=i686", "-m32"],
2134 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2138 "-fomit-frame-pointer",
2139 -- we want -fno-builtin, because when gcc inlines
2140 -- built-in functions like memcpy() it tends to
2141 -- run out of registers, requiring -monly-n-regs
2143 "-DSTOLEN_X86_REGS="++show n_regs ]
2146 #elif ia64_TARGET_ARCH
2147 = ( [], ["-fomit-frame-pointer", "-G0"] )
2149 #elif x86_64_TARGET_ARCH
2151 #if darwin_TARGET_OS
2156 ["-fomit-frame-pointer",
2157 "-fno-asynchronous-unwind-tables",
2158 -- the unwind tables are unnecessary for HC code,
2159 -- and get in the way of -split-objs. Another option
2160 -- would be to throw them away in the mangler, but this
2163 -- calling builtins like strlen() using the FFI can
2164 -- cause gcc to run out of regs, so use the external
2168 #elif sparc_TARGET_ARCH
2170 -- For now, to suppress the gcc warning "call-clobbered
2171 -- register used for global register variable", we simply
2172 -- disable all warnings altogether using the -w flag. Oh well.
2174 #elif powerpc_apple_darwin_TARGET
2176 -- Disable Apple's precompiling preprocessor. It's a great thing
2177 -- for "normal" programs, but it doesn't support register variable
2179 = ( [], ["-no-cpp-precomp"] )
2184 picCCOpts :: DynFlags -> [String]
2186 #if darwin_TARGET_OS
2187 -- Apple prefers to do things the other way round.
2188 -- PIC is on by default.
2189 -- -mdynamic-no-pic:
2190 -- Turn off PIC code generation.
2192 -- Don't generate "common" symbols - these are unwanted
2193 -- in dynamic libraries.
2196 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2198 = ["-mdynamic-no-pic"]
2199 #elif mingw32_TARGET_OS
2200 -- no -fPIC for Windows
2202 = ["-U __PIC__","-D__PIC__"]
2207 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2212 -- -----------------------------------------------------------------------------
2216 can_split = cSplitObjs == "YES"
2218 -- -----------------------------------------------------------------------------
2221 data Printable = String String
2222 | FromDynFlags (DynFlags -> String)
2224 compilerInfo :: [(String, Printable)]
2225 compilerInfo = [("Project name", String cProjectName),
2226 ("Project version", String cProjectVersion),
2227 ("Booter version", String cBooterVersion),
2228 ("Stage", String cStage),
2229 ("Have interpreter", String cGhcWithInterpreter),
2230 ("Object splitting", String cSplitObjs),
2231 ("Have native code generator", String cGhcWithNativeCodeGen),
2232 ("Have llvm code generator", String cGhcWithLlvmCodeGen),
2233 ("Support SMP", String cGhcWithSMP),
2234 ("Unregisterised", String cGhcUnregisterised),
2235 ("Tables next to code", String cGhcEnableTablesNextToCode),
2236 ("RTS ways", String cGhcRTSWays),
2237 ("Leading underscore", String cLeadingUnderscore),
2238 ("Debug on", String (show debugIsOn)),
2239 ("LibDir", FromDynFlags topDir),
2240 ("Global Package DB", FromDynFlags systemPackageConfig)