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_WarnMissingImportList
168 | Opt_WarnMissingMethods
169 | Opt_WarnMissingSigs
170 | Opt_WarnNameShadowing
171 | Opt_WarnOverlappingPatterns
172 | Opt_WarnSimplePatterns
173 | Opt_WarnTypeDefaults
174 | Opt_WarnMonomorphism
175 | Opt_WarnUnusedBinds
176 | Opt_WarnUnusedImports
177 | Opt_WarnUnusedMatches
178 | Opt_WarnWarningsDeprecations
179 | Opt_WarnDeprecatedFlags
180 | Opt_WarnDodgyExports
181 | Opt_WarnDodgyImports
184 | Opt_WarnUnrecognisedPragmas
185 | Opt_WarnDodgyForeignImports
186 | Opt_WarnLazyUnliftedBindings
187 | Opt_WarnUnusedDoBind
188 | Opt_WarnWrongDoBind
189 | Opt_WarnAlternativeLayoutRuleTransitional
193 | Opt_OverlappingInstances
194 | Opt_UndecidableInstances
195 | Opt_IncoherentInstances
196 | Opt_MonomorphismRestriction
199 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
200 | Opt_ForeignFunctionInterface
201 | Opt_UnliftedFFITypes
202 | Opt_GHCForeignImportPrim
203 | Opt_PArr -- Syntactic support for parallel arrays
204 | Opt_Arrows -- Arrow-notation syntax
205 | Opt_TemplateHaskell
208 | Opt_Generics -- "Derivable type classes"
209 | Opt_ImplicitPrelude
210 | Opt_ScopedTypeVariables
214 | Opt_OverloadedStrings
215 | Opt_DisambiguateRecordFields
216 | Opt_RecordWildCards
223 | Opt_StandaloneDeriving
224 | Opt_DeriveDataTypeable
226 | Opt_DeriveTraversable
229 | Opt_TypeSynonymInstances
230 | Opt_FlexibleContexts
231 | Opt_FlexibleInstances
232 | Opt_ConstrainedClassMethods
233 | Opt_MultiParamTypeClasses
234 | Opt_FunctionalDependencies
236 | Opt_PolymorphicComponents
237 | Opt_ExistentialQuantification
241 | Opt_ParallelListComp
242 | Opt_TransformListComp
243 | Opt_GeneralizedNewtypeDeriving
246 | Opt_PostfixOperators
249 | Opt_LiberalTypeSynonyms
252 | Opt_ImpredicativeTypes
255 | Opt_NewQualifiedOperators
257 | Opt_AlternativeLayoutRule
258 | Opt_AlternativeLayoutRuleTransitional
259 | Opt_DatatypeContexts
261 | Opt_PrintExplicitForalls
268 | Opt_StaticArgumentTransformation
272 | Opt_DoLambdaEtaExpansion
276 | Opt_UnboxStrictFields
279 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
281 | Opt_RegsGraph -- do graph coloring register allocation
282 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
285 | Opt_IgnoreInterfacePragmas
286 | Opt_OmitInterfacePragmas
287 | Opt_ExposeAllUnfoldings
290 | Opt_AutoSccsOnAllToplevs
291 | Opt_AutoSccsOnExportedToplevs
292 | Opt_AutoSccsOnIndividualCafs
300 | Opt_ExcessPrecision
301 | Opt_EagerBlackHoling
302 | Opt_ReadUserPackageConf
307 | Opt_HideAllPackages
308 | Opt_PrintBindResult
312 | Opt_BreakOnException
314 | Opt_PrintEvldWithShow
315 | Opt_PrintBindContents
318 | Opt_EmitExternalCore
320 | Opt_BuildingCabalPackage
326 | Opt_ConvertToZipCfgAndBack
327 | Opt_AutoLinkPackages
328 | Opt_ImplicitImportQualified
337 | Opt_KeepRawTokenStream
342 -- | Contains not only a collection of 'DynFlag's but also a plethora of
343 -- information relating to the compilation of a single file or GHC session
344 data DynFlags = DynFlags {
347 hscTarget :: HscTarget,
348 hscOutName :: String, -- ^ Name of the output file
349 extCoreName :: String, -- ^ Name of the .hcr output file
350 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
351 optLevel :: Int, -- ^ Optimisation level
352 simplPhases :: Int, -- ^ Number of simplifier phases
353 maxSimplIterations :: Int, -- ^ Max simplifier iterations
354 shouldDumpSimplPhase :: Maybe String,
355 ruleCheck :: Maybe String,
356 strictnessBefore :: [Int], -- ^ Additional demand analysis
358 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
359 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
360 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
362 #ifndef OMIT_NATIVE_CODEGEN
363 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
365 stolen_x86_regs :: Int,
366 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
367 importPaths :: [FilePath],
369 mainFunIs :: Maybe String,
370 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
372 dphBackend :: DPHBackend,
374 thisPackage :: PackageId, -- ^ name of package currently being compiled
377 ways :: [Way], -- ^ Way flags from the command line
378 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
379 rtsBuildTag :: String, -- ^ The RTS \"way\"
381 -- For object splitting
382 splitInfo :: Maybe (String,Int),
385 objectDir :: Maybe String,
386 dylibInstallName :: Maybe String,
387 hiDir :: Maybe String,
388 stubDir :: Maybe String,
394 outputFile :: Maybe String,
395 outputHi :: Maybe String,
396 dynLibLoader :: DynLibLoader,
398 -- | This is set by 'DriverPipeline.runPipeline' based on where
399 -- its output is going.
400 dumpPrefix :: Maybe FilePath,
402 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
403 -- Set by @-ddump-file-prefix@
404 dumpPrefixForce :: Maybe FilePath,
406 includePaths :: [String],
407 libraryPaths :: [String],
408 frameworkPaths :: [String], -- used on darwin only
409 cmdlineFrameworks :: [String], -- ditto
410 tmpDir :: String, -- no trailing '/'
412 ghcUsagePath :: FilePath, -- Filled in by SysTools
413 ghciUsagePath :: FilePath, -- ditto
414 rtsOpts :: Maybe String,
416 hpcDir :: String, -- ^ Path to store the .mix files
418 -- options for particular phases
426 opt_windres :: [String],
427 opt_lo :: [String], -- LLVM: llvm optimiser
428 opt_lc :: [String], -- LLVM: llc static compiler
430 -- commands for particular phases
432 pgm_P :: (String,[Option]),
434 pgm_c :: (String,[Option]),
435 pgm_m :: (String,[Option]),
436 pgm_s :: (String,[Option]),
437 pgm_a :: (String,[Option]),
438 pgm_l :: (String,[Option]),
439 pgm_dll :: (String,[Option]),
441 pgm_sysman :: String,
442 pgm_windres :: String,
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
674 pkgDatabase = Nothing,
675 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
676 ways = panic "defaultDynFlags: No ways",
677 buildTag = panic "defaultDynFlags: No buildTag",
678 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
680 -- initSysTools fills all these in
681 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
682 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
683 topDir = panic "defaultDynFlags: No topDir",
684 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
685 pgm_L = panic "defaultDynFlags: No pgm_L",
686 pgm_P = panic "defaultDynFlags: No pgm_P",
687 pgm_F = panic "defaultDynFlags: No pgm_F",
688 pgm_c = panic "defaultDynFlags: No pgm_c",
689 pgm_m = panic "defaultDynFlags: No pgm_m",
690 pgm_s = panic "defaultDynFlags: No pgm_s",
691 pgm_a = panic "defaultDynFlags: No pgm_a",
692 pgm_l = panic "defaultDynFlags: No pgm_l",
693 pgm_dll = panic "defaultDynFlags: No pgm_dll",
694 pgm_T = panic "defaultDynFlags: No pgm_T",
695 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
696 pgm_windres = panic "defaultDynFlags: No pgm_windres",
697 pgm_lo = panic "defaultDynFlags: No pgm_lo",
698 pgm_lc = panic "defaultDynFlags: No pgm_lc",
699 -- end of initSysTools values
701 depMakefile = "Makefile",
702 depIncludePkgDeps = False,
705 -- end of ghc -M values
706 filesToClean = panic "defaultDynFlags: No filesToClean",
707 dirsToClean = panic "defaultDynFlags: No dirsToClean",
708 haddockOptions = Nothing,
710 Opt_AutoLinkPackages,
711 Opt_ReadUserPackageConf,
713 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
714 -- behaviour the default, to see if anyone notices
718 Opt_MonomorphismRestriction,
720 Opt_DatatypeContexts,
730 Opt_PrintBindContents
732 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
733 -- The default -O0 options
736 log_action = \severity srcSpan style msg ->
738 SevInfo -> printErrs (msg style)
739 SevFatal -> printErrs (msg style)
742 printErrs ((mkLocMessage srcSpan msg) style)
743 -- careful (#2302): printErrs prints in UTF-8, whereas
744 -- converting to string first and using hPutStr would
745 -- just emit the low 8 bits of each unicode char.
749 Note [Verbosity levels]
750 ~~~~~~~~~~~~~~~~~~~~~~~
751 0 | print errors & warnings only
752 1 | minimal verbosity: print "compiling M ... done." for each module.
753 2 | equivalent to -dshow-passes
754 3 | equivalent to existing "ghc -v"
755 4 | "ghc -v -ddump-most"
756 5 | "ghc -v -ddump-all"
759 -- | Test whether a 'DynFlag' is set
760 dopt :: DynFlag -> DynFlags -> Bool
761 dopt f dflags = f `elem` (flags dflags)
764 dopt_set :: DynFlags -> DynFlag -> DynFlags
765 dopt_set dfs f = dfs{ flags = f : flags dfs }
767 -- | Unset a 'DynFlag'
768 dopt_unset :: DynFlags -> DynFlag -> DynFlags
769 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
771 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
772 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
773 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
774 -> [a] -- ^ Correctly ordered extracted options
775 getOpts dflags opts = reverse (opts dflags)
776 -- We add to the options from the front, so we need to reverse the list
778 -- | Gets the verbosity flag for the current verbosity level. This is fed to
779 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
780 getVerbFlag :: DynFlags -> String
782 | verbosity dflags >= 3 = "-v"
785 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
786 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
787 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
789 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres, addOptlo, addOptlc,
790 addCmdlineFramework, addHaddockOpts
791 :: String -> DynFlags -> DynFlags
792 setOutputFile, setOutputHi, setDumpPrefixForce
793 :: Maybe String -> DynFlags -> DynFlags
795 setObjectDir f d = d{ objectDir = Just f}
796 setHiDir f d = d{ hiDir = Just f}
797 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
798 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
799 -- \#included from the .hc file when compiling with -fvia-C.
800 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
801 setDylibInstallName f d = d{ dylibInstallName = Just f}
803 setObjectSuf f d = d{ objectSuf = f}
804 setHiSuf f d = d{ hiSuf = f}
805 setHcSuf f d = d{ hcSuf = f}
807 setOutputFile f d = d{ outputFile = f}
808 setOutputHi f d = d{ outputHi = f}
810 parseDynLibLoaderMode f d =
812 ("deploy", "") -> d{ dynLibLoader = Deployable }
813 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
814 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
815 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
816 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
817 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
819 setDumpPrefixForce f d = d { dumpPrefixForce = f}
821 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
822 -- Config.hs should really use Option.
823 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
825 setPgmL f d = d{ pgm_L = f}
826 setPgmF f d = d{ pgm_F = f}
827 setPgmc f d = d{ pgm_c = (f,[])}
828 setPgmm f d = d{ pgm_m = (f,[])}
829 setPgms f d = d{ pgm_s = (f,[])}
830 setPgma f d = d{ pgm_a = (f,[])}
831 setPgml f d = d{ pgm_l = (f,[])}
832 setPgmdll f d = d{ pgm_dll = (f,[])}
833 setPgmwindres f d = d{ pgm_windres = f}
834 setPgmlo f d = d{ pgm_lo = (f,[])}
835 setPgmlc f d = d{ pgm_lc = (f,[])}
837 addOptL f d = d{ opt_L = f : opt_L d}
838 addOptP f d = d{ opt_P = f : opt_P d}
839 addOptF f d = d{ opt_F = f : opt_F d}
840 addOptc f d = d{ opt_c = f : opt_c d}
841 addOptm f d = d{ opt_m = f : opt_m d}
842 addOpta f d = d{ opt_a = f : opt_a d}
843 addOptl f d = d{ opt_l = f : opt_l d}
844 addOptwindres f d = d{ opt_windres = f : opt_windres d}
845 addOptlo f d = d{ opt_lo = f : opt_lo d}
846 addOptlc f d = d{ opt_lc = f : opt_lc d}
848 setDepMakefile :: FilePath -> DynFlags -> DynFlags
849 setDepMakefile f d = d { depMakefile = deOptDep f }
851 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
852 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
854 addDepExcludeMod :: String -> DynFlags -> DynFlags
856 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
858 addDepSuffix :: FilePath -> DynFlags -> DynFlags
859 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
862 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
863 -- we need to strip the "-optdep" off of the arg
864 deOptDep :: String -> String
865 deOptDep x = case stripPrefix "-optdep" x of
869 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
871 addHaddockOpts f d = d{ haddockOptions = Just f}
873 -- -----------------------------------------------------------------------------
874 -- Command-line options
876 -- | When invoking external tools as part of the compilation pipeline, we
877 -- pass these a sequence of options on the command-line. Rather than
878 -- just using a list of Strings, we use a type that allows us to distinguish
879 -- between filepaths and 'other stuff'. The reason for this is that
880 -- this type gives us a handle on transforming filenames, and filenames only,
881 -- to whatever format they're expected to be on a particular platform.
883 = FileOption -- an entry that _contains_ filename(s) / filepaths.
884 String -- a non-filepath prefix that shouldn't be
885 -- transformed (e.g., "/out=")
886 String -- the filepath/filename portion
889 showOpt :: Option -> String
890 showOpt (FileOption pre f) = pre ++ f
891 showOpt (Option s) = s
893 -----------------------------------------------------------------------------
894 -- Setting the optimisation level
896 updOptLevel :: Int -> DynFlags -> DynFlags
897 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
899 = dfs2{ optLevel = final_n }
901 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
902 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
903 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
905 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
906 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
908 optLevelFlags :: [([Int], DynFlag)]
910 = [ ([0], Opt_IgnoreInterfacePragmas)
911 , ([0], Opt_OmitInterfacePragmas)
913 , ([1,2], Opt_IgnoreAsserts)
914 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
916 , ([1,2], Opt_DoEtaReduction)
917 , ([1,2], Opt_CaseMerge)
918 , ([1,2], Opt_Strictness)
920 , ([1,2], Opt_FullLaziness)
921 , ([1,2], Opt_Specialise)
922 , ([1,2], Opt_FloatIn)
924 , ([2], Opt_LiberateCase)
925 , ([2], Opt_SpecConstr)
927 -- , ([2], Opt_StaticArgumentTransformation)
928 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
929 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
930 -- several improvements to the heuristics, and I'm concerned that without
931 -- those changes SAT will interfere with some attempts to write "high
932 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
933 -- this year. In particular, the version in HEAD lacks the tail call
934 -- criterion, so many things that look like reasonable loops will be
935 -- turned into functions with extra (unneccesary) thunk creation.
937 , ([0,1,2], Opt_DoLambdaEtaExpansion)
938 -- This one is important for a tiresome reason:
939 -- we want to make sure that the bindings for data
940 -- constructors are eta-expanded. This is probably
941 -- a good thing anyway, but it seems fragile.
944 -- -----------------------------------------------------------------------------
945 -- Standard sets of warning options
947 standardWarnings :: [DynFlag]
949 = [ Opt_WarnWarningsDeprecations,
950 Opt_WarnDeprecatedFlags,
951 Opt_WarnUnrecognisedPragmas,
952 Opt_WarnOverlappingPatterns,
953 Opt_WarnMissingFields,
954 Opt_WarnMissingMethods,
955 Opt_WarnDuplicateExports,
956 Opt_WarnLazyUnliftedBindings,
957 Opt_WarnDodgyForeignImports,
959 Opt_WarnAlternativeLayoutRuleTransitional
962 minusWOpts :: [DynFlag]
964 = standardWarnings ++
965 [ Opt_WarnUnusedBinds,
966 Opt_WarnUnusedMatches,
967 Opt_WarnUnusedImports,
968 Opt_WarnIncompletePatterns,
969 Opt_WarnDodgyExports,
973 minusWallOpts :: [DynFlag]
976 [ Opt_WarnTypeDefaults,
977 Opt_WarnNameShadowing,
984 -- minuswRemovesOpts should be every warning option
985 minuswRemovesOpts :: [DynFlag]
988 [Opt_WarnImplicitPrelude,
989 Opt_WarnIncompletePatternsRecUpd,
990 Opt_WarnSimplePatterns,
991 Opt_WarnMonomorphism,
992 Opt_WarnUnrecognisedPragmas,
996 -- -----------------------------------------------------------------------------
997 -- StgToDo: abstraction of stg-to-stg passes to run.
1000 = StgDoMassageForProfiling -- should be (next to) last
1001 -- There's also setStgVarInfo, but its absolute "lastness"
1002 -- is so critical that it is hardwired in (no flag).
1005 getStgToDo :: DynFlags -> [StgToDo]
1009 stg_stats = dopt Opt_StgStats dflags
1011 todo1 = if stg_stats then [D_stg_stats] else []
1013 todo2 | WayProf `elem` wayNames dflags
1014 = StgDoMassageForProfiling : todo1
1018 -- -----------------------------------------------------------------------------
1021 allFlags :: [String]
1022 allFlags = map ('-':) $
1023 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1024 map ("fno-"++) flags ++
1025 map ("f"++) flags ++
1026 map ("X"++) supportedLanguages
1027 where ok (PrefixPred _ _) = False
1029 flags = [ name | (name, _, _) <- fFlags ]
1031 dynamic_flags :: [Flag DynP]
1033 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1034 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1035 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1036 , Flag "#include" (HasArg (addCmdlineHCInclude))
1037 (DeprecatedFullText "-#include and INCLUDE pragmas are deprecated: They no longer have any effect")
1038 , Flag "v" (OptIntSuffix setVerbosity) Supported
1040 ------- Specific phases --------------------------------------------
1041 -- need to appear before -pgmL to be parsed as LLVM flags.
1042 , Flag "pgmlo" (HasArg (upd . setPgmlo)) Supported
1043 , Flag "pgmlc" (HasArg (upd . setPgmlc)) Supported
1045 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1046 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1047 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1048 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1049 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1050 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1051 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1052 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1053 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1054 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1056 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1057 , Flag "optlo" (HasArg (upd . addOptlo)) Supported
1058 , Flag "optlc" (HasArg (upd . addOptlc)) Supported
1060 , Flag "optL" (HasArg (upd . addOptL)) Supported
1061 , Flag "optP" (HasArg (upd . addOptP)) Supported
1062 , Flag "optF" (HasArg (upd . addOptF)) Supported
1063 , Flag "optc" (HasArg (upd . addOptc)) Supported
1064 , Flag "optm" (HasArg (upd . addOptm)) Supported
1065 , Flag "opta" (HasArg (upd . addOpta)) Supported
1066 , Flag "optl" (HasArg (upd . addOptl)) Supported
1067 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1070 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1073 -------- ghc -M -----------------------------------------------------
1074 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1075 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1076 (Deprecated "Use -dep-suffix instead")
1077 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1078 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1079 (Deprecated "Use -dep-makefile instead")
1080 , Flag "optdep-w" (NoArg (return ()))
1081 (Deprecated "-optdep-w doesn't do anything")
1082 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1083 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1084 (Deprecated "Use -include-pkg-deps instead")
1085 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1086 (Deprecated "Use -include-pkg-deps instead")
1087 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1088 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1089 (Deprecated "Use -exclude-module instead")
1090 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1091 (Deprecated "Use -exclude-module instead")
1093 -------- Linking ----------------------------------------------------
1094 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1096 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1098 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1100 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1102 ------- Libraries ---------------------------------------------------
1103 , Flag "L" (Prefix addLibraryPath ) Supported
1104 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1106 ------- Frameworks --------------------------------------------------
1107 -- -framework-path should really be -F ...
1108 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1109 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1111 ------- Output Redirection ------------------------------------------
1112 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1113 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1114 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1115 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1116 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1117 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1118 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1119 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1120 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1121 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1122 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1125 ------- Keeping temporary files -------------------------------------
1126 -- These can be singular (think ghc -c) or plural (think ghc --make)
1127 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1128 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1129 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1130 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1131 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1132 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1133 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1134 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1135 -- This only makes sense as plural
1136 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1138 ------- Miscellaneous ----------------------------------------------
1139 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1140 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1141 , Flag "with-rtsopts" (HasArg setRtsOpts) Supported
1142 , Flag "rtsopts" (NoArg (setDynFlag Opt_RtsOptsEnabled)) Supported
1143 , Flag "no-rtsopts" (NoArg (unSetDynFlag Opt_RtsOptsEnabled)) Supported
1144 , Flag "main-is" (SepArg setMainIs ) Supported
1145 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1146 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1147 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1149 ------- recompilation checker --------------------------------------
1150 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1151 (Deprecated "Use -fno-force-recomp instead")
1152 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1153 (Deprecated "Use -fforce-recomp instead")
1155 ------ HsCpp opts ---------------------------------------------------
1156 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1157 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1159 ------- Include/Import Paths ----------------------------------------
1160 , Flag "I" (Prefix addIncludePath) Supported
1161 , Flag "i" (OptPrefix addImportPath ) Supported
1163 ------ Debugging ----------------------------------------------------
1164 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1166 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1168 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1170 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1172 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1174 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1176 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1178 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1180 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1182 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1184 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1186 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1188 , Flag "ddump-asm-regalloc-stages"
1189 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1191 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1193 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1195 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1196 ; setDumpFlag' Opt_D_dump_llvm}))
1198 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1200 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1202 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1204 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1206 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1208 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1210 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1212 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1214 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1216 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1218 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1220 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1222 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1224 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1226 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1228 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1230 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1232 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1234 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1236 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1238 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1240 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1242 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1244 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1246 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1248 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1250 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1252 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1254 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1256 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1258 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1260 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1261 ; setVerboseCore2Core }))
1263 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1265 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1267 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1269 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1271 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1273 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1275 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1277 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1279 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1281 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1284 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1286 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1288 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1290 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1292 , Flag "dshow-passes"
1293 (NoArg (do forceRecompile
1294 setVerbosity (Just 2)))
1296 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1299 ------ Machine dependant (-m<blah>) stuff ---------------------------
1301 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1303 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1305 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1308 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1311 ------ Warning opts -------------------------------------------------
1312 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1314 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1316 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1318 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1320 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1321 (Deprecated "Use -w instead")
1322 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1325 ------ Optimisation flags ------------------------------------------
1326 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1327 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1328 (Deprecated "Use -O0 instead")
1329 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1330 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1332 -- If the number is missing, use 1
1334 , Flag "fsimplifier-phases"
1335 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1337 , Flag "fmax-simplifier-iterations"
1338 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1341 , Flag "fspec-constr-threshold"
1342 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1344 , Flag "fno-spec-constr-threshold"
1345 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1347 , Flag "fspec-constr-count"
1348 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1350 , Flag "fno-spec-constr-count"
1351 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1353 , Flag "fliberate-case-threshold"
1354 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1356 , Flag "fno-liberate-case-threshold"
1357 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1360 , Flag "frule-check"
1361 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1363 , Flag "fcontext-stack"
1364 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1367 , Flag "fstrictness-before"
1368 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1371 ------ Profiling ----------------------------------------------------
1373 -- XXX Should the -f* flags be deprecated?
1374 -- They don't seem to be documented
1375 , Flag "fauto-sccs-on-all-toplevs"
1376 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1379 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1381 , Flag "no-auto-all"
1382 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1384 , Flag "fauto-sccs-on-exported-toplevs"
1385 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1388 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1391 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1393 , Flag "fauto-sccs-on-individual-cafs"
1394 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1397 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1400 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1403 ------ DPH flags ----------------------------------------------------
1406 (NoArg (setDPHBackend DPHSeq))
1409 (NoArg (setDPHBackend DPHPar))
1412 (NoArg (setDPHBackend DPHThis))
1415 ------ Compiler flags -----------------------------------------------
1417 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1418 , Flag "fvia-c" (NoArg (setObjTarget HscC))
1419 (Deprecated "The -fvia-c flag will be removed in a future GHC release")
1420 , Flag "fvia-C" (NoArg (setObjTarget HscC))
1421 (Deprecated "The -fvia-C flag will be removed in a future GHC release")
1422 , Flag "fllvm" (NoArg (setObjTarget HscLlvm)) Supported
1424 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1425 setTarget HscNothing))
1427 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1428 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1430 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1432 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1435 ++ map (mkFlag True "f" setDynFlag ) fFlags
1436 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1437 ++ map (mkFlag True "X" setDynFlag ) xFlags
1438 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1440 package_flags :: [Flag DynP]
1442 ------- Packages ----------------------------------------------------
1443 Flag "package-conf" (HasArg extraPkgConf_) Supported
1444 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1446 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1447 , Flag "package-id" (HasArg exposePackageId) Supported
1448 , Flag "package" (HasArg exposePackage) Supported
1449 , Flag "hide-package" (HasArg hidePackage) Supported
1450 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1452 , Flag "ignore-package" (HasArg ignorePackage)
1454 , Flag "syslib" (HasArg exposePackage)
1455 (Deprecated "Use -package instead")
1458 mkFlag :: Bool -- ^ True <=> it should be turned on
1459 -> String -- ^ The flag prefix
1460 -> (DynFlag -> DynP ())
1461 -> (String, DynFlag, Bool -> Deprecated)
1463 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1464 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1466 deprecatedForLanguage :: String -> Bool -> Deprecated
1467 deprecatedForLanguage lang turn_on
1468 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1470 flag | turn_on = lang
1471 | otherwise = "No"++lang
1473 useInstead :: String -> Bool -> Deprecated
1474 useInstead flag turn_on
1475 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1477 no = if turn_on then "" else "no-"
1479 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1480 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1482 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1483 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1484 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1485 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1486 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1487 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1488 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1489 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1490 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1491 ( "warn-missing-import-lists", Opt_WarnMissingImportList, const Supported ),
1492 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1493 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1494 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1495 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1496 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1497 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1498 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1499 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1500 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1501 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1502 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1503 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1504 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1505 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1506 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1507 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1508 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1509 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1510 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1511 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1512 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, const Supported ),
1513 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1514 ( "strictness", Opt_Strictness, const Supported ),
1515 ( "specialise", Opt_Specialise, const Supported ),
1516 ( "float-in", Opt_FloatIn, const Supported ),
1517 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1518 ( "full-laziness", Opt_FullLaziness, const Supported ),
1519 ( "liberate-case", Opt_LiberateCase, const Supported ),
1520 ( "spec-constr", Opt_SpecConstr, const Supported ),
1521 ( "cse", Opt_CSE, const Supported ),
1522 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1523 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1524 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1525 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1526 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1527 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1528 ( "case-merge", Opt_CaseMerge, const Supported ),
1529 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1530 ( "method-sharing", Opt_MethodSharing, const Supported ),
1531 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1532 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1533 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1534 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1535 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1536 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1537 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1538 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1539 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1540 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1541 ( "break-on-error", Opt_BreakOnError, const Supported ),
1542 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1543 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1544 ( "run-cps", Opt_RunCPS, const Supported ),
1545 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1546 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1547 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1548 ( "vectorise", Opt_Vectorise, const Supported ),
1549 ( "regs-graph", Opt_RegsGraph, const Supported ),
1550 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1551 ( "th", Opt_TemplateHaskell,
1552 deprecatedForLanguage "TemplateHaskell" ),
1553 ( "fi", Opt_ForeignFunctionInterface,
1554 deprecatedForLanguage "ForeignFunctionInterface" ),
1555 ( "ffi", Opt_ForeignFunctionInterface,
1556 deprecatedForLanguage "ForeignFunctionInterface" ),
1557 ( "arrows", Opt_Arrows,
1558 deprecatedForLanguage "Arrows" ),
1559 ( "generics", Opt_Generics,
1560 deprecatedForLanguage "Generics" ),
1561 ( "implicit-prelude", Opt_ImplicitPrelude,
1562 deprecatedForLanguage "ImplicitPrelude" ),
1563 ( "bang-patterns", Opt_BangPatterns,
1564 deprecatedForLanguage "BangPatterns" ),
1565 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1566 deprecatedForLanguage "MonomorphismRestriction" ),
1567 ( "mono-pat-binds", Opt_MonoPatBinds,
1568 deprecatedForLanguage "MonoPatBinds" ),
1569 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1570 deprecatedForLanguage "ExtendedDefaultRules" ),
1571 ( "implicit-params", Opt_ImplicitParams,
1572 deprecatedForLanguage "ImplicitParams" ),
1573 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1574 deprecatedForLanguage "ScopedTypeVariables" ),
1576 deprecatedForLanguage "PArr" ),
1577 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1578 deprecatedForLanguage "OverlappingInstances" ),
1579 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1580 deprecatedForLanguage "UndecidableInstances" ),
1581 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1582 deprecatedForLanguage "IncoherentInstances" ),
1583 ( "gen-manifest", Opt_GenManifest, const Supported ),
1584 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1585 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1586 ( "shared-implib", Opt_SharedImplib, const Supported ),
1587 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1588 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1591 supportedLanguages :: [String]
1592 supportedLanguages = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1594 -- This may contain duplicates
1595 languageOptions :: [DynFlag]
1596 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1598 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1599 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1601 ( "CPP", Opt_Cpp, const Supported ),
1602 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1603 ( "TupleSections", Opt_TupleSections, const Supported ),
1604 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1605 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1606 ( "MagicHash", Opt_MagicHash, const Supported ),
1607 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1608 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1609 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1610 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1611 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1612 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1613 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1614 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1615 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1616 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1617 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1618 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1619 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1620 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1621 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1622 ( "RecursiveDo", Opt_RecursiveDo,
1623 deprecatedForLanguage "DoRec"),
1624 ( "DoRec", Opt_DoRec, const Supported ),
1625 ( "Arrows", Opt_Arrows, const Supported ),
1626 ( "PArr", Opt_PArr, const Supported ),
1627 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1628 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1629 ( "Generics", Opt_Generics, const Supported ),
1631 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1632 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1633 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1634 ( "RecordPuns", Opt_RecordPuns,
1635 deprecatedForLanguage "NamedFieldPuns" ),
1636 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1637 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1638 ( "GADTs", Opt_GADTs, const Supported ),
1639 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1640 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1641 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1643 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1645 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1646 -- On by default (which is not strictly H98):
1647 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1648 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1649 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1650 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, const Supported ),
1652 ( "DatatypeContexts", Opt_DatatypeContexts, const Supported ),
1653 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1654 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1655 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1656 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1657 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1659 ( "PatternSignatures", Opt_ScopedTypeVariables,
1660 deprecatedForLanguage "ScopedTypeVariables" ),
1662 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1663 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1664 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1665 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1666 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1667 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1668 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1669 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1670 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1671 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1672 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1673 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1674 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1675 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1676 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1677 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1678 ( "PackageImports", Opt_PackageImports, const Supported ),
1679 ( "NewQualifiedOperators", Opt_NewQualifiedOperators,
1680 const $ Deprecated "The new qualified operator syntax was rejected by Haskell'" )
1683 impliedFlags :: [(DynFlag, DynFlag)]
1685 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1686 , (Opt_Rank2Types, Opt_ExplicitForAll)
1687 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1688 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1689 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1690 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1692 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1693 -- be completely rigid for GADTs
1695 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1696 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1697 -- all over the place
1699 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1700 -- Note [Scoped tyvars] in TcBinds
1701 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1703 -- Record wild-cards implies field disambiguation
1704 -- Otherwise if you write (C {..}) you may well get
1705 -- stuff like " 'a' not in scope ", which is a bit silly
1706 -- if the compiler has just filled in field 'a' of constructor 'C'
1707 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1710 glasgowExtsFlags :: [DynFlag]
1711 glasgowExtsFlags = [
1712 Opt_PrintExplicitForalls
1713 , Opt_ForeignFunctionInterface
1714 , Opt_UnliftedFFITypes
1716 , Opt_ImplicitParams
1717 , Opt_ScopedTypeVariables
1719 , Opt_TypeSynonymInstances
1720 , Opt_StandaloneDeriving
1721 , Opt_DeriveDataTypeable
1723 , Opt_DeriveFoldable
1724 , Opt_DeriveTraversable
1725 , Opt_FlexibleContexts
1726 , Opt_FlexibleInstances
1727 , Opt_ConstrainedClassMethods
1728 , Opt_MultiParamTypeClasses
1729 , Opt_FunctionalDependencies
1731 , Opt_PolymorphicComponents
1732 , Opt_ExistentialQuantification
1734 , Opt_PostfixOperators
1736 , Opt_LiberalTypeSynonyms
1740 , Opt_ParallelListComp
1741 , Opt_EmptyDataDecls
1742 , Opt_KindSignatures
1743 , Opt_GeneralizedNewtypeDeriving
1744 , Opt_TypeFamilies ]
1746 -- -----------------------------------------------------------------------------
1747 -- Parsing the dynamic flags.
1749 -- | Parse dynamic flags from a list of command line arguments. Returns the
1750 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1751 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1752 -- flags or missing arguments).
1753 parseDynamicFlags :: Monad m =>
1754 DynFlags -> [Located String]
1755 -> m (DynFlags, [Located String], [Located String])
1756 -- ^ Updated 'DynFlags', left-over arguments, and
1757 -- list of warnings.
1758 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1760 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1761 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1762 parseDynamicNoPackageFlags :: Monad m =>
1763 DynFlags -> [Located String]
1764 -> m (DynFlags, [Located String], [Located String])
1765 -- ^ Updated 'DynFlags', left-over arguments, and
1766 -- list of warnings.
1767 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1769 parseDynamicFlags_ :: Monad m =>
1770 DynFlags -> [Located String] -> Bool
1771 -> m (DynFlags, [Located String], [Located String])
1772 parseDynamicFlags_ dflags0 args pkg_flags = do
1773 -- XXX Legacy support code
1774 -- We used to accept things like
1775 -- optdep-f -optdepdepend
1776 -- optdep-f -optdep depend
1777 -- optdep -f -optdepdepend
1778 -- optdep -f -optdep depend
1779 -- but the spaces trip up proper argument handling. So get rid of them.
1780 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1781 f (x : xs) = x : f xs
1785 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1786 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1787 | otherwise = dynamic_flags
1789 let ((leftover, errs, warns), dflags1)
1790 = runCmdLine (processArgs flag_spec args') dflags0
1791 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1793 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1794 -- isn't up to the job. We know that if hscTarget == HscC, then the
1795 -- user has explicitly used -fvia-C, because -fasm is the default,
1796 -- unless there is no NCG on this platform. The latter case is
1797 -- checked when the -fPIC flag is parsed.
1799 let (pic_warns, dflags2) =
1800 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1801 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1802 dflags1{ hscTarget = HscAsm })
1805 return (dflags2, leftover, pic_warns ++ warns)
1807 type DynP = CmdLineP DynFlags
1809 upd :: (DynFlags -> DynFlags) -> DynP ()
1811 dfs <- getCmdLineState
1812 putCmdLineState $! (f dfs)
1814 --------------------------
1815 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1816 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1817 ; mapM_ setDynFlag deps }
1819 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1820 -- When you set f, set the ones it implies
1821 -- NB: use setDynFlag recursively, in case the implied flags
1822 -- implies further flags
1823 -- When you un-set f, however, we don't un-set the things it implies
1824 -- (except for -fno-glasgow-exts, which is treated specially)
1826 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1828 --------------------------
1829 setDumpFlag :: DynFlag -> OptKind DynP
1830 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1832 setDumpFlag' :: DynFlag -> DynP ()
1833 setDumpFlag' dump_flag
1834 = do { setDynFlag dump_flag
1835 ; when want_recomp forceRecompile }
1837 -- Certain dumpy-things are really interested in what's going
1838 -- on during recompilation checking, so in those cases we
1839 -- don't want to turn it off.
1840 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1841 Opt_D_dump_hi_diffs]
1843 forceRecompile :: DynP ()
1844 -- Whenver we -ddump, force recompilation (by switching off the
1845 -- recompilation checker), else you don't see the dump! However,
1846 -- don't switch it off in --make mode, else *everything* gets
1847 -- recompiled which probably isn't what you want
1848 forceRecompile = do { dfs <- getCmdLineState
1849 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1851 force_recomp dfs = isOneShot (ghcMode dfs)
1853 setVerboseCore2Core :: DynP ()
1854 setVerboseCore2Core = do forceRecompile
1855 setDynFlag Opt_D_verbose_core2core
1856 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
1859 setDumpSimplPhases :: String -> DynP ()
1860 setDumpSimplPhases s = do forceRecompile
1861 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
1863 spec = case s of { ('=' : s') -> s'; _ -> s }
1865 setVerbosity :: Maybe Int -> DynP ()
1866 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1868 addCmdlineHCInclude :: String -> DynP ()
1869 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
1871 extraPkgConf_ :: FilePath -> DynP ()
1872 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1874 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
1876 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
1878 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
1880 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
1882 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
1884 setPackageName :: String -> DynFlags -> DynFlags
1885 setPackageName p s = s{ thisPackage = stringToPackageId p }
1887 -- If we're linking a binary, then only targets that produce object
1888 -- code are allowed (requests for other target types are ignored).
1889 setTarget :: HscTarget -> DynP ()
1890 setTarget l = upd set
1893 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
1896 -- Changes the target only if we're compiling object code. This is
1897 -- used by -fasm and -fvia-C, which switch from one to the other, but
1898 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
1899 -- can be safely used in an OPTIONS_GHC pragma.
1900 setObjTarget :: HscTarget -> DynP ()
1901 setObjTarget l = upd set
1904 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1907 setOptLevel :: Int -> DynFlags -> DynFlags
1908 setOptLevel n dflags
1909 | hscTarget dflags == HscInterpreted && n > 0
1911 -- not in IO any more, oh well:
1912 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1914 = updOptLevel n dflags
1917 -- -Odph is equivalent to
1919 -- -O2 optimise as much as possible
1920 -- -fno-method-sharing sharing specialisation defeats fusion
1922 -- -fdicts-cheap always inline dictionaries
1923 -- -fmax-simplifier-iterations20 this is necessary sometimes
1924 -- -fsimplifier-phases=3 we use an additional simplifier phase
1926 -- -fno-spec-constr-threshold run SpecConstr even for big loops
1927 -- -fno-spec-constr-count SpecConstr as much as possible
1928 -- -finline-enough-args hack to prevent excessive inlining
1930 setDPHOpt :: DynFlags -> DynFlags
1931 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
1933 , specConstrThreshold = Nothing
1934 , specConstrCount = Nothing
1936 `dopt_set` Opt_DictsCheap
1937 `dopt_unset` Opt_MethodSharing
1939 data DPHBackend = DPHPar
1942 deriving(Eq, Ord, Enum, Show)
1944 setDPHBackend :: DPHBackend -> DynP ()
1945 setDPHBackend backend
1947 upd $ \dflags -> dflags { dphBackend = backend }
1948 mapM_ exposePackage (dph_packages backend)
1950 dph_packages DPHThis = []
1951 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
1952 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
1954 dphPackage :: DynFlags -> PackageId
1955 dphPackage dflags = case dphBackend dflags of
1956 DPHPar -> dphParPackageId
1957 DPHSeq -> dphSeqPackageId
1958 DPHThis -> thisPackage dflags
1960 setMainIs :: String -> DynP ()
1962 | not (null main_fn) && isLower (head main_fn)
1963 -- The arg looked like "Foo.Bar.baz"
1964 = upd $ \d -> d{ mainFunIs = Just main_fn,
1965 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1967 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
1968 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1970 | otherwise -- The arg looked like "baz"
1971 = upd $ \d -> d{ mainFunIs = Just arg }
1973 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1975 -----------------------------------------------------------------------------
1976 -- Paths & Libraries
1978 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1980 -- -i on its own deletes the import paths
1981 addImportPath "" = upd (\s -> s{importPaths = []})
1982 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1986 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1989 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1991 addFrameworkPath p =
1992 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1994 #ifndef mingw32_TARGET_OS
1995 split_marker :: Char
1996 split_marker = ':' -- not configurable (ToDo)
1999 splitPathList :: String -> [String]
2000 splitPathList s = filter notNull (splitUp s)
2001 -- empty paths are ignored: there might be a trailing
2002 -- ':' in the initial list, for example. Empty paths can
2003 -- cause confusion when they are translated into -I options
2004 -- for passing to gcc.
2006 #ifndef mingw32_TARGET_OS
2007 splitUp xs = split split_marker xs
2009 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2011 -- That is, if "foo:bar:baz" is used, this interpreted as
2012 -- consisting of three entries, 'foo', 'bar', 'baz'.
2013 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2014 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2016 -- Notice that no attempt is made to fully replace the 'standard'
2017 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2018 -- that this will cause too much breakage for users & ':' will
2019 -- work fine even with DOS paths, if you're not insisting on being silly.
2022 splitUp (x:':':div:xs) | div `elem` dir_markers
2023 = ((x:':':div:p): splitUp rs)
2025 (p,rs) = findNextPath xs
2026 -- we used to check for existence of the path here, but that
2027 -- required the IO monad to be threaded through the command-line
2028 -- parser which is quite inconvenient. The
2029 splitUp xs = cons p (splitUp rs)
2031 (p,rs) = findNextPath xs
2036 -- will be called either when we've consumed nought or the
2037 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2038 -- finding the next split marker.
2040 case break (`elem` split_markers) xs of
2041 (p, _:ds) -> (p, ds)
2044 split_markers :: [Char]
2045 split_markers = [':', ';']
2047 dir_markers :: [Char]
2048 dir_markers = ['/', '\\']
2051 -- -----------------------------------------------------------------------------
2052 -- tmpDir, where we store temporary files.
2054 setTmpDir :: FilePath -> DynFlags -> DynFlags
2055 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2056 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2057 -- seem necessary now --SDM 7/2/2008
2059 -----------------------------------------------------------------------------
2062 setRtsOpts :: String -> DynP ()
2063 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2065 -----------------------------------------------------------------------------
2068 setOptHpcDir :: String -> DynP ()
2069 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2071 -----------------------------------------------------------------------------
2072 -- Via-C compilation stuff
2074 -- There are some options that we need to pass to gcc when compiling
2075 -- Haskell code via C, but are only supported by recent versions of
2076 -- gcc. The configure script decides which of these options we need,
2077 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2078 -- read before each via-C compilation. The advantage of having these
2079 -- in a separate file is that the file can be created at install-time
2080 -- depending on the available gcc version, and even re-generated later
2081 -- if gcc is upgraded.
2083 -- The options below are not dependent on the version of gcc, only the
2086 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2087 [String]) -- for registerised HC compilations
2088 machdepCCOpts _dflags
2089 #if alpha_TARGET_ARCH
2091 #ifdef HAVE_THREADED_RTS_SUPPORT
2095 -- For now, to suppress the gcc warning "call-clobbered
2096 -- register used for global register variable", we simply
2097 -- disable all warnings altogether using the -w flag. Oh well.
2099 #elif hppa_TARGET_ARCH
2100 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2101 -- (very nice, but too bad the HP /usr/include files don't agree.)
2102 = ( ["-D_HPUX_SOURCE"], [] )
2104 #elif m68k_TARGET_ARCH
2105 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2106 -- popping of args to routines to be explicit; if we let things
2107 -- be deferred 'til after an STGJUMP, imminent death is certain!
2109 -- -fomit-frame-pointer : *don't*
2110 -- It's better to have a6 completely tied up being a frame pointer
2111 -- rather than let GCC pick random things to do with it.
2112 -- (If we want to steal a6, then we would try to do things
2113 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2114 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2116 #elif i386_TARGET_ARCH
2117 -- -fno-defer-pop : basically the same game as for m68k
2119 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2120 -- the fp (%ebp) for our register maps.
2121 = let n_regs = stolen_x86_regs _dflags
2124 #if darwin_TARGET_OS
2125 -- By default, gcc on OS X will generate SSE
2126 -- instructions, which need things 16-byte aligned,
2127 -- but we don't 16-byte align things. Thus drop
2128 -- back to generic i686 compatibility. Trac #2983.
2130 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2131 ["-march=i686", "-m32"],
2133 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2137 "-fomit-frame-pointer",
2138 -- we want -fno-builtin, because when gcc inlines
2139 -- built-in functions like memcpy() it tends to
2140 -- run out of registers, requiring -monly-n-regs
2142 "-DSTOLEN_X86_REGS="++show n_regs ]
2145 #elif ia64_TARGET_ARCH
2146 = ( [], ["-fomit-frame-pointer", "-G0"] )
2148 #elif x86_64_TARGET_ARCH
2150 #if darwin_TARGET_OS
2155 ["-fomit-frame-pointer",
2156 "-fno-asynchronous-unwind-tables",
2157 -- the unwind tables are unnecessary for HC code,
2158 -- and get in the way of -split-objs. Another option
2159 -- would be to throw them away in the mangler, but this
2162 -- calling builtins like strlen() using the FFI can
2163 -- cause gcc to run out of regs, so use the external
2167 #elif sparc_TARGET_ARCH
2169 -- For now, to suppress the gcc warning "call-clobbered
2170 -- register used for global register variable", we simply
2171 -- disable all warnings altogether using the -w flag. Oh well.
2173 #elif powerpc_apple_darwin_TARGET
2175 -- Disable Apple's precompiling preprocessor. It's a great thing
2176 -- for "normal" programs, but it doesn't support register variable
2178 = ( [], ["-no-cpp-precomp"] )
2183 picCCOpts :: DynFlags -> [String]
2185 #if darwin_TARGET_OS
2186 -- Apple prefers to do things the other way round.
2187 -- PIC is on by default.
2188 -- -mdynamic-no-pic:
2189 -- Turn off PIC code generation.
2191 -- Don't generate "common" symbols - these are unwanted
2192 -- in dynamic libraries.
2195 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2197 = ["-mdynamic-no-pic"]
2198 #elif mingw32_TARGET_OS
2199 -- no -fPIC for Windows
2201 = ["-U __PIC__","-D__PIC__"]
2205 -- we need -fPIC for C files when we are compiling with -dynamic,
2206 -- otherwise things like stub.c files don't get compiled
2207 -- correctly. They need to reference data in the Haskell
2208 -- objects, but can't without -fPIC. See
2209 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2210 | opt_PIC || not opt_Static
2211 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2216 -- -----------------------------------------------------------------------------
2220 can_split = cSplitObjs == "YES"
2222 -- -----------------------------------------------------------------------------
2225 data Printable = String String
2226 | FromDynFlags (DynFlags -> String)
2228 compilerInfo :: [(String, Printable)]
2229 compilerInfo = [("Project name", String cProjectName),
2230 ("Project version", String cProjectVersion),
2231 ("Booter version", String cBooterVersion),
2232 ("Stage", String cStage),
2233 ("Build platform", String cBuildPlatform),
2234 ("Host platform", String cHostPlatform),
2235 ("Target platform", String cTargetPlatform),
2236 ("Have interpreter", String cGhcWithInterpreter),
2237 ("Object splitting", String cSplitObjs),
2238 ("Have native code generator", String cGhcWithNativeCodeGen),
2239 ("Have llvm code generator", String cGhcWithLlvmCodeGen),
2240 ("Support SMP", String cGhcWithSMP),
2241 ("Unregisterised", String cGhcUnregisterised),
2242 ("Tables next to code", String cGhcEnableTablesNextToCode),
2243 ("RTS ways", String cGhcRTSWays),
2244 ("Leading underscore", String cLeadingUnderscore),
2245 ("Debug on", String (show debugIsOn)),
2246 ("LibDir", FromDynFlags topDir),
2247 ("Global Package DB", FromDynFlags systemPackageConfig)