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
115 | Opt_D_dump_inlinings
116 | Opt_D_dump_rule_firings
117 | Opt_D_dump_occur_anal
121 | Opt_D_dump_simpl_iterations
122 | Opt_D_dump_simpl_phases
131 | Opt_D_dump_worker_wrapper
132 | Opt_D_dump_rn_trace
133 | Opt_D_dump_rn_stats
135 | Opt_D_dump_simpl_stats
136 | Opt_D_dump_tc_trace
137 | Opt_D_dump_if_trace
144 | Opt_D_verbose_core2core
145 | Opt_D_verbose_stg2stg
147 | Opt_D_dump_hi_diffs
148 | Opt_D_dump_minimal_imports
149 | Opt_D_dump_mod_cycles
150 | Opt_D_dump_view_pattern_commoning
151 | Opt_D_faststring_stats
152 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
153 | Opt_D_no_debug_output
159 | Opt_WarnIsError -- -Werror; makes warnings fatal
160 | Opt_WarnDuplicateExports
162 | Opt_WarnImplicitPrelude
163 | Opt_WarnIncompletePatterns
164 | Opt_WarnIncompletePatternsRecUpd
165 | Opt_WarnMissingFields
166 | Opt_WarnMissingMethods
167 | Opt_WarnMissingSigs
168 | Opt_WarnNameShadowing
169 | Opt_WarnOverlappingPatterns
170 | Opt_WarnSimplePatterns
171 | Opt_WarnTypeDefaults
172 | Opt_WarnMonomorphism
173 | Opt_WarnUnusedBinds
174 | Opt_WarnUnusedImports
175 | Opt_WarnUnusedMatches
176 | Opt_WarnWarningsDeprecations
177 | Opt_WarnDeprecatedFlags
178 | Opt_WarnDodgyExports
179 | Opt_WarnDodgyImports
182 | Opt_WarnUnrecognisedPragmas
183 | Opt_WarnDodgyForeignImports
184 | Opt_WarnLazyUnliftedBindings
185 | Opt_WarnUnusedDoBind
186 | Opt_WarnWrongDoBind
190 | Opt_OverlappingInstances
191 | Opt_UndecidableInstances
192 | Opt_IncoherentInstances
193 | Opt_MonomorphismRestriction
196 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
197 | Opt_ForeignFunctionInterface
198 | Opt_UnliftedFFITypes
199 | Opt_GHCForeignImportPrim
200 | Opt_PArr -- Syntactic support for parallel arrays
201 | Opt_Arrows -- Arrow-notation syntax
202 | Opt_TemplateHaskell
205 | Opt_Generics -- "Derivable type classes"
206 | Opt_ImplicitPrelude
207 | Opt_ScopedTypeVariables
211 | Opt_OverloadedStrings
212 | Opt_DisambiguateRecordFields
213 | Opt_RecordWildCards
220 | Opt_StandaloneDeriving
221 | Opt_DeriveDataTypeable
223 | Opt_DeriveTraversable
226 | Opt_TypeSynonymInstances
227 | Opt_FlexibleContexts
228 | Opt_FlexibleInstances
229 | Opt_ConstrainedClassMethods
230 | Opt_MultiParamTypeClasses
231 | Opt_FunctionalDependencies
233 | Opt_PolymorphicComponents
234 | Opt_ExistentialQuantification
238 | Opt_ParallelListComp
239 | Opt_TransformListComp
240 | Opt_GeneralizedNewtypeDeriving
243 | Opt_PostfixOperators
246 | Opt_LiberalTypeSynonyms
249 | Opt_ImpredicativeTypes
252 | Opt_NewQualifiedOperators
254 | Opt_AlternativeLayoutRule
256 | Opt_PrintExplicitForalls
263 | Opt_StaticArgumentTransformation
267 | Opt_DoLambdaEtaExpansion
271 | Opt_UnboxStrictFields
274 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
276 | Opt_RegsGraph -- do graph coloring register allocation
277 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
280 | Opt_IgnoreInterfacePragmas
281 | Opt_OmitInterfacePragmas
282 | Opt_ExposeAllUnfoldings
285 | Opt_AutoSccsOnAllToplevs
286 | Opt_AutoSccsOnExportedToplevs
287 | Opt_AutoSccsOnIndividualCafs
295 | Opt_ExcessPrecision
296 | Opt_EagerBlackHoling
297 | Opt_ReadUserPackageConf
301 | Opt_HideAllPackages
302 | Opt_PrintBindResult
306 | Opt_BreakOnException
308 | Opt_PrintEvldWithShow
309 | Opt_PrintBindContents
312 | Opt_EmitExternalCore
314 | Opt_BuildingCabalPackage
320 | Opt_ConvertToZipCfgAndBack
321 | Opt_AutoLinkPackages
322 | Opt_ImplicitImportQualified
331 | Opt_KeepRawTokenStream
335 -- | Contains not only a collection of 'DynFlag's but also a plethora of
336 -- information relating to the compilation of a single file or GHC session
337 data DynFlags = DynFlags {
340 hscTarget :: HscTarget,
341 hscOutName :: String, -- ^ Name of the output file
342 extCoreName :: String, -- ^ Name of the .hcr output file
343 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
344 optLevel :: Int, -- ^ Optimisation level
345 simplPhases :: Int, -- ^ Number of simplifier phases
346 maxSimplIterations :: Int, -- ^ Max simplifier iterations
347 shouldDumpSimplPhase :: Maybe String,
348 ruleCheck :: Maybe String,
349 strictnessBefore :: [Int], -- ^ Additional demand analysis
351 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
352 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
353 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
355 #ifndef OMIT_NATIVE_CODEGEN
356 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
358 stolen_x86_regs :: Int,
359 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
360 importPaths :: [FilePath],
362 mainFunIs :: Maybe String,
363 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
365 dphBackend :: DPHBackend,
367 thisPackage :: PackageId, -- ^ name of package currently being compiled
370 ways :: [Way], -- ^ Way flags from the command line
371 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
372 rtsBuildTag :: String, -- ^ The RTS \"way\"
374 -- For object splitting
375 splitInfo :: Maybe (String,Int),
378 objectDir :: Maybe String,
379 dylibInstallName :: Maybe String,
380 hiDir :: Maybe String,
381 stubDir :: Maybe String,
387 outputFile :: Maybe String,
388 outputHi :: Maybe String,
389 dynLibLoader :: DynLibLoader,
391 -- | This is set by 'DriverPipeline.runPipeline' based on where
392 -- its output is going.
393 dumpPrefix :: Maybe FilePath,
395 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
396 -- Set by @-ddump-file-prefix@
397 dumpPrefixForce :: Maybe FilePath,
399 includePaths :: [String],
400 libraryPaths :: [String],
401 frameworkPaths :: [String], -- used on darwin only
402 cmdlineFrameworks :: [String], -- ditto
403 tmpDir :: String, -- no trailing '/'
405 ghcUsagePath :: FilePath, -- Filled in by SysTools
406 ghciUsagePath :: FilePath, -- ditto
408 hpcDir :: String, -- ^ Path to store the .mix files
410 -- options for particular phases
418 opt_windres :: [String],
420 -- commands for particular phases
422 pgm_P :: (String,[Option]),
424 pgm_c :: (String,[Option]),
425 pgm_m :: (String,[Option]),
426 pgm_s :: (String,[Option]),
427 pgm_a :: (String,[Option]),
428 pgm_l :: (String,[Option]),
429 pgm_dll :: (String,[Option]),
431 pgm_sysman :: String,
432 pgm_windres :: String,
435 depMakefile :: FilePath,
436 depIncludePkgDeps :: Bool,
437 depExcludeMods :: [ModuleName],
438 depSuffixes :: [String],
441 extraPkgConfs :: [FilePath],
442 topDir :: FilePath, -- filled in by SysTools
443 systemPackageConfig :: FilePath, -- ditto
444 -- ^ The @-package-conf@ flags given on the command line, in the order
447 packageFlags :: [PackageFlag],
448 -- ^ The @-package@ and @-hide-package@ flags from the command-line
451 -- NB. do not modify this field, it is calculated by
452 -- Packages.initPackages and Packages.updatePackages.
453 pkgDatabase :: Maybe [PackageConfig],
454 pkgState :: PackageState,
457 -- These have to be IORefs, because the defaultCleanupHandler needs to
458 -- know what to clean when an exception happens
459 filesToClean :: IORef [FilePath],
460 dirsToClean :: IORef (FiniteMap FilePath FilePath),
465 -- | Message output action: use "ErrUtils" instead of this if you can
466 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
468 haddockOptions :: Maybe String
471 wayNames :: DynFlags -> [WayName]
472 wayNames = map wayName . ways
474 -- | The target code type of the compilation (if any).
476 -- Whenever you change the target, also make sure to set 'ghcLink' to
477 -- something sensible.
479 -- 'HscNothing' can be used to avoid generating any output, however, note
482 -- * This will not run the desugaring step, thus no warnings generated in
483 -- this step will be output. In particular, this includes warnings related
484 -- to pattern matching. You can run the desugarer manually using
485 -- 'GHC.desugarModule'.
487 -- * If a program uses Template Haskell the typechecker may try to run code
488 -- from an imported module. This will fail if no code has been generated
489 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
490 -- whether this might be the case and choose to either switch to a
491 -- different target or avoid typechecking such modules. (The latter may
492 -- preferable for security reasons.)
495 = HscC -- ^ Generate C code.
496 | HscAsm -- ^ Generate assembly using the native code generator.
497 | HscJava -- ^ Generate Java bytecode.
498 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
499 | HscNothing -- ^ Don't generate any code. See notes above.
502 -- | Will this target result in an object file on the disk?
503 isObjectTarget :: HscTarget -> Bool
504 isObjectTarget HscC = True
505 isObjectTarget HscAsm = True
506 isObjectTarget _ = False
508 -- | The 'GhcMode' tells us whether we're doing multi-module
509 -- compilation (controlled via the "GHC" API) or one-shot
510 -- (single-module) compilation. This makes a difference primarily to
511 -- the "Finder": in one-shot mode we look for interface files for
512 -- imported modules, but in multi-module mode we look for source files
513 -- in order to check whether they need to be recompiled.
515 = CompManager -- ^ @\-\-make@, GHCi, etc.
516 | OneShot -- ^ @ghc -c Foo.hs@
517 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
520 instance Outputable GhcMode where
521 ppr CompManager = ptext (sLit "CompManager")
522 ppr OneShot = ptext (sLit "OneShot")
523 ppr MkDepend = ptext (sLit "MkDepend")
525 isOneShot :: GhcMode -> Bool
526 isOneShot OneShot = True
527 isOneShot _other = False
529 -- | What to do in the link step, if there is one.
531 = NoLink -- ^ Don't link at all
532 | LinkBinary -- ^ Link object code into a binary
533 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
534 -- bytecode and object code).
535 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
538 isNoLink :: GhcLink -> Bool
539 isNoLink NoLink = True
542 -- Is it worth evaluating this Bool and caching it in the DynFlags value
543 -- during initDynFlags?
544 doingTickyProfiling :: DynFlags -> Bool
545 doingTickyProfiling _ = opt_Ticky
546 -- XXX -ticky is a static flag, because it implies -debug which is also
547 -- static. If the way flags were made dynamic, we could fix this.
550 = ExposePackage String
551 | ExposePackageId String
553 | IgnorePackage String
556 defaultHscTarget :: HscTarget
557 defaultHscTarget = defaultObjectTarget
559 -- | The 'HscTarget' value corresponding to the default way to create
560 -- object files on the current platform.
561 defaultObjectTarget :: HscTarget
563 | cGhcWithNativeCodeGen == "YES" = HscAsm
568 | Wrapped (Maybe String)
572 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
573 initDynFlags :: DynFlags -> IO DynFlags
574 initDynFlags dflags = do
575 -- someday these will be dynamic flags
576 ways <- readIORef v_Ways
577 refFilesToClean <- newIORef []
578 refDirsToClean <- newIORef emptyFM
581 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
582 rtsBuildTag = mkBuildTag ways,
583 filesToClean = refFilesToClean,
584 dirsToClean = refDirsToClean
587 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
588 -- and must be fully initialized by 'GHC.newSession' first.
589 defaultDynFlags :: DynFlags
592 ghcMode = CompManager,
593 ghcLink = LinkBinary,
594 hscTarget = defaultHscTarget,
600 maxSimplIterations = 4,
601 shouldDumpSimplPhase = Nothing,
603 specConstrThreshold = Just 200,
604 specConstrCount = Just 3,
605 liberateCaseThreshold = Just 200,
606 strictnessBefore = [],
608 #ifndef OMIT_NATIVE_CODEGEN
609 targetPlatform = defaultTargetPlatform,
612 cmdlineHcIncludes = [],
616 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
620 thisPackage = mainPackageId,
623 dylibInstallName = Nothing,
627 objectSuf = phaseInputExt StopLn,
628 hcSuf = phaseInputExt HCc,
631 outputFile = Nothing,
633 dynLibLoader = SystemDependent,
634 dumpPrefix = Nothing,
635 dumpPrefixForce = Nothing,
639 cmdlineFrameworks = [],
640 tmpDir = cDEFAULT_TMPDIR,
646 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
657 pkgDatabase = Nothing,
658 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
659 ways = panic "defaultDynFlags: No ways",
660 buildTag = panic "defaultDynFlags: No buildTag",
661 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
663 -- initSysTools fills all these in
664 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
665 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
666 topDir = panic "defaultDynFlags: No topDir",
667 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
668 pgm_L = panic "defaultDynFlags: No pgm_L",
669 pgm_P = panic "defaultDynFlags: No pgm_P",
670 pgm_F = panic "defaultDynFlags: No pgm_F",
671 pgm_c = panic "defaultDynFlags: No pgm_c",
672 pgm_m = panic "defaultDynFlags: No pgm_m",
673 pgm_s = panic "defaultDynFlags: No pgm_s",
674 pgm_a = panic "defaultDynFlags: No pgm_a",
675 pgm_l = panic "defaultDynFlags: No pgm_l",
676 pgm_dll = panic "defaultDynFlags: No pgm_dll",
677 pgm_T = panic "defaultDynFlags: No pgm_T",
678 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
679 pgm_windres = panic "defaultDynFlags: No pgm_windres",
680 -- end of initSysTools values
682 depMakefile = "Makefile",
683 depIncludePkgDeps = False,
686 -- end of ghc -M values
687 filesToClean = panic "defaultDynFlags: No filesToClean",
688 dirsToClean = panic "defaultDynFlags: No dirsToClean",
689 haddockOptions = Nothing,
691 Opt_AutoLinkPackages,
692 Opt_ReadUserPackageConf,
694 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
695 -- behaviour the default, to see if anyone notices
699 Opt_MonomorphismRestriction,
710 Opt_PrintBindContents
712 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
713 -- The default -O0 options
716 log_action = \severity srcSpan style msg ->
718 SevInfo -> printErrs (msg style)
719 SevFatal -> printErrs (msg style)
722 printErrs ((mkLocMessage srcSpan msg) style)
723 -- careful (#2302): printErrs prints in UTF-8, whereas
724 -- converting to string first and using hPutStr would
725 -- just emit the low 8 bits of each unicode char.
729 Note [Verbosity levels]
730 ~~~~~~~~~~~~~~~~~~~~~~~
731 0 | print errors & warnings only
732 1 | minimal verbosity: print "compiling M ... done." for each module.
733 2 | equivalent to -dshow-passes
734 3 | equivalent to existing "ghc -v"
735 4 | "ghc -v -ddump-most"
736 5 | "ghc -v -ddump-all"
739 -- | Test whether a 'DynFlag' is set
740 dopt :: DynFlag -> DynFlags -> Bool
741 dopt f dflags = f `elem` (flags dflags)
744 dopt_set :: DynFlags -> DynFlag -> DynFlags
745 dopt_set dfs f = dfs{ flags = f : flags dfs }
747 -- | Unset a 'DynFlag'
748 dopt_unset :: DynFlags -> DynFlag -> DynFlags
749 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
751 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
752 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
753 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
754 -> [a] -- ^ Correctly ordered extracted options
755 getOpts dflags opts = reverse (opts dflags)
756 -- We add to the options from the front, so we need to reverse the list
758 -- | Gets the verbosity flag for the current verbosity level. This is fed to
759 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
760 getVerbFlag :: DynFlags -> String
762 | verbosity dflags >= 3 = "-v"
765 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
766 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
767 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
768 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
769 addCmdlineFramework, addHaddockOpts
770 :: String -> DynFlags -> DynFlags
771 setOutputFile, setOutputHi, setDumpPrefixForce
772 :: Maybe String -> DynFlags -> DynFlags
774 setObjectDir f d = d{ objectDir = Just f}
775 setHiDir f d = d{ hiDir = Just f}
776 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
777 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
778 -- \#included from the .hc file when compiling with -fvia-C.
779 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
780 setDylibInstallName f d = d{ dylibInstallName = Just f}
782 setObjectSuf f d = d{ objectSuf = f}
783 setHiSuf f d = d{ hiSuf = f}
784 setHcSuf f d = d{ hcSuf = f}
786 setOutputFile f d = d{ outputFile = f}
787 setOutputHi f d = d{ outputHi = f}
789 parseDynLibLoaderMode f d =
791 ("deploy", "") -> d{ dynLibLoader = Deployable }
792 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
793 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
794 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
795 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
796 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
798 setDumpPrefixForce f d = d { dumpPrefixForce = f}
800 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
801 -- Config.hs should really use Option.
802 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
804 setPgmL f d = d{ pgm_L = f}
805 setPgmF f d = d{ pgm_F = f}
806 setPgmc f d = d{ pgm_c = (f,[])}
807 setPgmm f d = d{ pgm_m = (f,[])}
808 setPgms f d = d{ pgm_s = (f,[])}
809 setPgma f d = d{ pgm_a = (f,[])}
810 setPgml f d = d{ pgm_l = (f,[])}
811 setPgmdll f d = d{ pgm_dll = (f,[])}
812 setPgmwindres f d = d{ pgm_windres = f}
814 addOptL f d = d{ opt_L = f : opt_L d}
815 addOptP f d = d{ opt_P = f : opt_P d}
816 addOptF f d = d{ opt_F = f : opt_F d}
817 addOptc f d = d{ opt_c = f : opt_c d}
818 addOptm f d = d{ opt_m = f : opt_m d}
819 addOpta f d = d{ opt_a = f : opt_a d}
820 addOptl f d = d{ opt_l = f : opt_l d}
821 addOptwindres f d = d{ opt_windres = f : opt_windres d}
823 setDepMakefile :: FilePath -> DynFlags -> DynFlags
824 setDepMakefile f d = d { depMakefile = deOptDep f }
826 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
827 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
829 addDepExcludeMod :: String -> DynFlags -> DynFlags
831 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
833 addDepSuffix :: FilePath -> DynFlags -> DynFlags
834 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
837 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
838 -- we need to strip the "-optdep" off of the arg
839 deOptDep :: String -> String
840 deOptDep x = case stripPrefix "-optdep" x of
844 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
846 addHaddockOpts f d = d{ haddockOptions = Just f}
848 -- -----------------------------------------------------------------------------
849 -- Command-line options
851 -- | When invoking external tools as part of the compilation pipeline, we
852 -- pass these a sequence of options on the command-line. Rather than
853 -- just using a list of Strings, we use a type that allows us to distinguish
854 -- between filepaths and 'other stuff'. The reason for this is that
855 -- this type gives us a handle on transforming filenames, and filenames only,
856 -- to whatever format they're expected to be on a particular platform.
858 = FileOption -- an entry that _contains_ filename(s) / filepaths.
859 String -- a non-filepath prefix that shouldn't be
860 -- transformed (e.g., "/out=")
861 String -- the filepath/filename portion
864 showOpt :: Option -> String
865 showOpt (FileOption pre f) = pre ++ f
866 showOpt (Option s) = s
868 -----------------------------------------------------------------------------
869 -- Setting the optimisation level
871 updOptLevel :: Int -> DynFlags -> DynFlags
872 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
874 = dfs2{ optLevel = final_n }
876 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
877 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
878 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
880 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
881 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
883 optLevelFlags :: [([Int], DynFlag)]
885 = [ ([0], Opt_IgnoreInterfacePragmas)
886 , ([0], Opt_OmitInterfacePragmas)
888 , ([1,2], Opt_IgnoreAsserts)
889 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
891 , ([1,2], Opt_DoEtaReduction)
892 , ([1,2], Opt_CaseMerge)
893 , ([1,2], Opt_Strictness)
895 , ([1,2], Opt_FullLaziness)
896 , ([1,2], Opt_Specialise)
897 , ([1,2], Opt_FloatIn)
899 , ([2], Opt_LiberateCase)
900 , ([2], Opt_SpecConstr)
902 -- , ([2], Opt_StaticArgumentTransformation)
903 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
904 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
905 -- several improvements to the heuristics, and I'm concerned that without
906 -- those changes SAT will interfere with some attempts to write "high
907 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
908 -- this year. In particular, the version in HEAD lacks the tail call
909 -- criterion, so many things that look like reasonable loops will be
910 -- turned into functions with extra (unneccesary) thunk creation.
912 , ([0,1,2], Opt_DoLambdaEtaExpansion)
913 -- This one is important for a tiresome reason:
914 -- we want to make sure that the bindings for data
915 -- constructors are eta-expanded. This is probably
916 -- a good thing anyway, but it seems fragile.
919 -- -----------------------------------------------------------------------------
920 -- Standard sets of warning options
922 standardWarnings :: [DynFlag]
924 = [ Opt_WarnWarningsDeprecations,
925 Opt_WarnDeprecatedFlags,
926 Opt_WarnUnrecognisedPragmas,
927 Opt_WarnOverlappingPatterns,
928 Opt_WarnMissingFields,
929 Opt_WarnMissingMethods,
930 Opt_WarnDuplicateExports,
931 Opt_WarnLazyUnliftedBindings,
932 Opt_WarnDodgyForeignImports,
936 minusWOpts :: [DynFlag]
938 = standardWarnings ++
939 [ Opt_WarnUnusedBinds,
940 Opt_WarnUnusedMatches,
941 Opt_WarnUnusedImports,
942 Opt_WarnIncompletePatterns,
943 Opt_WarnDodgyExports,
947 minusWallOpts :: [DynFlag]
950 [ Opt_WarnTypeDefaults,
951 Opt_WarnNameShadowing,
958 -- minuswRemovesOpts should be every warning option
959 minuswRemovesOpts :: [DynFlag]
962 [Opt_WarnImplicitPrelude,
963 Opt_WarnIncompletePatternsRecUpd,
964 Opt_WarnSimplePatterns,
965 Opt_WarnMonomorphism,
966 Opt_WarnUnrecognisedPragmas,
970 -- -----------------------------------------------------------------------------
971 -- StgToDo: abstraction of stg-to-stg passes to run.
974 = StgDoMassageForProfiling -- should be (next to) last
975 -- There's also setStgVarInfo, but its absolute "lastness"
976 -- is so critical that it is hardwired in (no flag).
979 getStgToDo :: DynFlags -> [StgToDo]
983 stg_stats = dopt Opt_StgStats dflags
985 todo1 = if stg_stats then [D_stg_stats] else []
987 todo2 | WayProf `elem` wayNames dflags
988 = StgDoMassageForProfiling : todo1
992 -- -----------------------------------------------------------------------------
996 allFlags = map ('-':) $
997 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
998 map ("fno-"++) flags ++
1000 map ("X"++) supportedLanguages ++
1001 map ("XNo"++) supportedLanguages
1002 where ok (PrefixPred _ _) = False
1004 flags = [ name | (name, _, _) <- fFlags ]
1006 dynamic_flags :: [Flag DynP]
1008 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1009 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1010 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1011 , Flag "#include" (HasArg (addCmdlineHCInclude))
1012 (Deprecated "No longer has any effect")
1013 , Flag "v" (OptIntSuffix setVerbosity) Supported
1015 ------- Specific phases --------------------------------------------
1016 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1017 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1018 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1019 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1020 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1021 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1022 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1023 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1024 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1025 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1027 , Flag "optL" (HasArg (upd . addOptL)) Supported
1028 , Flag "optP" (HasArg (upd . addOptP)) Supported
1029 , Flag "optF" (HasArg (upd . addOptF)) Supported
1030 , Flag "optc" (HasArg (upd . addOptc)) Supported
1031 , Flag "optm" (HasArg (upd . addOptm)) Supported
1032 , Flag "opta" (HasArg (upd . addOpta)) Supported
1033 , Flag "optl" (HasArg (upd . addOptl)) Supported
1034 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1037 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1040 -------- ghc -M -----------------------------------------------------
1041 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1042 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1043 (Deprecated "Use -dep-suffix instead")
1044 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1045 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1046 (Deprecated "Use -dep-makefile instead")
1047 , Flag "optdep-w" (NoArg (return ()))
1048 (Deprecated "-optdep-w doesn't do anything")
1049 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1050 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1051 (Deprecated "Use -include-pkg-deps instead")
1052 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1053 (Deprecated "Use -include-pkg-deps instead")
1054 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1055 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1056 (Deprecated "Use -exclude-module instead")
1057 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1058 (Deprecated "Use -exclude-module instead")
1060 -------- Linking ----------------------------------------------------
1061 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1063 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1064 (Deprecated "Use -c instead")
1065 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1067 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1069 , Flag "dylib-install-name" (HasArg (upd . setDylibInstallName)) Supported
1071 ------- Libraries ---------------------------------------------------
1072 , Flag "L" (Prefix addLibraryPath ) Supported
1073 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1075 ------- Frameworks --------------------------------------------------
1076 -- -framework-path should really be -F ...
1077 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1078 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1080 ------- Output Redirection ------------------------------------------
1081 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1082 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1083 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1084 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1085 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1086 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1087 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1088 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1089 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1090 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1091 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1094 ------- Keeping temporary files -------------------------------------
1095 -- These can be singular (think ghc -c) or plural (think ghc --make)
1096 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1097 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1098 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1099 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1100 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1101 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1102 -- This only makes sense as plural
1103 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1105 ------- Miscellaneous ----------------------------------------------
1106 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1107 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1108 , Flag "main-is" (SepArg setMainIs ) Supported
1109 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1110 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1111 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1113 ------- recompilation checker --------------------------------------
1114 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1115 (Deprecated "Use -fno-force-recomp instead")
1116 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1117 (Deprecated "Use -fforce-recomp instead")
1119 ------ HsCpp opts ---------------------------------------------------
1120 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1121 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1123 ------- Include/Import Paths ----------------------------------------
1124 , Flag "I" (Prefix addIncludePath) Supported
1125 , Flag "i" (OptPrefix addImportPath ) Supported
1127 ------ Debugging ----------------------------------------------------
1128 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1130 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1132 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1134 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1136 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1138 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1140 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1142 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1144 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1146 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1148 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1150 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1152 , Flag "ddump-asm-regalloc-stages"
1153 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1155 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1157 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1159 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1161 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1163 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1165 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1167 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1169 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1171 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1173 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1175 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1177 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1179 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1181 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1183 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1185 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1187 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1189 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1191 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1193 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1195 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1197 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1199 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1201 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1203 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1205 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1207 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1209 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1211 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1213 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1215 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1217 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1219 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1221 , Flag "dverbose-core2core" (NoArg (do { setVerbosity (Just 2)
1222 ; setVerboseCore2Core }))
1224 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1226 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1228 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1230 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1232 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1234 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1236 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1238 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1240 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1242 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1245 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1247 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1249 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1251 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1253 , Flag "dshow-passes"
1254 (NoArg (do forceRecompile
1255 setVerbosity (Just 2)))
1257 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1260 ------ Machine dependant (-m<blah>) stuff ---------------------------
1262 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1264 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1266 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1269 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1272 ------ Warning opts -------------------------------------------------
1273 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1275 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1277 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1279 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1281 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1282 (Deprecated "Use -w instead")
1283 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1286 ------ Optimisation flags ------------------------------------------
1287 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1288 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1289 (Deprecated "Use -O0 instead")
1290 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1291 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1293 -- If the number is missing, use 1
1295 , Flag "fsimplifier-phases"
1296 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1298 , Flag "fmax-simplifier-iterations"
1299 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1302 , Flag "fspec-constr-threshold"
1303 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1305 , Flag "fno-spec-constr-threshold"
1306 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1308 , Flag "fspec-constr-count"
1309 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1311 , Flag "fno-spec-constr-count"
1312 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1314 , Flag "fliberate-case-threshold"
1315 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1317 , Flag "fno-liberate-case-threshold"
1318 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1321 , Flag "frule-check"
1322 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1324 , Flag "fcontext-stack"
1325 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1328 , Flag "fstrictness-before"
1329 (IntSuffix (\n -> upd (\dfs -> dfs{ strictnessBefore = n : strictnessBefore dfs })))
1332 ------ Profiling ----------------------------------------------------
1334 -- XXX Should the -f* flags be deprecated?
1335 -- They don't seem to be documented
1336 , Flag "fauto-sccs-on-all-toplevs"
1337 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1340 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1342 , Flag "no-auto-all"
1343 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1345 , Flag "fauto-sccs-on-exported-toplevs"
1346 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1349 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1352 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1354 , Flag "fauto-sccs-on-individual-cafs"
1355 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1358 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1361 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1364 ------ DPH flags ----------------------------------------------------
1367 (NoArg (setDPHBackend DPHSeq))
1370 (NoArg (setDPHBackend DPHPar))
1373 (NoArg (setDPHBackend DPHThis))
1376 ------ Compiler flags -----------------------------------------------
1378 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1379 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1380 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1382 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1383 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1384 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1386 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1388 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1391 ++ map (mkFlag True "f" setDynFlag ) fFlags
1392 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1393 ++ map (mkFlag True "X" setDynFlag ) xFlags
1394 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1396 package_flags :: [Flag DynP]
1398 ------- Packages ----------------------------------------------------
1399 Flag "package-conf" (HasArg extraPkgConf_) Supported
1400 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1402 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1403 , Flag "package-id" (HasArg exposePackageId) Supported
1404 , Flag "package" (HasArg exposePackage) Supported
1405 , Flag "hide-package" (HasArg hidePackage) Supported
1406 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1408 , Flag "ignore-package" (HasArg ignorePackage)
1410 , Flag "syslib" (HasArg exposePackage)
1411 (Deprecated "Use -package instead")
1414 mkFlag :: Bool -- ^ True <=> it should be turned on
1415 -> String -- ^ The flag prefix
1416 -> (DynFlag -> DynP ())
1417 -> (String, DynFlag, Bool -> Deprecated)
1419 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1420 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1422 deprecatedForLanguage :: String -> Bool -> Deprecated
1423 deprecatedForLanguage lang turn_on
1424 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1426 flag | turn_on = lang
1427 | otherwise = "No"++lang
1429 useInstead :: String -> Bool -> Deprecated
1430 useInstead flag turn_on
1431 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1433 no = if turn_on then "" else "no-"
1435 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1436 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1438 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1439 ( "warn-dodgy-exports", Opt_WarnDodgyExports, const Supported ),
1440 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1441 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1442 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1443 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1444 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1445 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1446 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1447 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1448 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1449 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1450 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1451 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1452 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1453 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1454 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1455 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1456 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1457 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1458 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1459 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1460 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1461 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1462 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1463 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1464 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1465 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1466 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1467 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1468 ( "strictness", Opt_Strictness, const Supported ),
1469 ( "specialise", Opt_Specialise, const Supported ),
1470 ( "float-in", Opt_FloatIn, const Supported ),
1471 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1472 ( "full-laziness", Opt_FullLaziness, const Supported ),
1473 ( "liberate-case", Opt_LiberateCase, const Supported ),
1474 ( "spec-constr", Opt_SpecConstr, const Supported ),
1475 ( "cse", Opt_CSE, const Supported ),
1476 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1477 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1478 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, const Supported ),
1479 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1480 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1481 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1482 ( "case-merge", Opt_CaseMerge, const Supported ),
1483 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1484 ( "method-sharing", Opt_MethodSharing, const Supported ),
1485 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1486 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1487 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1488 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1489 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1490 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1491 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1492 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1493 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1494 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1495 ( "break-on-error", Opt_BreakOnError, const Supported ),
1496 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1497 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1498 ( "run-cps", Opt_RunCPS, const Supported ),
1499 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1500 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1501 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1502 ( "vectorise", Opt_Vectorise, const Supported ),
1503 ( "regs-graph", Opt_RegsGraph, const Supported ),
1504 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1505 ( "th", Opt_TemplateHaskell,
1506 deprecatedForLanguage "TemplateHaskell" ),
1507 ( "fi", Opt_ForeignFunctionInterface,
1508 deprecatedForLanguage "ForeignFunctionInterface" ),
1509 ( "ffi", Opt_ForeignFunctionInterface,
1510 deprecatedForLanguage "ForeignFunctionInterface" ),
1511 ( "arrows", Opt_Arrows,
1512 deprecatedForLanguage "Arrows" ),
1513 ( "generics", Opt_Generics,
1514 deprecatedForLanguage "Generics" ),
1515 ( "implicit-prelude", Opt_ImplicitPrelude,
1516 deprecatedForLanguage "ImplicitPrelude" ),
1517 ( "bang-patterns", Opt_BangPatterns,
1518 deprecatedForLanguage "BangPatterns" ),
1519 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1520 deprecatedForLanguage "MonomorphismRestriction" ),
1521 ( "mono-pat-binds", Opt_MonoPatBinds,
1522 deprecatedForLanguage "MonoPatBinds" ),
1523 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1524 deprecatedForLanguage "ExtendedDefaultRules" ),
1525 ( "implicit-params", Opt_ImplicitParams,
1526 deprecatedForLanguage "ImplicitParams" ),
1527 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1528 deprecatedForLanguage "ScopedTypeVariables" ),
1530 deprecatedForLanguage "PArr" ),
1531 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1532 deprecatedForLanguage "OverlappingInstances" ),
1533 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1534 deprecatedForLanguage "UndecidableInstances" ),
1535 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1536 deprecatedForLanguage "IncoherentInstances" ),
1537 ( "gen-manifest", Opt_GenManifest, const Supported ),
1538 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1539 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1540 ( "shared-implib", Opt_SharedImplib, const Supported ),
1541 ( "building-cabal-package", Opt_BuildingCabalPackage, const Supported ),
1542 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1545 supportedLanguages :: [String]
1546 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1548 -- This may contain duplicates
1549 languageOptions :: [DynFlag]
1550 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1552 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1553 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1555 ( "CPP", Opt_Cpp, const Supported ),
1556 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1557 ( "TupleSections", Opt_TupleSections, const Supported ),
1558 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1559 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1560 ( "MagicHash", Opt_MagicHash, const Supported ),
1561 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1562 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1563 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1564 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1565 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1566 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1567 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1568 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1569 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1570 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1571 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1572 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1573 ( "ImpredicativeTypes", Opt_ImpredicativeTypes,
1574 const $ Deprecated "impredicative polymorphism will be simplified or removed in GHC 6.14" ),
1575 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1576 ( "RecursiveDo", Opt_RecursiveDo,
1577 deprecatedForLanguage "DoRec"),
1578 ( "DoRec", Opt_DoRec, const Supported ),
1579 ( "Arrows", Opt_Arrows, const Supported ),
1580 ( "PArr", Opt_PArr, const Supported ),
1581 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1582 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1583 ( "Generics", Opt_Generics, const Supported ),
1585 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1586 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1587 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1588 ( "RecordPuns", Opt_RecordPuns,
1589 deprecatedForLanguage "NamedFieldPuns" ),
1590 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1591 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1592 ( "GADTs", Opt_GADTs, const Supported ),
1593 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1594 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1595 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1597 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1599 ( "NPlusKPatterns", Opt_NPlusKPatterns, const Supported ),
1600 -- On by default (which is not strictly H98):
1601 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1602 ( "ExplicitForAll", Opt_ExplicitForAll, const Supported ),
1603 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, const Supported ),
1604 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1605 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1606 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1607 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1608 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1610 ( "PatternSignatures", Opt_ScopedTypeVariables,
1611 deprecatedForLanguage "ScopedTypeVariables" ),
1613 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1614 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1615 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1616 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1617 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1618 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1619 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1620 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1621 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1622 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1623 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1624 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1625 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1626 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1627 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1628 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1629 ( "PackageImports", Opt_PackageImports, const Supported ),
1630 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1633 impliedFlags :: [(DynFlag, DynFlag)]
1635 = [ (Opt_RankNTypes, Opt_ExplicitForAll)
1636 , (Opt_Rank2Types, Opt_ExplicitForAll)
1637 , (Opt_ScopedTypeVariables, Opt_ExplicitForAll)
1638 , (Opt_LiberalTypeSynonyms, Opt_ExplicitForAll)
1639 , (Opt_ExistentialQuantification, Opt_ExplicitForAll)
1640 , (Opt_PolymorphicComponents, Opt_ExplicitForAll)
1642 , (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1643 -- be completely rigid for GADTs
1645 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1646 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1647 -- all over the place
1649 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1650 -- Note [Scoped tyvars] in TcBinds
1651 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1653 -- Record wild-cards implies field disambiguation
1654 -- Otherwise if you write (C {..}) you may well get
1655 -- stuff like " 'a' not in scope ", which is a bit silly
1656 -- if the compiler has just filled in field 'a' of constructor 'C'
1657 , (Opt_RecordWildCards, Opt_DisambiguateRecordFields)
1660 glasgowExtsFlags :: [DynFlag]
1661 glasgowExtsFlags = [
1662 Opt_PrintExplicitForalls
1663 , Opt_ForeignFunctionInterface
1664 , Opt_UnliftedFFITypes
1666 , Opt_ImplicitParams
1667 , Opt_ScopedTypeVariables
1669 , Opt_TypeSynonymInstances
1670 , Opt_StandaloneDeriving
1671 , Opt_DeriveDataTypeable
1673 , Opt_DeriveFoldable
1674 , Opt_DeriveTraversable
1675 , Opt_FlexibleContexts
1676 , Opt_FlexibleInstances
1677 , Opt_ConstrainedClassMethods
1678 , Opt_MultiParamTypeClasses
1679 , Opt_FunctionalDependencies
1681 , Opt_PolymorphicComponents
1682 , Opt_ExistentialQuantification
1684 , Opt_PostfixOperators
1686 , Opt_LiberalTypeSynonyms
1690 , Opt_ParallelListComp
1691 , Opt_EmptyDataDecls
1692 , Opt_KindSignatures
1693 , Opt_GeneralizedNewtypeDeriving
1694 , Opt_TypeFamilies ]
1696 -- -----------------------------------------------------------------------------
1697 -- Parsing the dynamic flags.
1699 -- | Parse dynamic flags from a list of command line arguments. Returns the
1700 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1701 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1702 -- flags or missing arguments).
1703 parseDynamicFlags :: Monad m =>
1704 DynFlags -> [Located String]
1705 -> m (DynFlags, [Located String], [Located String])
1706 -- ^ Updated 'DynFlags', left-over arguments, and
1707 -- list of warnings.
1708 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1710 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1711 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1712 parseDynamicNoPackageFlags :: Monad m =>
1713 DynFlags -> [Located String]
1714 -> m (DynFlags, [Located String], [Located String])
1715 -- ^ Updated 'DynFlags', left-over arguments, and
1716 -- list of warnings.
1717 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1719 parseDynamicFlags_ :: Monad m =>
1720 DynFlags -> [Located String] -> Bool
1721 -> m (DynFlags, [Located String], [Located String])
1722 parseDynamicFlags_ dflags0 args pkg_flags = do
1723 -- XXX Legacy support code
1724 -- We used to accept things like
1725 -- optdep-f -optdepdepend
1726 -- optdep-f -optdep depend
1727 -- optdep -f -optdepdepend
1728 -- optdep -f -optdep depend
1729 -- but the spaces trip up proper argument handling. So get rid of them.
1730 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1731 f (x : xs) = x : f xs
1735 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1736 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1737 | otherwise = dynamic_flags
1739 let ((leftover, errs, warns), dflags1)
1740 = runCmdLine (processArgs flag_spec args') dflags0
1741 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1743 -- Cannot use -fPIC with registerised -fvia-C, because the mangler
1744 -- isn't up to the job. We know that if hscTarget == HscC, then the
1745 -- user has explicitly used -fvia-C, because -fasm is the default,
1746 -- unless there is no NCG on this platform. The latter case is
1747 -- checked when the -fPIC flag is parsed.
1749 let (pic_warns, dflags2) =
1750 if opt_PIC && hscTarget dflags1 == HscC && cGhcUnregisterised == "NO"
1751 then ([L noSrcSpan $ "Warning: -fvia-C is incompatible with -fPIC; ignoring -fvia-C"],
1752 dflags1{ hscTarget = HscAsm })
1755 return (dflags2, leftover, pic_warns ++ warns)
1757 type DynP = CmdLineP DynFlags
1759 upd :: (DynFlags -> DynFlags) -> DynP ()
1761 dfs <- getCmdLineState
1762 putCmdLineState $! (f dfs)
1764 --------------------------
1765 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1766 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1767 ; mapM_ setDynFlag deps }
1769 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1770 -- When you set f, set the ones it implies
1771 -- NB: use setDynFlag recursively, in case the implied flags
1772 -- implies further flags
1773 -- When you un-set f, however, we don't un-set the things it implies
1774 -- (except for -fno-glasgow-exts, which is treated specially)
1776 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1778 --------------------------
1779 setDumpFlag :: DynFlag -> OptKind DynP
1780 setDumpFlag dump_flag
1781 = NoArg (do { setDynFlag dump_flag
1782 ; when want_recomp forceRecompile })
1784 -- Certain dumpy-things are really interested in what's going
1785 -- on during recompilation checking, so in those cases we
1786 -- don't want to turn it off.
1787 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1788 Opt_D_dump_hi_diffs]
1790 forceRecompile :: DynP ()
1791 -- Whenver we -ddump, force recompilation (by switching off the
1792 -- recompilation checker), else you don't see the dump! However,
1793 -- don't switch it off in --make mode, else *everything* gets
1794 -- recompiled which probably isn't what you want
1795 forceRecompile = do { dfs <- getCmdLineState
1796 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1798 force_recomp dfs = isOneShot (ghcMode dfs)
1800 setVerboseCore2Core :: DynP ()
1801 setVerboseCore2Core = do forceRecompile
1802 setDynFlag Opt_D_verbose_core2core
1803 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
1806 setDumpSimplPhases :: String -> DynP ()
1807 setDumpSimplPhases s = do forceRecompile
1808 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
1810 spec = case s of { ('=' : s') -> s'; _ -> s }
1812 setVerbosity :: Maybe Int -> DynP ()
1813 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1815 addCmdlineHCInclude :: String -> DynP ()
1816 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
1818 extraPkgConf_ :: FilePath -> DynP ()
1819 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1821 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
1823 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
1825 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
1827 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
1829 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
1831 setPackageName :: String -> DynFlags -> DynFlags
1832 setPackageName p s = s{ thisPackage = stringToPackageId p }
1834 -- If we're linking a binary, then only targets that produce object
1835 -- code are allowed (requests for other target types are ignored).
1836 setTarget :: HscTarget -> DynP ()
1837 setTarget l = upd set
1840 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
1843 -- Changes the target only if we're compiling object code. This is
1844 -- used by -fasm and -fvia-C, which switch from one to the other, but
1845 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
1846 -- can be safely used in an OPTIONS_GHC pragma.
1847 setObjTarget :: HscTarget -> DynP ()
1848 setObjTarget l = upd set
1851 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1854 setOptLevel :: Int -> DynFlags -> DynFlags
1855 setOptLevel n dflags
1856 | hscTarget dflags == HscInterpreted && n > 0
1858 -- not in IO any more, oh well:
1859 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1861 = updOptLevel n dflags
1864 -- -Odph is equivalent to
1866 -- -O2 optimise as much as possible
1867 -- -fno-method-sharing sharing specialisation defeats fusion
1869 -- -fdicts-cheap always inline dictionaries
1870 -- -fmax-simplifier-iterations20 this is necessary sometimes
1871 -- -fsimplifier-phases=3 we use an additional simplifier phase
1873 -- -fno-spec-constr-threshold run SpecConstr even for big loops
1874 -- -fno-spec-constr-count SpecConstr as much as possible
1875 -- -finline-enough-args hack to prevent excessive inlining
1877 setDPHOpt :: DynFlags -> DynFlags
1878 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
1880 , specConstrThreshold = Nothing
1881 , specConstrCount = Nothing
1883 `dopt_set` Opt_DictsCheap
1884 `dopt_unset` Opt_MethodSharing
1886 data DPHBackend = DPHPar
1889 deriving(Eq, Ord, Enum, Show)
1891 setDPHBackend :: DPHBackend -> DynP ()
1892 setDPHBackend backend
1894 upd $ \dflags -> dflags { dphBackend = backend }
1895 mapM_ exposePackage (dph_packages backend)
1897 dph_packages DPHThis = []
1898 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
1899 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
1901 dphPackage :: DynFlags -> PackageId
1902 dphPackage dflags = case dphBackend dflags of
1903 DPHPar -> dphParPackageId
1904 DPHSeq -> dphSeqPackageId
1905 DPHThis -> thisPackage dflags
1907 setMainIs :: String -> DynP ()
1909 | not (null main_fn) && isLower (head main_fn)
1910 -- The arg looked like "Foo.Bar.baz"
1911 = upd $ \d -> d{ mainFunIs = Just main_fn,
1912 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1914 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
1915 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1917 | otherwise -- The arg looked like "baz"
1918 = upd $ \d -> d{ mainFunIs = Just arg }
1920 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1922 -----------------------------------------------------------------------------
1923 -- Paths & Libraries
1925 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1927 -- -i on its own deletes the import paths
1928 addImportPath "" = upd (\s -> s{importPaths = []})
1929 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1933 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1936 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1938 addFrameworkPath p =
1939 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1941 #ifndef mingw32_TARGET_OS
1942 split_marker :: Char
1943 split_marker = ':' -- not configurable (ToDo)
1946 splitPathList :: String -> [String]
1947 splitPathList s = filter notNull (splitUp s)
1948 -- empty paths are ignored: there might be a trailing
1949 -- ':' in the initial list, for example. Empty paths can
1950 -- cause confusion when they are translated into -I options
1951 -- for passing to gcc.
1953 #ifndef mingw32_TARGET_OS
1954 splitUp xs = split split_marker xs
1956 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
1958 -- That is, if "foo:bar:baz" is used, this interpreted as
1959 -- consisting of three entries, 'foo', 'bar', 'baz'.
1960 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
1961 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
1963 -- Notice that no attempt is made to fully replace the 'standard'
1964 -- split marker ':' with the Windows / DOS one, ';'. The reason being
1965 -- that this will cause too much breakage for users & ':' will
1966 -- work fine even with DOS paths, if you're not insisting on being silly.
1969 splitUp (x:':':div:xs) | div `elem` dir_markers
1970 = ((x:':':div:p): splitUp rs)
1972 (p,rs) = findNextPath xs
1973 -- we used to check for existence of the path here, but that
1974 -- required the IO monad to be threaded through the command-line
1975 -- parser which is quite inconvenient. The
1976 splitUp xs = cons p (splitUp rs)
1978 (p,rs) = findNextPath xs
1983 -- will be called either when we've consumed nought or the
1984 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
1985 -- finding the next split marker.
1987 case break (`elem` split_markers) xs of
1988 (p, _:ds) -> (p, ds)
1991 split_markers :: [Char]
1992 split_markers = [':', ';']
1994 dir_markers :: [Char]
1995 dir_markers = ['/', '\\']
1998 -- -----------------------------------------------------------------------------
1999 -- tmpDir, where we store temporary files.
2001 setTmpDir :: FilePath -> DynFlags -> DynFlags
2002 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2003 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2004 -- seem necessary now --SDM 7/2/2008
2006 -----------------------------------------------------------------------------
2009 setOptHpcDir :: String -> DynP ()
2010 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2012 -----------------------------------------------------------------------------
2013 -- Via-C compilation stuff
2015 -- There are some options that we need to pass to gcc when compiling
2016 -- Haskell code via C, but are only supported by recent versions of
2017 -- gcc. The configure script decides which of these options we need,
2018 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2019 -- read before each via-C compilation. The advantage of having these
2020 -- in a separate file is that the file can be created at install-time
2021 -- depending on the available gcc version, and even re-generated later
2022 -- if gcc is upgraded.
2024 -- The options below are not dependent on the version of gcc, only the
2027 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2028 [String]) -- for registerised HC compilations
2029 machdepCCOpts _dflags
2030 #if alpha_TARGET_ARCH
2032 #ifdef HAVE_THREADED_RTS_SUPPORT
2036 -- For now, to suppress the gcc warning "call-clobbered
2037 -- register used for global register variable", we simply
2038 -- disable all warnings altogether using the -w flag. Oh well.
2040 #elif hppa_TARGET_ARCH
2041 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2042 -- (very nice, but too bad the HP /usr/include files don't agree.)
2043 = ( ["-D_HPUX_SOURCE"], [] )
2045 #elif m68k_TARGET_ARCH
2046 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2047 -- popping of args to routines to be explicit; if we let things
2048 -- be deferred 'til after an STGJUMP, imminent death is certain!
2050 -- -fomit-frame-pointer : *don't*
2051 -- It's better to have a6 completely tied up being a frame pointer
2052 -- rather than let GCC pick random things to do with it.
2053 -- (If we want to steal a6, then we would try to do things
2054 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2055 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2057 #elif i386_TARGET_ARCH
2058 -- -fno-defer-pop : basically the same game as for m68k
2060 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2061 -- the fp (%ebp) for our register maps.
2062 = let n_regs = stolen_x86_regs _dflags
2065 #if darwin_TARGET_OS
2066 -- By default, gcc on OS X will generate SSE
2067 -- instructions, which need things 16-byte aligned,
2068 -- but we don't 16-byte align things. Thus drop
2069 -- back to generic i686 compatibility. Trac #2983.
2071 -- Since Snow Leopard (10.6), gcc defaults to x86_64.
2072 ["-march=i686", "-m32"],
2074 [ if opt_Static then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2078 "-fomit-frame-pointer",
2079 -- we want -fno-builtin, because when gcc inlines
2080 -- built-in functions like memcpy() it tends to
2081 -- run out of registers, requiring -monly-n-regs
2083 "-DSTOLEN_X86_REGS="++show n_regs ]
2086 #elif ia64_TARGET_ARCH
2087 = ( [], ["-fomit-frame-pointer", "-G0"] )
2089 #elif x86_64_TARGET_ARCH
2091 #if darwin_TARGET_OS
2096 ["-fomit-frame-pointer",
2097 "-fno-asynchronous-unwind-tables",
2098 -- the unwind tables are unnecessary for HC code,
2099 -- and get in the way of -split-objs. Another option
2100 -- would be to throw them away in the mangler, but this
2103 -- calling builtins like strlen() using the FFI can
2104 -- cause gcc to run out of regs, so use the external
2108 #elif sparc_TARGET_ARCH
2110 -- For now, to suppress the gcc warning "call-clobbered
2111 -- register used for global register variable", we simply
2112 -- disable all warnings altogether using the -w flag. Oh well.
2114 #elif powerpc_apple_darwin_TARGET
2116 -- Disable Apple's precompiling preprocessor. It's a great thing
2117 -- for "normal" programs, but it doesn't support register variable
2119 = ( [], ["-no-cpp-precomp"] )
2124 picCCOpts :: DynFlags -> [String]
2126 #if darwin_TARGET_OS
2127 -- Apple prefers to do things the other way round.
2128 -- PIC is on by default.
2129 -- -mdynamic-no-pic:
2130 -- Turn off PIC code generation.
2132 -- Don't generate "common" symbols - these are unwanted
2133 -- in dynamic libraries.
2136 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2138 = ["-mdynamic-no-pic"]
2139 #elif mingw32_TARGET_OS
2140 -- no -fPIC for Windows
2142 = ["-U __PIC__","-D__PIC__"]
2146 | opt_PIC || not opt_Static
2147 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2152 -- -----------------------------------------------------------------------------
2156 can_split = cSplitObjs == "YES"
2158 -- -----------------------------------------------------------------------------
2161 data Printable = String String
2162 | FromDynFlags (DynFlags -> String)
2164 compilerInfo :: [(String, Printable)]
2165 compilerInfo = [("Project name", String cProjectName),
2166 ("Project version", String cProjectVersion),
2167 ("Booter version", String cBooterVersion),
2168 ("Stage", String cStage),
2169 ("Have interpreter", String cGhcWithInterpreter),
2170 ("Object splitting", String cSplitObjs),
2171 ("Have native code generator", String cGhcWithNativeCodeGen),
2172 ("Support SMP", String cGhcWithSMP),
2173 ("Unregisterised", String cGhcUnregisterised),
2174 ("Tables next to code", String cGhcEnableTablesNextToCode),
2175 ("Win32 DLLs", String cEnableWin32DLLs),
2176 ("RTS ways", String cGhcRTSWays),
2177 ("Leading underscore", String cLeadingUnderscore),
2178 ("Debug on", String (show debugIsOn)),
2179 ("LibDir", FromDynFlags topDir)