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
260 | Opt_PrintExplicitForalls
267 | Opt_StaticArgumentTransformation
271 | Opt_DoLambdaEtaExpansion
275 | Opt_UnboxStrictFields
278 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
280 | Opt_RegsGraph -- do graph coloring register allocation
281 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
284 | Opt_IgnoreInterfacePragmas
285 | Opt_OmitInterfacePragmas
286 | Opt_ExposeAllUnfoldings
289 | Opt_AutoSccsOnAllToplevs
290 | Opt_AutoSccsOnExportedToplevs
291 | Opt_AutoSccsOnIndividualCafs
299 | Opt_ExcessPrecision
300 | Opt_EagerBlackHoling
301 | Opt_ReadUserPackageConf
306 | Opt_HideAllPackages
307 | Opt_PrintBindResult
311 | Opt_BreakOnException
313 | Opt_PrintEvldWithShow
314 | Opt_PrintBindContents
317 | Opt_EmitExternalCore
319 | Opt_BuildingCabalPackage
325 | Opt_ConvertToZipCfgAndBack
326 | Opt_AutoLinkPackages
327 | Opt_ImplicitImportQualified
336 | Opt_KeepRawTokenStream
341 -- | Contains not only a collection of 'DynFlag's but also a plethora of
342 -- information relating to the compilation of a single file or GHC session
343 data DynFlags = DynFlags {
346 hscTarget :: HscTarget,
347 hscOutName :: String, -- ^ Name of the output file
348 extCoreName :: String, -- ^ Name of the .hcr output file
349 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
350 optLevel :: Int, -- ^ Optimisation level
351 simplPhases :: Int, -- ^ Number of simplifier phases
352 maxSimplIterations :: Int, -- ^ Max simplifier iterations
353 shouldDumpSimplPhase :: Maybe String,
354 ruleCheck :: Maybe String,
355 strictnessBefore :: [Int], -- ^ Additional demand analysis
357 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
358 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
359 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
361 #ifndef OMIT_NATIVE_CODEGEN
362 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
364 stolen_x86_regs :: Int,
365 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
366 importPaths :: [FilePath],
368 mainFunIs :: Maybe String,
369 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
371 dphBackend :: DPHBackend,
373 thisPackage :: PackageId, -- ^ name of package currently being compiled
376 ways :: [Way], -- ^ Way flags from the command line
377 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
378 rtsBuildTag :: String, -- ^ The RTS \"way\"
380 -- For object splitting
381 splitInfo :: Maybe (String,Int),
384 objectDir :: Maybe String,
385 dylibInstallName :: Maybe String,
386 hiDir :: Maybe String,
387 stubDir :: Maybe String,
393 outputFile :: Maybe String,
394 outputHi :: Maybe String,
395 dynLibLoader :: DynLibLoader,
397 -- | This is set by 'DriverPipeline.runPipeline' based on where
398 -- its output is going.
399 dumpPrefix :: Maybe FilePath,
401 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
402 -- Set by @-ddump-file-prefix@
403 dumpPrefixForce :: Maybe FilePath,
405 includePaths :: [String],
406 libraryPaths :: [String],
407 frameworkPaths :: [String], -- used on darwin only
408 cmdlineFrameworks :: [String], -- ditto
409 tmpDir :: String, -- no trailing '/'
411 ghcUsagePath :: FilePath, -- Filled in by SysTools
412 ghciUsagePath :: FilePath, -- ditto
413 rtsOpts :: Maybe String,
415 hpcDir :: String, -- ^ Path to store the .mix files
417 -- options for particular phases
425 opt_windres :: [String],
426 opt_la :: [String], -- LLVM: llvm-as assembler
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_la :: (String,[Option]), -- LLVM: llvm-as assembler
444 pgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
445 pgm_lc :: (String,[Option]), -- LLVM: llc static compiler
448 depMakefile :: FilePath,
449 depIncludePkgDeps :: Bool,
450 depExcludeMods :: [ModuleName],
451 depSuffixes :: [String],
454 extraPkgConfs :: [FilePath],
455 topDir :: FilePath, -- filled in by SysTools
456 systemPackageConfig :: FilePath, -- ditto
457 -- ^ The @-package-conf@ flags given on the command line, in the order
460 packageFlags :: [PackageFlag],
461 -- ^ The @-package@ and @-hide-package@ flags from the command-line
464 -- NB. do not modify this field, it is calculated by
465 -- Packages.initPackages and Packages.updatePackages.
466 pkgDatabase :: Maybe [PackageConfig],
467 pkgState :: PackageState,
470 -- These have to be IORefs, because the defaultCleanupHandler needs to
471 -- know what to clean when an exception happens
472 filesToClean :: IORef [FilePath],
473 dirsToClean :: IORef (FiniteMap FilePath FilePath),
478 -- | Message output action: use "ErrUtils" instead of this if you can
479 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
481 haddockOptions :: Maybe String
484 wayNames :: DynFlags -> [WayName]
485 wayNames = map wayName . ways
487 -- | The target code type of the compilation (if any).
489 -- Whenever you change the target, also make sure to set 'ghcLink' to
490 -- something sensible.
492 -- 'HscNothing' can be used to avoid generating any output, however, note
495 -- * This will not run the desugaring step, thus no warnings generated in
496 -- this step will be output. In particular, this includes warnings related
497 -- to pattern matching. You can run the desugarer manually using
498 -- 'GHC.desugarModule'.
500 -- * If a program uses Template Haskell the typechecker may try to run code
501 -- from an imported module. This will fail if no code has been generated
502 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
503 -- whether this might be the case and choose to either switch to a
504 -- different target or avoid typechecking such modules. (The latter may
505 -- preferable for security reasons.)
508 = HscC -- ^ Generate C code.
509 | HscAsm -- ^ Generate assembly using the native code generator.
510 | HscLlvm -- ^ Generate assembly using the llvm code generator.
511 | HscJava -- ^ Generate Java bytecode.
512 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
513 | HscNothing -- ^ Don't generate any code. See notes above.
516 -- | Will this target result in an object file on the disk?
517 isObjectTarget :: HscTarget -> Bool
518 isObjectTarget HscC = True
519 isObjectTarget HscAsm = True
520 isObjectTarget HscLlvm = True
521 isObjectTarget _ = False
523 -- | The 'GhcMode' tells us whether we're doing multi-module
524 -- compilation (controlled via the "GHC" API) or one-shot
525 -- (single-module) compilation. This makes a difference primarily to
526 -- the "Finder": in one-shot mode we look for interface files for
527 -- imported modules, but in multi-module mode we look for source files
528 -- in order to check whether they need to be recompiled.
530 = CompManager -- ^ @\-\-make@, GHCi, etc.
531 | OneShot -- ^ @ghc -c Foo.hs@
532 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
535 instance Outputable GhcMode where
536 ppr CompManager = ptext (sLit "CompManager")
537 ppr OneShot = ptext (sLit "OneShot")
538 ppr MkDepend = ptext (sLit "MkDepend")
540 isOneShot :: GhcMode -> Bool
541 isOneShot OneShot = True
542 isOneShot _other = False
544 -- | What to do in the link step, if there is one.
546 = NoLink -- ^ Don't link at all
547 | LinkBinary -- ^ Link object code into a binary
548 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
549 -- bytecode and object code).
550 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
553 isNoLink :: GhcLink -> Bool
554 isNoLink NoLink = True
557 -- Is it worth evaluating this Bool and caching it in the DynFlags value
558 -- during initDynFlags?
559 doingTickyProfiling :: DynFlags -> Bool
560 doingTickyProfiling _ = opt_Ticky
561 -- XXX -ticky is a static flag, because it implies -debug which is also
562 -- static. If the way flags were made dynamic, we could fix this.
565 = ExposePackage String
566 | ExposePackageId String
568 | IgnorePackage String
571 defaultHscTarget :: HscTarget
572 defaultHscTarget = defaultObjectTarget
574 -- | The 'HscTarget' value corresponding to the default way to create
575 -- object files on the current platform.
576 defaultObjectTarget :: HscTarget
578 | cGhcWithNativeCodeGen == "YES" = HscAsm
583 | Wrapped (Maybe String)
587 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
588 initDynFlags :: DynFlags -> IO DynFlags
589 initDynFlags dflags = do
590 -- someday these will be dynamic flags
591 ways <- readIORef v_Ways
592 refFilesToClean <- newIORef []
593 refDirsToClean <- newIORef emptyFM
596 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
597 rtsBuildTag = mkBuildTag ways,
598 filesToClean = refFilesToClean,
599 dirsToClean = refDirsToClean
602 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
603 -- and must be fully initialized by 'GHC.newSession' first.
604 defaultDynFlags :: DynFlags
607 ghcMode = CompManager,
608 ghcLink = LinkBinary,
609 hscTarget = defaultHscTarget,
615 maxSimplIterations = 4,
616 shouldDumpSimplPhase = Nothing,
618 specConstrThreshold = Just 200,
619 specConstrCount = Just 3,
620 liberateCaseThreshold = Just 200,
621 strictnessBefore = [],
623 #ifndef OMIT_NATIVE_CODEGEN
624 targetPlatform = defaultTargetPlatform,
627 cmdlineHcIncludes = [],
631 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
635 thisPackage = mainPackageId,
638 dylibInstallName = Nothing,
642 objectSuf = phaseInputExt StopLn,
643 hcSuf = phaseInputExt HCc,
646 outputFile = Nothing,
648 dynLibLoader = SystemDependent,
649 dumpPrefix = Nothing,
650 dumpPrefixForce = Nothing,
654 cmdlineFrameworks = [],
655 tmpDir = cDEFAULT_TMPDIR,
662 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
676 pkgDatabase = Nothing,
677 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
678 ways = panic "defaultDynFlags: No ways",
679 buildTag = panic "defaultDynFlags: No buildTag",
680 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
682 -- initSysTools fills all these in
683 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
684 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
685 topDir = panic "defaultDynFlags: No topDir",
686 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
687 pgm_L = panic "defaultDynFlags: No pgm_L",
688 pgm_P = panic "defaultDynFlags: No pgm_P",
689 pgm_F = panic "defaultDynFlags: No pgm_F",
690 pgm_c = panic "defaultDynFlags: No pgm_c",
691 pgm_m = panic "defaultDynFlags: No pgm_m",
692 pgm_s = panic "defaultDynFlags: No pgm_s",
693 pgm_a = panic "defaultDynFlags: No pgm_a",
694 pgm_l = panic "defaultDynFlags: No pgm_l",
695 pgm_dll = panic "defaultDynFlags: No pgm_dll",
696 pgm_T = panic "defaultDynFlags: No pgm_T",
697 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
698 pgm_windres = panic "defaultDynFlags: No pgm_windres",
699 pgm_la = panic "defaultDynFlags: No pgm_la",
700 pgm_lo = panic "defaultDynFlags: No pgm_lo",
701 pgm_lc = panic "defaultDynFlags: No pgm_lc",
702 -- end of initSysTools values
704 depMakefile = "Makefile",
705 depIncludePkgDeps = False,
708 -- end of ghc -M values
709 filesToClean = panic "defaultDynFlags: No filesToClean",
710 dirsToClean = panic "defaultDynFlags: No dirsToClean",
711 haddockOptions = Nothing,
713 Opt_AutoLinkPackages,
714 Opt_ReadUserPackageConf,
716 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
717 -- behaviour the default, to see if anyone notices
721 Opt_MonomorphismRestriction,
732 Opt_PrintBindContents
734 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
735 -- The default -O0 options
738 log_action = \severity srcSpan style msg ->
740 SevInfo -> printErrs (msg style)
741 SevFatal -> printErrs (msg style)
744 printErrs ((mkLocMessage srcSpan msg) style)
745 -- careful (#2302): printErrs prints in UTF-8, whereas
746 -- converting to string first and using hPutStr would
747 -- just emit the low 8 bits of each unicode char.
751 Note [Verbosity levels]
752 ~~~~~~~~~~~~~~~~~~~~~~~
753 0 | print errors & warnings only
754 1 | minimal verbosity: print "compiling M ... done." for each module.
755 2 | equivalent to -dshow-passes
756 3 | equivalent to existing "ghc -v"
757 4 | "ghc -v -ddump-most"
758 5 | "ghc -v -ddump-all"
761 -- | Test whether a 'DynFlag' is set
762 dopt :: DynFlag -> DynFlags -> Bool
763 dopt f dflags = f `elem` (flags dflags)
766 dopt_set :: DynFlags -> DynFlag -> DynFlags
767 dopt_set dfs f = dfs{ flags = f : flags dfs }
769 -- | Unset a 'DynFlag'
770 dopt_unset :: DynFlags -> DynFlag -> DynFlags
771 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
773 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
774 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
775 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
776 -> [a] -- ^ Correctly ordered extracted options
777 getOpts dflags opts = reverse (opts dflags)
778 -- We add to the options from the front, so we need to reverse the list
780 -- | Gets the verbosity flag for the current verbosity level. This is fed to
781 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
782 getVerbFlag :: DynFlags -> String
784 | verbosity dflags >= 3 = "-v"
787 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
788 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
789 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
790 setPgmla, setPgmlo, setPgmlc,
791 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres, addOptla, addOptlo,
792 addOptlc, addCmdlineFramework, addHaddockOpts
793 :: String -> DynFlags -> DynFlags
794 setOutputFile, setOutputHi, setDumpPrefixForce
795 :: Maybe String -> DynFlags -> DynFlags
797 setObjectDir f d = d{ objectDir = Just f}
798 setHiDir f d = d{ hiDir = Just f}
799 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
800 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
801 -- \#included from the .hc file when compiling with -fvia-C.
802 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
803 setDylibInstallName f d = d{ dylibInstallName = Just f}
805 setObjectSuf f d = d{ objectSuf = f}
806 setHiSuf f d = d{ hiSuf = f}
807 setHcSuf f d = d{ hcSuf = f}
809 setOutputFile f d = d{ outputFile = f}
810 setOutputHi f d = d{ outputHi = f}
812 parseDynLibLoaderMode f d =
814 ("deploy", "") -> d{ dynLibLoader = Deployable }
815 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
816 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
817 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
818 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
819 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
821 setDumpPrefixForce f d = d { dumpPrefixForce = f}
823 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
824 -- Config.hs should really use Option.
825 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
827 setPgmL f d = d{ pgm_L = f}
828 setPgmF f d = d{ pgm_F = f}
829 setPgmc f d = d{ pgm_c = (f,[])}
830 setPgmm f d = d{ pgm_m = (f,[])}
831 setPgms f d = d{ pgm_s = (f,[])}
832 setPgma f d = d{ pgm_a = (f,[])}
833 setPgml f d = d{ pgm_l = (f,[])}
834 setPgmdll f d = d{ pgm_dll = (f,[])}
835 setPgmwindres f d = d{ pgm_windres = f}
836 setPgmla f d = d{ pgm_la = (f,[])}
837 setPgmlo f d = d{ pgm_lo = (f,[])}
838 setPgmlc f d = d{ pgm_lc = (f,[])}
840 addOptL f d = d{ opt_L = f : opt_L d}
841 addOptP f d = d{ opt_P = f : opt_P d}
842 addOptF f d = d{ opt_F = f : opt_F d}
843 addOptc f d = d{ opt_c = f : opt_c d}
844 addOptm f d = d{ opt_m = f : opt_m d}
845 addOpta f d = d{ opt_a = f : opt_a d}
846 addOptl f d = d{ opt_l = f : opt_l d}
847 addOptwindres f d = d{ opt_windres = f : opt_windres d}
848 addOptla f d = d{ opt_la = f : opt_la d}
849 addOptlo f d = d{ opt_lo = f : opt_lo d}
850 addOptlc f d = d{ opt_lc = f : opt_lc d}
852 setDepMakefile :: FilePath -> DynFlags -> DynFlags
853 setDepMakefile f d = d { depMakefile = deOptDep f }
855 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
856 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
858 addDepExcludeMod :: String -> DynFlags -> DynFlags
860 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
862 addDepSuffix :: FilePath -> DynFlags -> DynFlags
863 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
866 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
867 -- we need to strip the "-optdep" off of the arg
868 deOptDep :: String -> String
869 deOptDep x = case stripPrefix "-optdep" x of
873 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
875 addHaddockOpts f d = d{ haddockOptions = Just f}
877 -- -----------------------------------------------------------------------------
878 -- Command-line options
880 -- | When invoking external tools as part of the compilation pipeline, we
881 -- pass these a sequence of options on the command-line. Rather than
882 -- just using a list of Strings, we use a type that allows us to distinguish
883 -- between filepaths and 'other stuff'. The reason for this is that
884 -- this type gives us a handle on transforming filenames, and filenames only,
885 -- to whatever format they're expected to be on a particular platform.
887 = FileOption -- an entry that _contains_ filename(s) / filepaths.
888 String -- a non-filepath prefix that shouldn't be
889 -- transformed (e.g., "/out=")
890 String -- the filepath/filename portion
893 showOpt :: Option -> String
894 showOpt (FileOption pre f) = pre ++ f
895 showOpt (Option s) = s
897 -----------------------------------------------------------------------------
898 -- Setting the optimisation level
900 updOptLevel :: Int -> DynFlags -> DynFlags
901 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
903 = dfs2{ optLevel = final_n }
905 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
906 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
907 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
909 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
910 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
912 optLevelFlags :: [([Int], DynFlag)]
914 = [ ([0], Opt_IgnoreInterfacePragmas)
915 , ([0], Opt_OmitInterfacePragmas)
917 , ([1,2], Opt_IgnoreAsserts)
918 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
920 , ([1,2], Opt_DoEtaReduction)
921 , ([1,2], Opt_CaseMerge)
922 , ([1,2], Opt_Strictness)
924 , ([1,2], Opt_FullLaziness)
925 , ([1,2], Opt_Specialise)
926 , ([1,2], Opt_FloatIn)
928 , ([2], Opt_LiberateCase)
929 , ([2], Opt_SpecConstr)
931 -- , ([2], Opt_StaticArgumentTransformation)
932 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
933 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
934 -- several improvements to the heuristics, and I'm concerned that without
935 -- those changes SAT will interfere with some attempts to write "high
936 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
937 -- this year. In particular, the version in HEAD lacks the tail call
938 -- criterion, so many things that look like reasonable loops will be
939 -- turned into functions with extra (unneccesary) thunk creation.
941 , ([0,1,2], Opt_DoLambdaEtaExpansion)
942 -- This one is important for a tiresome reason:
943 -- we want to make sure that the bindings for data
944 -- constructors are eta-expanded. This is probably
945 -- a good thing anyway, but it seems fragile.
948 -- -----------------------------------------------------------------------------
949 -- Standard sets of warning options
951 standardWarnings :: [DynFlag]
953 = [ Opt_WarnWarningsDeprecations,
954 Opt_WarnDeprecatedFlags,
955 Opt_WarnUnrecognisedPragmas,
956 Opt_WarnOverlappingPatterns,
957 Opt_WarnMissingFields,
958 Opt_WarnMissingMethods,
959 Opt_WarnDuplicateExports,
960 Opt_WarnLazyUnliftedBindings,
961 Opt_WarnDodgyForeignImports,
963 Opt_WarnAlternativeLayoutRuleTransitional
966 minusWOpts :: [DynFlag]
968 = standardWarnings ++
969 [ Opt_WarnUnusedBinds,
970 Opt_WarnUnusedMatches,
971 Opt_WarnUnusedImports,
972 Opt_WarnIncompletePatterns,
973 Opt_WarnDodgyExports,
977 minusWallOpts :: [DynFlag]
980 [ Opt_WarnTypeDefaults,
981 Opt_WarnNameShadowing,
988 -- minuswRemovesOpts should be every warning option
989 minuswRemovesOpts :: [DynFlag]
992 [Opt_WarnImplicitPrelude,
993 Opt_WarnIncompletePatternsRecUpd,
994 Opt_WarnSimplePatterns,
995 Opt_WarnMonomorphism,
996 Opt_WarnUnrecognisedPragmas,
1000 -- -----------------------------------------------------------------------------
1001 -- StgToDo: abstraction of stg-to-stg passes to run.
1004 = StgDoMassageForProfiling -- should be (next to) last
1005 -- There's also setStgVarInfo, but its absolute "lastness"
1006 -- is so critical that it is hardwired in (no flag).
1009 getStgToDo :: DynFlags -> [StgToDo]
1013 stg_stats = dopt Opt_StgStats dflags
1015 todo1 = if stg_stats then [D_stg_stats] else []
1017 todo2 | WayProf `elem` wayNames dflags
1018 = StgDoMassageForProfiling : todo1
1022 -- -----------------------------------------------------------------------------
1025 allFlags :: [String]
1026 allFlags = map ('-':) $
1027 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1028 map ("fno-"++) flags ++
1029 map ("f"++) flags ++
1030 map ("X"++) supportedLanguages
1031 where ok (PrefixPred _ _) = False
1033 flags = [ name | (name, _, _) <- fFlags ]
1035 dynamic_flags :: [Flag DynP]
1037 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1038 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1039 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1040 , Flag "#include" (HasArg (addCmdlineHCInclude))
1041 (DeprecatedFullText "-#include and INCLUDE pragmas are deprecated: They no longer have any effect")
1042 , Flag "v" (OptIntSuffix setVerbosity) Supported
1044 ------- Specific phases --------------------------------------------
1045 -- need to appear before -pgmL to be parsed as LLVM flags.
1046 , Flag "pgmla" (HasArg (upd . setPgmla)) Supported
1047 , Flag "pgmlo" (HasArg (upd . setPgmlo)) Supported
1048 , Flag "pgmlc" (HasArg (upd . setPgmlc)) Supported
1050 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1051 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1052 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1053 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1054 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1055 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1056 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1057 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1058 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1059 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1061 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1062 , Flag "optla" (HasArg (upd . addOptla)) Supported
1063 , Flag "optlo" (HasArg (upd . addOptlo)) Supported
1064 , Flag "optlc" (HasArg (upd . addOptlc)) Supported
1066 , Flag "optL" (HasArg (upd . addOptL)) Supported
1067 , Flag "optP" (HasArg (upd . addOptP)) Supported
1068 , Flag "optF" (HasArg (upd . addOptF)) Supported
1069 , Flag "optc" (HasArg (upd . addOptc)) Supported
1070 , Flag "optm" (HasArg (upd . addOptm)) Supported
1071 , Flag "opta" (HasArg (upd . addOpta)) Supported
1072 , Flag "optl" (HasArg (upd . addOptl)) Supported
1073 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1076 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1079 -------- ghc -M -----------------------------------------------------
1080 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1081 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1082 (Deprecated "Use -dep-suffix instead")
1083 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1084 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1085 (Deprecated "Use -dep-makefile instead")
1086 , Flag "optdep-w" (NoArg (return ()))
1087 (Deprecated "-optdep-w doesn't do anything")
1088 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1089 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1090 (Deprecated "Use -include-pkg-deps instead")
1091 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1092 (Deprecated "Use -include-pkg-deps instead")
1093 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1094 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1095 (Deprecated "Use -exclude-module instead")
1096 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1097 (Deprecated "Use -exclude-module instead")
1099 -------- Linking ----------------------------------------------------
1100 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1102 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1104 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1106 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1108 ------- Libraries ---------------------------------------------------
1109 , Flag "L" (Prefix addLibraryPath ) Supported
1110 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1112 ------- Frameworks --------------------------------------------------
1113 -- -framework-path should really be -F ...
1114 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1115 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1117 ------- Output Redirection ------------------------------------------
1118 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1119 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1120 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1121 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1122 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1123 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1124 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1125 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1126 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1127 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1128 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1131 ------- Keeping temporary files -------------------------------------
1132 -- These can be singular (think ghc -c) or plural (think ghc --make)
1133 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1134 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1135 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1136 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1137 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1138 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1139 , Flag "keep-llvm-file" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1140 , Flag "keep-llvm-files" (NoArg (setDynFlag Opt_KeepLlvmFiles)) Supported
1141 -- This only makes sense as plural
1142 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1144 ------- Miscellaneous ----------------------------------------------
1145 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1146 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1147 , Flag "with-rtsopts" (HasArg setRtsOpts) Supported
1148 , Flag "rtsopts" (NoArg (setDynFlag Opt_RtsOptsEnabled)) Supported
1149 , Flag "no-rtsopts" (NoArg (unSetDynFlag Opt_RtsOptsEnabled)) Supported
1150 , Flag "main-is" (SepArg setMainIs ) Supported
1151 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1152 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1153 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1155 ------- recompilation checker --------------------------------------
1156 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1157 (Deprecated "Use -fno-force-recomp instead")
1158 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1159 (Deprecated "Use -fforce-recomp instead")
1161 ------ HsCpp opts ---------------------------------------------------
1162 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1163 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1165 ------- Include/Import Paths ----------------------------------------
1166 , Flag "I" (Prefix addIncludePath) Supported
1167 , Flag "i" (OptPrefix addImportPath ) Supported
1169 ------ Debugging ----------------------------------------------------
1170 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1172 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1174 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1176 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1178 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1180 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1182 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1184 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1186 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1188 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1190 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1192 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1194 , Flag "ddump-asm-regalloc-stages"
1195 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1197 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1199 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1201 , Flag "ddump-llvm" (NoArg (do { setObjTarget HscLlvm
1202 ; setDumpFlag' Opt_D_dump_llvm}))
1204 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1206 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1208 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1210 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1212 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1214 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1216 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1218 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1220 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1222 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1224 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1226 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1228 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1230 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1232 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1234 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1236 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1238 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1240 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1242 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1244 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1246 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1248 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1250 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1252 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1254 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1256 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1258 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1260 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1262 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1264 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1266 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1267 ; setVerboseCore2Core }))
1269 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1271 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1273 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1275 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1277 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1279 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1281 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1283 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1285 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1287 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1290 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1292 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1294 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1296 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1298 , Flag "dshow-passes"
1299 (NoArg (do forceRecompile
1300 setVerbosity (Just 2)))
1302 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1305 ------ Machine dependant (-m<blah>) stuff ---------------------------
1307 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1309 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1311 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1314 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1317 ------ Warning opts -------------------------------------------------
1318 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1320 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1322 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1324 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1326 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1327 (Deprecated "Use -w instead")
1328 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1331 ------ Optimisation flags ------------------------------------------
1332 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1333 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1334 (Deprecated "Use -O0 instead")
1335 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1336 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1338 -- If the number is missing, use 1
1340 , Flag "fsimplifier-phases"
1341 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1343 , Flag "fmax-simplifier-iterations"
1344 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1347 , Flag "fspec-constr-threshold"
1348 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1350 , Flag "fno-spec-constr-threshold"
1351 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1353 , Flag "fspec-constr-count"
1354 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1356 , Flag "fno-spec-constr-count"
1357 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1359 , Flag "fliberate-case-threshold"
1360 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1362 , Flag "fno-liberate-case-threshold"
1363 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1366 , Flag "frule-check"
1367 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1369 , Flag "fcontext-stack"
1370 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1373 , Flag "fstrictness-before"
1374 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1377 ------ Profiling ----------------------------------------------------
1379 -- XXX Should the -f* flags be deprecated?
1380 -- They don't seem to be documented
1381 , Flag "fauto-sccs-on-all-toplevs"
1382 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1385 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1387 , Flag "no-auto-all"
1388 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1390 , Flag "fauto-sccs-on-exported-toplevs"
1391 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1394 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1397 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1399 , Flag "fauto-sccs-on-individual-cafs"
1400 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1403 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1406 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1409 ------ DPH flags ----------------------------------------------------
1412 (NoArg (setDPHBackend DPHSeq))
1415 (NoArg (setDPHBackend DPHPar))
1418 (NoArg (setDPHBackend DPHThis))
1421 ------ Compiler flags -----------------------------------------------
1423 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1424 , Flag "fvia-c" (NoArg (setObjTarget HscC))
1425 (Deprecated "The -fvia-c flag will be removed in a future GHC release")
1426 , Flag "fvia-C" (NoArg (setObjTarget HscC))
1427 (Deprecated "The -fvia-C flag will be removed in a future GHC release")
1428 , Flag "fllvm" (NoArg (setObjTarget HscLlvm)) Supported
1430 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1431 setTarget HscNothing))
1433 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1434 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1436 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1438 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1441 ++ map (mkFlag True "f" setDynFlag ) fFlags
1442 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1443 ++ map (mkFlag True "X" setDynFlag ) xFlags
1444 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1446 package_flags :: [Flag DynP]
1448 ------- Packages ----------------------------------------------------
1449 Flag "package-conf" (HasArg extraPkgConf_) Supported
1450 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1452 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1453 , Flag "package-id" (HasArg exposePackageId) Supported
1454 , Flag "package" (HasArg exposePackage) Supported
1455 , Flag "hide-package" (HasArg hidePackage) Supported
1456 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1458 , Flag "ignore-package" (HasArg ignorePackage)
1460 , Flag "syslib" (HasArg exposePackage)
1461 (Deprecated "Use -package instead")
1464 mkFlag :: Bool -- ^ True <=> it should be turned on
1465 -> String -- ^ The flag prefix
1466 -> (DynFlag -> DynP ())
1467 -> (String, DynFlag, Bool -> Deprecated)
1469 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1470 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1472 deprecatedForLanguage :: String -> Bool -> Deprecated
1473 deprecatedForLanguage lang turn_on
1474 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1476 flag | turn_on = lang
1477 | otherwise = "No"++lang
1479 useInstead :: String -> Bool -> Deprecated
1480 useInstead flag turn_on
1481 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1483 no = if turn_on then "" else "no-"
1485 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1486 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1488 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1489 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1490 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1491 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1492 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1493 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1494 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1495 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1496 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1497 ( "warn-missing-import-lists", Opt_WarnMissingImportList, const Supported ),
1498 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1499 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1500 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1501 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1502 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1503 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1504 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1505 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1506 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1507 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1508 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1509 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1510 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1511 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1512 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1513 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1514 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1515 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1516 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1517 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1518 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, const Supported ),
1519 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1520 ( "strictness", Opt_Strictness, const Supported ),
1521 ( "specialise", Opt_Specialise, const Supported ),
1522 ( "float-in", Opt_FloatIn, const Supported ),
1523 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1524 ( "full-laziness", Opt_FullLaziness, const Supported ),
1525 ( "liberate-case", Opt_LiberateCase, const Supported ),
1526 ( "spec-constr", Opt_SpecConstr, const Supported ),
1527 ( "cse", Opt_CSE, const Supported ),
1528 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1529 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1530 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1531 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1532 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1533 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1534 ( "case-merge", Opt_CaseMerge, const Supported ),
1535 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1536 ( "method-sharing", Opt_MethodSharing, const Supported ),
1537 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1538 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1539 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1540 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1541 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1542 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1543 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1544 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1545 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1546 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1547 ( "break-on-error", Opt_BreakOnError, const Supported ),
1548 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1549 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1550 ( "run-cps", Opt_RunCPS, const Supported ),
1551 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1552 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1553 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1554 ( "vectorise", Opt_Vectorise, const Supported ),
1555 ( "regs-graph", Opt_RegsGraph, const Supported ),
1556 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1557 ( "th", Opt_TemplateHaskell,
1558 deprecatedForLanguage "TemplateHaskell" ),
1559 ( "fi", Opt_ForeignFunctionInterface,
1560 deprecatedForLanguage "ForeignFunctionInterface" ),
1561 ( "ffi", Opt_ForeignFunctionInterface,
1562 deprecatedForLanguage "ForeignFunctionInterface" ),
1563 ( "arrows", Opt_Arrows,
1564 deprecatedForLanguage "Arrows" ),
1565 ( "generics", Opt_Generics,
1566 deprecatedForLanguage "Generics" ),
1567 ( "implicit-prelude", Opt_ImplicitPrelude,
1568 deprecatedForLanguage "ImplicitPrelude" ),
1569 ( "bang-patterns", Opt_BangPatterns,
1570 deprecatedForLanguage "BangPatterns" ),
1571 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1572 deprecatedForLanguage "MonomorphismRestriction" ),
1573 ( "mono-pat-binds", Opt_MonoPatBinds,
1574 deprecatedForLanguage "MonoPatBinds" ),
1575 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1576 deprecatedForLanguage "ExtendedDefaultRules" ),
1577 ( "implicit-params", Opt_ImplicitParams,
1578 deprecatedForLanguage "ImplicitParams" ),
1579 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1580 deprecatedForLanguage "ScopedTypeVariables" ),
1582 deprecatedForLanguage "PArr" ),
1583 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1584 deprecatedForLanguage "OverlappingInstances" ),
1585 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1586 deprecatedForLanguage "UndecidableInstances" ),
1587 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1588 deprecatedForLanguage "IncoherentInstances" ),
1589 ( "gen-manifest", Opt_GenManifest, const Supported ),
1590 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1591 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1592 ( "shared-implib", Opt_SharedImplib, const Supported ),
1593 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1594 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1597 supportedLanguages :: [String]
1598 supportedLanguages = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1600 -- This may contain duplicates
1601 languageOptions :: [DynFlag]
1602 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1604 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1605 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1607 ( "CPP", Opt_Cpp, const Supported ),
1608 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1609 ( "TupleSections", Opt_TupleSections, const Supported ),
1610 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1611 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1612 ( "MagicHash", Opt_MagicHash, const Supported ),
1613 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1614 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1615 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1616 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1617 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1618 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1619 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1620 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1621 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1622 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1623 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1624 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1625 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1626 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1627 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1628 ( "RecursiveDo", Opt_RecursiveDo,
1629 deprecatedForLanguage "DoRec"),
1630 ( "DoRec", Opt_DoRec, const Supported ),
1631 ( "Arrows", Opt_Arrows, const Supported ),
1632 ( "PArr", Opt_PArr, const Supported ),
1633 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1634 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1635 ( "Generics", Opt_Generics, const Supported ),
1637 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1638 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1639 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1640 ( "RecordPuns", Opt_RecordPuns,
1641 deprecatedForLanguage "NamedFieldPuns" ),
1642 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1643 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1644 ( "GADTs", Opt_GADTs, const Supported ),
1645 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1646 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1647 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1649 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1651 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1652 -- On by default (which is not strictly H98):
1653 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1654 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1655 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1656 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, const Supported ),
1657 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1658 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1659 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1660 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1661 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1663 ( "PatternSignatures", Opt_ScopedTypeVariables,
1664 deprecatedForLanguage "ScopedTypeVariables" ),
1666 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1667 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1668 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1669 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1670 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1671 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1672 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1673 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1674 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1675 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1676 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1677 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1678 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1679 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1680 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1681 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1682 ( "PackageImports", Opt_PackageImports, const Supported ),
1683 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1686 impliedFlags :: [(DynFlag, DynFlag)]
1688 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1689 , (Opt_Rank2Types, Opt_ExplicitForAll)
1690 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1691 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1692 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1693 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1695 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1696 -- be completely rigid for GADTs
1698 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1699 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1700 -- all over the place
1702 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1703 -- Note [Scoped tyvars] in TcBinds
1704 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1706 -- Record wild-cards implies field disambiguation
1707 -- Otherwise if you write (C {..}) you may well get
1708 -- stuff like " 'a' not in scope ", which is a bit silly
1709 -- if the compiler has just filled in field 'a' of constructor 'C'
1710 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1713 glasgowExtsFlags :: [DynFlag]
1714 glasgowExtsFlags = [
1715 Opt_PrintExplicitForalls
1716 , Opt_ForeignFunctionInterface
1717 , Opt_UnliftedFFITypes
1719 , Opt_ImplicitParams
1720 , Opt_ScopedTypeVariables
1722 , Opt_TypeSynonymInstances
1723 , Opt_StandaloneDeriving
1724 , Opt_DeriveDataTypeable
1726 , Opt_DeriveFoldable
1727 , Opt_DeriveTraversable
1728 , Opt_FlexibleContexts
1729 , Opt_FlexibleInstances
1730 , Opt_ConstrainedClassMethods
1731 , Opt_MultiParamTypeClasses
1732 , Opt_FunctionalDependencies
1734 , Opt_PolymorphicComponents
1735 , Opt_ExistentialQuantification
1737 , Opt_PostfixOperators
1739 , Opt_LiberalTypeSynonyms
1743 , Opt_ParallelListComp
1744 , Opt_EmptyDataDecls
1745 , Opt_KindSignatures
1746 , Opt_GeneralizedNewtypeDeriving
1747 , Opt_TypeFamilies ]
1749 -- -----------------------------------------------------------------------------
1750 -- Parsing the dynamic flags.
1752 -- | Parse dynamic flags from a list of command line arguments. Returns the
1753 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1754 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1755 -- flags or missing arguments).
1756 parseDynamicFlags :: Monad m =>
1757 DynFlags -> [Located String]
1758 -> m (DynFlags, [Located String], [Located String])
1759 -- ^ Updated 'DynFlags', left-over arguments, and
1760 -- list of warnings.
1761 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1763 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1764 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1765 parseDynamicNoPackageFlags :: Monad m =>
1766 DynFlags -> [Located String]
1767 -> m (DynFlags, [Located String], [Located String])
1768 -- ^ Updated 'DynFlags', left-over arguments, and
1769 -- list of warnings.
1770 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1772 parseDynamicFlags_ :: Monad m =>
1773 DynFlags -> [Located String] -> Bool
1774 -> m (DynFlags, [Located String], [Located String])
1775 parseDynamicFlags_ dflags0 args pkg_flags = do
1776 -- XXX Legacy support code
1777 -- We used to accept things like
1778 -- optdep-f -optdepdepend
1779 -- optdep-f -optdep depend
1780 -- optdep -f -optdepdepend
1781 -- optdep -f -optdep depend
1782 -- but the spaces trip up proper argument handling. So get rid of them.
1783 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1784 f (x : xs) = x : f xs
1788 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1789 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1790 | otherwise = dynamic_flags
1792 let ((leftover, errs, warns), dflags1)
1793 = runCmdLine (processArgs flag_spec args') dflags0
1794 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1796 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1797 -- isn't up to the job. We know that if hscTarget == HscC, then the
1798 -- user has explicitly used -fvia-C, because -fasm is the default,
1799 -- unless there is no NCG on this platform. The latter case is
1800 -- checked when the -fPIC flag is parsed.
1802 let (pic_warns, dflags2) =
1803 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1804 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1805 dflags1{ hscTarget = HscAsm })
1808 return (dflags2, leftover, pic_warns ++ warns)
1810 type DynP = CmdLineP DynFlags
1812 upd :: (DynFlags -> DynFlags) -> DynP ()
1814 dfs <- getCmdLineState
1815 putCmdLineState $! (f dfs)
1817 --------------------------
1818 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1819 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1820 ; mapM_ setDynFlag deps }
1822 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1823 -- When you set f, set the ones it implies
1824 -- NB: use setDynFlag recursively, in case the implied flags
1825 -- implies further flags
1826 -- When you un-set f, however, we don't un-set the things it implies
1827 -- (except for -fno-glasgow-exts, which is treated specially)
1829 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1831 --------------------------
1832 setDumpFlag :: DynFlag -> OptKind DynP
1833 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
1835 setDumpFlag' :: DynFlag -> DynP ()
1836 setDumpFlag' dump_flag
1837 = do { setDynFlag dump_flag
1838 ; when want_recomp forceRecompile }
1840 -- Certain dumpy-things are really interested in what's going
1841 -- on during recompilation checking, so in those cases we
1842 -- don't want to turn it off.
1843 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1844 Opt_D_dump_hi_diffs]
1846 forceRecompile :: DynP ()
1847 -- Whenver we -ddump, force recompilation (by switching off the
1848 -- recompilation checker), else you don't see the dump! However,
1849 -- don't switch it off in --make mode, else *everything* gets
1850 -- recompiled which probably isn't what you want
1851 forceRecompile = do { dfs <- getCmdLineState
1852 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1854 force_recomp dfs = isOneShot (ghcMode dfs)
1856 setVerboseCore2Core :: DynP ()
1857 setVerboseCore2Core = do forceRecompile
1858 setDynFlag Opt_D_verbose_core2core
1859 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
1862 setDumpSimplPhases :: String -> DynP ()
1863 setDumpSimplPhases s = do forceRecompile
1864 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
1866 spec = case s of { ('=' : s') -> s'; _ -> s }
1868 setVerbosity :: Maybe Int -> DynP ()
1869 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1871 addCmdlineHCInclude :: String -> DynP ()
1872 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
1874 extraPkgConf_ :: FilePath -> DynP ()
1875 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1877 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
1879 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
1881 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
1883 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
1885 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
1887 setPackageName :: String -> DynFlags -> DynFlags
1888 setPackageName p s = s{ thisPackage = stringToPackageId p }
1890 -- If we're linking a binary, then only targets that produce object
1891 -- code are allowed (requests for other target types are ignored).
1892 setTarget :: HscTarget -> DynP ()
1893 setTarget l = upd set
1896 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
1899 -- Changes the target only if we're compiling object code. This is
1900 -- used by -fasm and -fvia-C, which switch from one to the other, but
1901 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
1902 -- can be safely used in an OPTIONS_GHC pragma.
1903 setObjTarget :: HscTarget -> DynP ()
1904 setObjTarget l = upd set
1907 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1910 setOptLevel :: Int -> DynFlags -> DynFlags
1911 setOptLevel n dflags
1912 | hscTarget dflags == HscInterpreted && n > 0
1914 -- not in IO any more, oh well:
1915 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1917 = updOptLevel n dflags
1920 -- -Odph is equivalent to
1922 -- -O2 optimise as much as possible
1923 -- -fno-method-sharing sharing specialisation defeats fusion
1925 -- -fdicts-cheap always inline dictionaries
1926 -- -fmax-simplifier-iterations20 this is necessary sometimes
1927 -- -fsimplifier-phases=3 we use an additional simplifier phase
1929 -- -fno-spec-constr-threshold run SpecConstr even for big loops
1930 -- -fno-spec-constr-count SpecConstr as much as possible
1931 -- -finline-enough-args hack to prevent excessive inlining
1933 setDPHOpt :: DynFlags -> DynFlags
1934 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
1936 , specConstrThreshold = Nothing
1937 , specConstrCount = Nothing
1939 `dopt_set` Opt_DictsCheap
1940 `dopt_unset` Opt_MethodSharing
1942 data DPHBackend = DPHPar
1945 deriving(Eq, Ord, Enum, Show)
1947 setDPHBackend :: DPHBackend -> DynP ()
1948 setDPHBackend backend
1950 upd $ \dflags -> dflags { dphBackend = backend }
1951 mapM_ exposePackage (dph_packages backend)
1953 dph_packages DPHThis = []
1954 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
1955 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
1957 dphPackage :: DynFlags -> PackageId
1958 dphPackage dflags = case dphBackend dflags of
1959 DPHPar -> dphParPackageId
1960 DPHSeq -> dphSeqPackageId
1961 DPHThis -> thisPackage dflags
1963 setMainIs :: String -> DynP ()
1965 | not (null main_fn) && isLower (head main_fn)
1966 -- The arg looked like "Foo.Bar.baz"
1967 = upd $ \d -> d{ mainFunIs = Just main_fn,
1968 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1970 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
1971 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1973 | otherwise -- The arg looked like "baz"
1974 = upd $ \d -> d{ mainFunIs = Just arg }
1976 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1978 -----------------------------------------------------------------------------
1979 -- Paths & Libraries
1981 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1983 -- -i on its own deletes the import paths
1984 addImportPath "" = upd (\s -> s{importPaths = []})
1985 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1989 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1992 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1994 addFrameworkPath p =
1995 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1997 #ifndef mingw32_TARGET_OS
1998 split_marker :: Char
1999 split_marker = ':' -- not configurable (ToDo)
2002 splitPathList :: String -> [String]
2003 splitPathList s = filter notNull (splitUp s)
2004 -- empty paths are ignored: there might be a trailing
2005 -- ':' in the initial list, for example. Empty paths can
2006 -- cause confusion when they are translated into -I options
2007 -- for passing to gcc.
2009 #ifndef mingw32_TARGET_OS
2010 splitUp xs = split split_marker xs
2012 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2014 -- That is, if "foo:bar:baz" is used, this interpreted as
2015 -- consisting of three entries, 'foo', 'bar', 'baz'.
2016 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2017 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2019 -- Notice that no attempt is made to fully replace the 'standard'
2020 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2021 -- that this will cause too much breakage for users & ':' will
2022 -- work fine even with DOS paths, if you're not insisting on being silly.
2025 splitUp (x:':':div:xs) | div `elem` dir_markers
2026 = ((x:':':div:p): splitUp rs)
2028 (p,rs) = findNextPath xs
2029 -- we used to check for existence of the path here, but that
2030 -- required the IO monad to be threaded through the command-line
2031 -- parser which is quite inconvenient. The
2032 splitUp xs = cons p (splitUp rs)
2034 (p,rs) = findNextPath xs
2039 -- will be called either when we've consumed nought or the
2040 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2041 -- finding the next split marker.
2043 case break (`elem` split_markers) xs of
2044 (p, _:ds) -> (p, ds)
2047 split_markers :: [Char]
2048 split_markers = [':', ';']
2050 dir_markers :: [Char]
2051 dir_markers = ['/', '\\']
2054 -- -----------------------------------------------------------------------------
2055 -- tmpDir, where we store temporary files.
2057 setTmpDir :: FilePath -> DynFlags -> DynFlags
2058 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2059 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2060 -- seem necessary now --SDM 7/2/2008
2062 -----------------------------------------------------------------------------
2065 setRtsOpts :: String -> DynP ()
2066 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2068 -----------------------------------------------------------------------------
2071 setOptHpcDir :: String -> DynP ()
2072 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2074 -----------------------------------------------------------------------------
2075 -- Via-C compilation stuff
2077 -- There are some options that we need to pass to gcc when compiling
2078 -- Haskell code via C, but are only supported by recent versions of
2079 -- gcc. The configure script decides which of these options we need,
2080 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2081 -- read before each via-C compilation. The advantage of having these
2082 -- in a separate file is that the file can be created at install-time
2083 -- depending on the available gcc version, and even re-generated later
2084 -- if gcc is upgraded.
2086 -- The options below are not dependent on the version of gcc, only the
2089 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2090 [String]) -- for registerised HC compilations
2091 machdepCCOpts _dflags
2092 #if alpha_TARGET_ARCH
2094 #ifdef HAVE_THREADED_RTS_SUPPORT
2098 -- For now, to suppress the gcc warning "call-clobbered
2099 -- register used for global register variable", we simply
2100 -- disable all warnings altogether using the -w flag. Oh well.
2102 #elif hppa_TARGET_ARCH
2103 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2104 -- (very nice, but too bad the HP /usr/include files don't agree.)
2105 = ( ["-D_HPUX_SOURCE"], [] )
2107 #elif m68k_TARGET_ARCH
2108 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2109 -- popping of args to routines to be explicit; if we let things
2110 -- be deferred 'til after an STGJUMP, imminent death is certain!
2112 -- -fomit-frame-pointer : *don't*
2113 -- It's better to have a6 completely tied up being a frame pointer
2114 -- rather than let GCC pick random things to do with it.
2115 -- (If we want to steal a6, then we would try to do things
2116 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2117 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2119 #elif i386_TARGET_ARCH
2120 -- -fno-defer-pop : basically the same game as for m68k
2122 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2123 -- the fp (%ebp) for our register maps.
2124 = let n_regs = stolen_x86_regs _dflags
2127 #if darwin_TARGET_OS
2128 -- By default, gcc on OS X will generate SSE
2129 -- instructions, which need things 16-byte aligned,
2130 -- but we don't 16-byte align things. Thus drop
2131 -- back to generic i686 compatibility. Trac #2983.
2133 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2134 ["-march=i686", "-m32"],
2136 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2140 "-fomit-frame-pointer",
2141 -- we want -fno-builtin, because when gcc inlines
2142 -- built-in functions like memcpy() it tends to
2143 -- run out of registers, requiring -monly-n-regs
2145 "-DSTOLEN_X86_REGS="++show n_regs ]
2148 #elif ia64_TARGET_ARCH
2149 = ( [], ["-fomit-frame-pointer", "-G0"] )
2151 #elif x86_64_TARGET_ARCH
2153 #if darwin_TARGET_OS
2158 ["-fomit-frame-pointer",
2159 "-fno-asynchronous-unwind-tables",
2160 -- the unwind tables are unnecessary for HC code,
2161 -- and get in the way of -split-objs. Another option
2162 -- would be to throw them away in the mangler, but this
2165 -- calling builtins like strlen() using the FFI can
2166 -- cause gcc to run out of regs, so use the external
2170 #elif sparc_TARGET_ARCH
2172 -- For now, to suppress the gcc warning "call-clobbered
2173 -- register used for global register variable", we simply
2174 -- disable all warnings altogether using the -w flag. Oh well.
2176 #elif powerpc_apple_darwin_TARGET
2178 -- Disable Apple's precompiling preprocessor. It's a great thing
2179 -- for "normal" programs, but it doesn't support register variable
2181 = ( [], ["-no-cpp-precomp"] )
2186 picCCOpts :: DynFlags -> [String]
2188 #if darwin_TARGET_OS
2189 -- Apple prefers to do things the other way round.
2190 -- PIC is on by default.
2191 -- -mdynamic-no-pic:
2192 -- Turn off PIC code generation.
2194 -- Don't generate "common" symbols - these are unwanted
2195 -- in dynamic libraries.
2198 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2200 = ["-mdynamic-no-pic"]
2201 #elif mingw32_TARGET_OS
2202 -- no -fPIC for Windows
2204 = ["-U __PIC__","-D__PIC__"]
2208 -- we need -fPIC for C files when we are compiling with -dynamic,
2209 -- otherwise things like stub.c files don't get compiled
2210 -- correctly. They need to reference data in the Haskell
2211 -- objects, but can't without -fPIC. See
2212 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2213 | opt_PIC || not opt_Static
2214 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2219 -- -----------------------------------------------------------------------------
2223 can_split = cSplitObjs == "YES"
2225 -- -----------------------------------------------------------------------------
2228 data Printable = String String
2229 | FromDynFlags (DynFlags -> String)
2231 compilerInfo :: [(String, Printable)]
2232 compilerInfo = [("Project name", String cProjectName),
2233 ("Project version", String cProjectVersion),
2234 ("Booter version", String cBooterVersion),
2235 ("Stage", String cStage),
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)