6 -- (c) The University of Glasgow 2005
9 -- Most flags are dynamic flags, which means they can change from
10 -- compilation to compilation using @OPTIONS_GHC@ pragmas, and in a
11 -- multi-session GHC each session can be using different dynamic
12 -- flags. Dynamic flags can also be set at the prompt in GHCi.
14 -- * Dynamic flags and associated configuration types
17 HscTarget(..), isObjectTarget, defaultObjectTarget,
18 GhcMode(..), isOneShot,
19 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
43 supportedLanguages, languageOptions,
45 -- ** DynFlag C compiler options
46 machdepCCOpts, picCCOpts,
48 -- * Configuration of the core-to-core passes
55 -- * Configuration of the stg-to-stg passes
59 -- * Compiler configuration suitable for display to the user
63 #include "HsVersions.h"
67 import PrelNames ( mAIN, main_RDR_Unqual )
68 import RdrName ( RdrName, mkRdrUnqual )
69 import OccName ( mkVarOccFS )
70 #ifdef i386_TARGET_ARCH
71 import StaticFlags ( opt_Static )
73 import StaticFlags ( opt_PIC, WayName(..), v_Ways, v_Build_tag,
75 import {-# SOURCE #-} Packages (PackageState)
76 import DriverPhases ( Phase(..), phaseInputExt )
79 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
81 import UniqFM ( UniqFM )
83 import Maybes ( orElse )
87 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
89 import Data.IORef ( readIORef )
90 import Control.Monad ( when )
93 import System.FilePath
94 import System.IO ( stderr, hPutChar )
96 -- -----------------------------------------------------------------------------
99 -- | Enumerates the simple on-or-off dynamic flags
105 | Opt_D_dump_cmmz_pretty
109 | Opt_D_dump_asm_native
110 | Opt_D_dump_asm_liveness
111 | Opt_D_dump_asm_coalesce
112 | Opt_D_dump_asm_regalloc
113 | Opt_D_dump_asm_regalloc_stages
114 | Opt_D_dump_asm_conflicts
115 | Opt_D_dump_asm_stats
121 | Opt_D_dump_inlinings
122 | Opt_D_dump_rule_firings
123 | Opt_D_dump_occur_anal
127 | Opt_D_dump_simpl_iterations
128 | Opt_D_dump_simpl_phases
137 | Opt_D_dump_worker_wrapper
138 | Opt_D_dump_rn_trace
139 | Opt_D_dump_rn_stats
141 | Opt_D_dump_simpl_stats
142 | Opt_D_dump_tc_trace
143 | Opt_D_dump_if_trace
149 | Opt_D_verbose_core2core
150 | Opt_D_verbose_stg2stg
152 | Opt_D_dump_hi_diffs
153 | Opt_D_dump_minimal_imports
154 | Opt_D_dump_mod_cycles
155 | Opt_D_dump_view_pattern_commoning
156 | Opt_D_faststring_stats
157 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
158 | Opt_D_no_debug_output
164 | Opt_WarnIsError -- -Werror; makes warnings fatal
165 | Opt_WarnDuplicateExports
167 | Opt_WarnImplicitPrelude
168 | Opt_WarnIncompletePatterns
169 | Opt_WarnIncompletePatternsRecUpd
170 | Opt_WarnMissingFields
171 | Opt_WarnMissingMethods
172 | Opt_WarnMissingSigs
173 | Opt_WarnNameShadowing
174 | Opt_WarnOverlappingPatterns
175 | Opt_WarnSimplePatterns
176 | Opt_WarnTypeDefaults
177 | Opt_WarnMonomorphism
178 | Opt_WarnUnusedBinds
179 | Opt_WarnUnusedImports
180 | Opt_WarnUnusedMatches
181 | Opt_WarnWarningsDeprecations
182 | Opt_WarnDeprecatedFlags
183 | Opt_WarnDodgyImports
186 | Opt_WarnUnrecognisedPragmas
187 | Opt_WarnDodgyForeignImports
190 | Opt_OverlappingInstances
191 | Opt_UndecidableInstances
192 | Opt_IncoherentInstances
193 | Opt_MonomorphismRestriction
195 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
196 | Opt_ForeignFunctionInterface
197 | Opt_UnliftedFFITypes
198 | Opt_PArr -- Syntactic support for parallel arrays
199 | Opt_Arrows -- Arrow-notation syntax
200 | Opt_TemplateHaskell
203 | Opt_Generics -- "Derivable type classes"
204 | Opt_ImplicitPrelude
205 | Opt_ScopedTypeVariables
209 | Opt_OverloadedStrings
210 | Opt_DisambiguateRecordFields
211 | Opt_RecordWildCards
216 | Opt_StandaloneDeriving
217 | Opt_DeriveDataTypeable
218 | Opt_TypeSynonymInstances
219 | Opt_FlexibleContexts
220 | Opt_FlexibleInstances
221 | Opt_ConstrainedClassMethods
222 | Opt_MultiParamTypeClasses
223 | Opt_FunctionalDependencies
225 | Opt_PolymorphicComponents
226 | Opt_ExistentialQuantification
230 | Opt_ParallelListComp
231 | Opt_TransformListComp
232 | Opt_GeneralizedNewtypeDeriving
234 | Opt_PostfixOperators
236 | Opt_LiberalTypeSynonyms
239 | Opt_ImpredicativeTypes
243 | Opt_PrintExplicitForalls
248 | Opt_StaticArgumentTransformation
252 | Opt_IgnoreInterfacePragmas
253 | Opt_OmitInterfacePragmas
254 | Opt_DoLambdaEtaExpansion
258 | Opt_UnboxStrictFields
261 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
263 | Opt_RegsGraph -- do graph coloring register allocation
264 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
272 | Opt_ExcessPrecision
273 | Opt_ReadUserPackageConf
277 | Opt_HideAllPackages
278 | Opt_PrintBindResult
282 | Opt_BreakOnException
284 | Opt_PrintEvldWithShow
285 | Opt_PrintBindContents
289 | Opt_ConvertToZipCfgAndBack
290 | Opt_AutoLinkPackages
291 | Opt_ImplicitImportQualified
302 -- | Contains not only a collection of 'DynFlag's but also a plethora of
303 -- information relating to the compilation of a single file or GHC session
304 data DynFlags = DynFlags {
307 coreToDo :: Maybe [CoreToDo], -- reserved for -Ofile
308 stgToDo :: Maybe [StgToDo], -- similarly
309 hscTarget :: HscTarget,
310 hscOutName :: String, -- ^ Name of the output file
311 extCoreName :: String, -- ^ Name of the .hcr output file
312 verbosity :: Int, -- ^ Verbosity level: see "DynFlags#verbosity_levels"
313 optLevel :: Int, -- ^ Optimisation level
314 simplPhases :: Int, -- ^ Number of simplifier phases
315 maxSimplIterations :: Int, -- ^ Max simplifier iterations
316 shouldDumpSimplPhase :: SimplifierMode -> Bool,
317 ruleCheck :: Maybe String,
319 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
320 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
321 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
323 stolen_x86_regs :: Int,
324 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
325 importPaths :: [FilePath],
327 mainFunIs :: Maybe String,
328 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
330 dphBackend :: DPHBackend,
332 thisPackage :: PackageId, -- ^ name of package currently being compiled
335 wayNames :: [WayName], -- ^ Way flags from the command line
336 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
337 rtsBuildTag :: String, -- ^ The RTS \"way\"
340 objectDir :: Maybe String,
341 hiDir :: Maybe String,
342 stubDir :: Maybe String,
348 outputFile :: Maybe String,
349 outputHi :: Maybe String,
350 dynLibLoader :: DynLibLoader,
352 -- | This is set by 'DriverPipeline.runPipeline' based on where
353 -- its output is going.
354 dumpPrefix :: Maybe FilePath,
356 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
357 -- Set by @-ddump-file-prefix@
358 dumpPrefixForce :: Maybe FilePath,
360 includePaths :: [String],
361 libraryPaths :: [String],
362 frameworkPaths :: [String], -- used on darwin only
363 cmdlineFrameworks :: [String], -- ditto
364 tmpDir :: String, -- no trailing '/'
366 ghcUsagePath :: FilePath, -- Filled in by SysTools
367 ghciUsagePath :: FilePath, -- ditto
369 hpcDir :: String, -- ^ Path to store the .mix files
371 -- options for particular phases
379 opt_windres :: [String],
381 -- commands for particular phases
383 pgm_P :: (String,[Option]),
385 pgm_c :: (String,[Option]),
386 pgm_m :: (String,[Option]),
387 pgm_s :: (String,[Option]),
388 pgm_a :: (String,[Option]),
389 pgm_l :: (String,[Option]),
390 pgm_dll :: (String,[Option]),
392 pgm_sysman :: String,
393 pgm_windres :: String,
396 depMakefile :: FilePath,
397 depIncludePkgDeps :: Bool,
398 depExcludeMods :: [ModuleName],
399 depSuffixes :: [String],
403 extraPkgConfs :: [FilePath],
404 topDir :: FilePath, -- filled in by SysTools
405 systemPackageConfig :: FilePath, -- ditto
406 -- ^ The @-package-conf@ flags given on the command line, in the order
409 packageFlags :: [PackageFlag],
410 -- ^ The @-package@ and @-hide-package@ flags from the command-line
413 -- NB. do not modify this field, it is calculated by
414 -- Packages.initPackages and Packages.updatePackages.
415 pkgDatabase :: Maybe (UniqFM PackageConfig),
416 pkgState :: PackageState,
421 -- | Message output action: use "ErrUtils" instead of this if you can
422 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
424 haddockOptions :: Maybe String
435 -- | Will this target result in an object file on the disk?
436 isObjectTarget :: HscTarget -> Bool
437 isObjectTarget HscC = True
438 isObjectTarget HscAsm = True
439 isObjectTarget _ = False
441 -- | The 'GhcMode' tells us whether we're doing multi-module
442 -- compilation (controlled via the "GHC" API) or one-shot
443 -- (single-module) compilation. This makes a difference primarily to
444 -- the "Finder": in one-shot mode we look for interface files for
445 -- imported modules, but in multi-module mode we look for source files
446 -- in order to check whether they need to be recompiled.
448 = CompManager -- ^ @\-\-make@, GHCi, etc.
449 | OneShot -- ^ @ghc -c Foo.hs@
450 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
453 instance Outputable GhcMode where
454 ppr CompManager = ptext (sLit "CompManager")
455 ppr OneShot = ptext (sLit "OneShot")
456 ppr MkDepend = ptext (sLit "MkDepend")
458 isOneShot :: GhcMode -> Bool
459 isOneShot OneShot = True
460 isOneShot _other = False
462 -- | What to do in the link step, if there is one.
464 = NoLink -- ^ Don't link at all
465 | LinkBinary -- ^ Link object code into a binary
466 | LinkInMemory -- ^ Use the in-memory dynamic linker
467 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
470 isNoLink :: GhcLink -> Bool
471 isNoLink NoLink = True
475 = ExposePackage String
477 | IgnorePackage String
480 defaultHscTarget :: HscTarget
481 defaultHscTarget = defaultObjectTarget
483 -- | The 'HscTarget' value corresponding to the default way to create
484 -- object files on the current platform.
485 defaultObjectTarget :: HscTarget
487 | cGhcWithNativeCodeGen == "YES" = HscAsm
492 | Wrapped (Maybe String)
496 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
497 initDynFlags :: DynFlags -> IO DynFlags
498 initDynFlags dflags = do
499 -- someday these will be dynamic flags
500 ways <- readIORef v_Ways
501 build_tag <- readIORef v_Build_tag
502 rts_build_tag <- readIORef v_RTS_Build_tag
505 buildTag = build_tag,
506 rtsBuildTag = rts_build_tag
509 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
510 -- and must be fully initialized by 'GHC.newSession' first.
511 defaultDynFlags :: DynFlags
514 ghcMode = CompManager,
515 ghcLink = LinkBinary,
518 hscTarget = defaultHscTarget,
524 maxSimplIterations = 4,
525 shouldDumpSimplPhase = const False,
527 specConstrThreshold = Just 200,
528 specConstrCount = Just 3,
529 liberateCaseThreshold = Just 200,
531 cmdlineHcIncludes = [],
535 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
539 thisPackage = mainPackageId,
545 objectSuf = phaseInputExt StopLn,
546 hcSuf = phaseInputExt HCc,
549 outputFile = Nothing,
551 dynLibLoader = Deployable,
552 dumpPrefix = Nothing,
553 dumpPrefixForce = Nothing,
557 cmdlineFrameworks = [],
558 tmpDir = cDEFAULT_TMPDIR,
575 pkgDatabase = Nothing,
576 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
577 wayNames = panic "defaultDynFlags: No wayNames",
578 buildTag = panic "defaultDynFlags: No buildTag",
579 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
580 -- initSysTools fills all these in
581 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
582 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
583 topDir = panic "defaultDynFlags: No topDir",
584 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
585 pgm_L = panic "defaultDynFlags: No pgm_L",
586 pgm_P = panic "defaultDynFlags: No pgm_P",
587 pgm_F = panic "defaultDynFlags: No pgm_F",
588 pgm_c = panic "defaultDynFlags: No pgm_c",
589 pgm_m = panic "defaultDynFlags: No pgm_m",
590 pgm_s = panic "defaultDynFlags: No pgm_s",
591 pgm_a = panic "defaultDynFlags: No pgm_a",
592 pgm_l = panic "defaultDynFlags: No pgm_l",
593 pgm_dll = panic "defaultDynFlags: No pgm_dll",
594 pgm_T = panic "defaultDynFlags: No pgm_T",
595 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
596 pgm_windres = panic "defaultDynFlags: No pgm_windres",
597 -- end of initSysTools values
599 depMakefile = "Makefile",
600 depIncludePkgDeps = False,
604 -- end of ghc -M values
605 haddockOptions = Nothing,
607 Opt_AutoLinkPackages,
608 Opt_ReadUserPackageConf,
610 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
611 -- behaviour the default, to see if anyone notices
615 Opt_MonomorphismRestriction,
623 Opt_PrintBindContents
625 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
626 -- The default -O0 options
629 log_action = \severity srcSpan style msg ->
631 SevInfo -> printErrs (msg style)
632 SevFatal -> printErrs (msg style)
635 printErrs ((mkLocMessage srcSpan msg) style)
636 -- careful (#2302): printErrs prints in UTF-8, whereas
637 -- converting to string first and using hPutStr would
638 -- just emit the low 8 bits of each unicode char.
645 0 | print errors & warnings only
646 1 | minimal verbosity: print "compiling M ... done." for each module.
647 2 | equivalent to -dshow-passes
648 3 | equivalent to existing "ghc -v"
649 4 | "ghc -v -ddump-most"
650 5 | "ghc -v -ddump-all"
653 -- | Test whether a 'DynFlag' is set
654 dopt :: DynFlag -> DynFlags -> Bool
655 dopt f dflags = f `elem` (flags dflags)
658 dopt_set :: DynFlags -> DynFlag -> DynFlags
659 dopt_set dfs f = dfs{ flags = f : flags dfs }
661 -- | Unset a 'DynFlag'
662 dopt_unset :: DynFlags -> DynFlag -> DynFlags
663 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
665 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
666 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
667 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
668 -> [a] -- ^ Correctly ordered extracted options
669 getOpts dflags opts = reverse (opts dflags)
670 -- We add to the options from the front, so we need to reverse the list
672 -- | Gets the verbosity flag for the current verbosity level. This is fed to
673 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
674 getVerbFlag :: DynFlags -> String
676 | verbosity dflags >= 3 = "-v"
679 setObjectDir, setHiDir, setStubDir, setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
680 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
681 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
682 addCmdlineFramework, addHaddockOpts
683 :: String -> DynFlags -> DynFlags
684 setOutputFile, setOutputHi, setDumpPrefixForce
685 :: Maybe String -> DynFlags -> DynFlags
687 setObjectDir f d = d{ objectDir = Just f}
688 setHiDir f d = d{ hiDir = Just f}
689 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
690 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
691 -- \#included from the .hc file when compiling with -fvia-C.
693 setObjectSuf f d = d{ objectSuf = f}
694 setHiSuf f d = d{ hiSuf = f}
695 setHcSuf f d = d{ hcSuf = f}
697 setOutputFile f d = d{ outputFile = f}
698 setOutputHi f d = d{ outputHi = f}
700 parseDynLibLoaderMode f d =
702 ("deploy", "") -> d{ dynLibLoader = Deployable }
703 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
704 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
705 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
706 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
707 (_,_) -> error "Unknown dynlib loader"
709 setDumpPrefixForce f d = d { dumpPrefixForce = f}
711 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
712 -- Config.hs should really use Option.
713 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
715 setPgmL f d = d{ pgm_L = f}
716 setPgmF f d = d{ pgm_F = f}
717 setPgmc f d = d{ pgm_c = (f,[])}
718 setPgmm f d = d{ pgm_m = (f,[])}
719 setPgms f d = d{ pgm_s = (f,[])}
720 setPgma f d = d{ pgm_a = (f,[])}
721 setPgml f d = d{ pgm_l = (f,[])}
722 setPgmdll f d = d{ pgm_dll = (f,[])}
723 setPgmwindres f d = d{ pgm_windres = f}
725 addOptL f d = d{ opt_L = f : opt_L d}
726 addOptP f d = d{ opt_P = f : opt_P d}
727 addOptF f d = d{ opt_F = f : opt_F d}
728 addOptc f d = d{ opt_c = f : opt_c d}
729 addOptm f d = d{ opt_m = f : opt_m d}
730 addOpta f d = d{ opt_a = f : opt_a d}
731 addOptl f d = d{ opt_l = f : opt_l d}
732 addOptwindres f d = d{ opt_windres = f : opt_windres d}
734 setDepMakefile :: FilePath -> DynFlags -> DynFlags
735 setDepMakefile f d = d { depMakefile = deOptDep f }
737 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
738 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
740 addDepExcludeMod :: String -> DynFlags -> DynFlags
742 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
744 addDepSuffix :: FilePath -> DynFlags -> DynFlags
745 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
747 setDepWarnings :: Bool -> DynFlags -> DynFlags
748 setDepWarnings b d = d { depWarnings = b }
751 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
752 -- we need to strip the "-optdep" off of the arg
753 deOptDep :: String -> String
754 deOptDep x = case maybePrefixMatch "-optdep" x of
758 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
760 addHaddockOpts f d = d{ haddockOptions = Just f}
762 -- -----------------------------------------------------------------------------
763 -- Command-line options
765 -- | When invoking external tools as part of the compilation pipeline, we
766 -- pass these a sequence of options on the command-line. Rather than
767 -- just using a list of Strings, we use a type that allows us to distinguish
768 -- between filepaths and 'other stuff'. The reason for this is that
769 -- this type gives us a handle on transforming filenames, and filenames only,
770 -- to whatever format they're expected to be on a particular platform.
772 = FileOption -- an entry that _contains_ filename(s) / filepaths.
773 String -- a non-filepath prefix that shouldn't be
774 -- transformed (e.g., "/out=")
775 String -- the filepath/filename portion
778 -----------------------------------------------------------------------------
779 -- Setting the optimisation level
781 updOptLevel :: Int -> DynFlags -> DynFlags
782 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
784 = dfs2{ optLevel = final_n }
786 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
787 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
788 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
790 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
791 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
793 optLevelFlags :: [([Int], DynFlag)]
795 = [ ([0], Opt_IgnoreInterfacePragmas)
796 , ([0], Opt_OmitInterfacePragmas)
798 , ([1,2], Opt_IgnoreAsserts)
799 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
801 , ([1,2], Opt_DoEtaReduction)
802 , ([1,2], Opt_CaseMerge)
803 , ([1,2], Opt_Strictness)
805 , ([1,2], Opt_FullLaziness)
807 , ([2], Opt_LiberateCase)
808 , ([2], Opt_SpecConstr)
810 -- , ([2], Opt_StaticArgumentTransformation)
811 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
812 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
813 -- several improvements to the heuristics, and I'm concerned that without
814 -- those changes SAT will interfere with some attempts to write "high
815 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
816 -- this year. In particular, the version in HEAD lacks the tail call
817 -- criterion, so many things that look like reasonable loops will be
818 -- turned into functions with extra (unneccesary) thunk creation.
820 , ([0,1,2], Opt_DoLambdaEtaExpansion)
821 -- This one is important for a tiresome reason:
822 -- we want to make sure that the bindings for data
823 -- constructors are eta-expanded. This is probably
824 -- a good thing anyway, but it seems fragile.
827 -- -----------------------------------------------------------------------------
828 -- Standard sets of warning options
830 standardWarnings :: [DynFlag]
832 = [ Opt_WarnWarningsDeprecations,
833 Opt_WarnDeprecatedFlags,
834 Opt_WarnUnrecognisedPragmas,
835 Opt_WarnOverlappingPatterns,
836 Opt_WarnMissingFields,
837 Opt_WarnMissingMethods,
838 Opt_WarnDuplicateExports,
839 Opt_WarnDodgyForeignImports
842 minusWOpts :: [DynFlag]
844 = standardWarnings ++
845 [ Opt_WarnUnusedBinds,
846 Opt_WarnUnusedMatches,
847 Opt_WarnUnusedImports,
848 Opt_WarnIncompletePatterns,
852 minusWallOpts :: [DynFlag]
855 [ Opt_WarnTypeDefaults,
856 Opt_WarnNameShadowing,
862 -- minuswRemovesOpts should be every warning option
863 minuswRemovesOpts :: [DynFlag]
866 [Opt_WarnImplicitPrelude,
867 Opt_WarnIncompletePatternsRecUpd,
868 Opt_WarnSimplePatterns,
869 Opt_WarnMonomorphism,
870 Opt_WarnUnrecognisedPragmas,
874 -- -----------------------------------------------------------------------------
875 -- CoreToDo: abstraction of core-to-core passes to run.
877 data CoreToDo -- These are diff core-to-core passes,
878 -- which may be invoked in any order,
879 -- as many times as you like.
881 = CoreDoSimplify -- The core-to-core simplifier.
884 -- Each run of the simplifier can take a different
885 -- set of simplifier-specific flags.
887 | CoreDoFloatOutwards FloatOutSwitches
892 | CoreDoWorkerWrapper
895 | CoreDoOldStrictness
898 | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
899 -- matching this string
900 | CoreDoVectorisation PackageId
901 | CoreDoNothing -- Useful when building up
902 | CoreDoPasses [CoreToDo] -- lists of these things
904 data SimplifierMode -- See comments in SimplMonad
906 | SimplPhase Int [String]
908 data SimplifierSwitch
909 = MaxSimplifierIterations Int
912 data FloatOutSwitches
913 = FloatOutSw Bool -- True <=> float lambdas to top level
914 Bool -- True <=> float constants to top level,
915 -- even if they do not escape a lambda
918 -- The core-to-core pass ordering is derived from the DynFlags:
919 runWhen :: Bool -> CoreToDo -> CoreToDo
920 runWhen True do_this = do_this
921 runWhen False _ = CoreDoNothing
923 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
924 runMaybe (Just x) f = f x
925 runMaybe Nothing _ = CoreDoNothing
927 getCoreToDo :: DynFlags -> [CoreToDo]
929 | Just todo <- coreToDo dflags = todo -- set explicitly by user
930 | otherwise = core_todo
932 opt_level = optLevel dflags
933 phases = simplPhases dflags
934 max_iter = maxSimplIterations dflags
935 strictness = dopt Opt_Strictness dflags
936 full_laziness = dopt Opt_FullLaziness dflags
937 cse = dopt Opt_CSE dflags
938 spec_constr = dopt Opt_SpecConstr dflags
939 liberate_case = dopt Opt_LiberateCase dflags
940 rule_check = ruleCheck dflags
941 static_args = dopt Opt_StaticArgumentTransformation dflags
943 maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
945 simpl_phase phase names iter
947 [ CoreDoSimplify (SimplPhase phase names) [
948 MaxSimplifierIterations iter
950 maybe_rule_check phase
954 = runWhen (dopt Opt_Vectorise dflags)
955 $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
958 -- By default, we have 2 phases before phase 0.
960 -- Want to run with inline phase 2 after the specialiser to give
961 -- maximum chance for fusion to work before we inline build/augment
962 -- in phase 1. This made a difference in 'ansi' where an
963 -- overloaded function wasn't inlined till too late.
965 -- Need phase 1 so that build/augment get
966 -- inlined. I found that spectral/hartel/genfft lost some useful
967 -- strictness in the function sumcode' if augment is not inlined
968 -- before strictness analysis runs
969 simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
970 | phase <- [phases, phases-1 .. 1] ]
973 -- initial simplify: mk specialiser happy: minimum effort please
974 simpl_gently = CoreDoSimplify SimplGently [
976 -- Don't inline anything till full laziness has bitten
977 -- In particular, inlining wrappers inhibits floating
978 -- e.g. ...(case f x of ...)...
979 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
980 -- ==> ...(case x of I# x# -> case fw x# of ...)...
981 -- and now the redex (f x) isn't floatable any more
982 -- Similarly, don't apply any rules until after full
983 -- laziness. Notably, list fusion can prevent floating.
985 NoCaseOfCase, -- Don't do case-of-case transformations.
986 -- This makes full laziness work better
987 MaxSimplifierIterations max_iter
991 if opt_level == 0 then
993 simpl_phase 0 ["final"] max_iter]
994 else {- opt_level >= 1 -} [
996 -- We want to do the static argument transform before full laziness as it
997 -- may expose extra opportunities to float things outwards. However, to fix
998 -- up the output of the transformation we need at do at least one simplify
999 -- after this before anything else
1000 runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1002 -- We run vectorisation here for now, but we might also try to run
1006 -- initial simplify: mk specialiser happy: minimum effort please
1009 -- Specialisation is best done before full laziness
1010 -- so that overloaded functions have all their dictionary lambdas manifest
1013 runWhen full_laziness (CoreDoFloatOutwards (FloatOutSw False False)),
1019 -- Phase 0: allow all Ids to be inlined now
1020 -- This gets foldr inlined before strictness analysis
1022 -- At least 3 iterations because otherwise we land up with
1023 -- huge dead expressions because of an infelicity in the
1025 -- let k = BIG in foldr k z xs
1026 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1027 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1029 simpl_phase 0 ["main"] (max max_iter 3),
1032 #ifdef OLD_STRICTNESS
1033 CoreDoOldStrictness,
1035 runWhen strictness (CoreDoPasses [
1037 CoreDoWorkerWrapper,
1039 simpl_phase 0 ["post-worker-wrapper"] max_iter
1042 runWhen full_laziness
1043 (CoreDoFloatOutwards (FloatOutSw False -- Not lambdas
1044 True)), -- Float constants
1045 -- nofib/spectral/hartel/wang doubles in speed if you
1046 -- do full laziness late in the day. It only happens
1047 -- after fusion and other stuff, so the early pass doesn't
1048 -- catch it. For the record, the redex is
1049 -- f_el22 (f_el21 r_midblock)
1052 runWhen cse CoreCSE,
1053 -- We want CSE to follow the final full-laziness pass, because it may
1054 -- succeed in commoning up things floated out by full laziness.
1055 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1061 -- Case-liberation for -O2. This should be after
1062 -- strictness analysis and the simplification which follows it.
1063 runWhen liberate_case (CoreDoPasses [
1065 simpl_phase 0 ["post-liberate-case"] max_iter
1066 ]), -- Run the simplifier after LiberateCase to vastly
1067 -- reduce the possiblility of shadowing
1068 -- Reason: see Note [Shadowing] in SpecConstr.lhs
1070 runWhen spec_constr CoreDoSpecConstr,
1074 -- Final clean-up simplification:
1075 simpl_phase 0 ["final"] max_iter
1078 -- -----------------------------------------------------------------------------
1079 -- StgToDo: abstraction of stg-to-stg passes to run.
1082 = StgDoMassageForProfiling -- should be (next to) last
1083 -- There's also setStgVarInfo, but its absolute "lastness"
1084 -- is so critical that it is hardwired in (no flag).
1087 getStgToDo :: DynFlags -> [StgToDo]
1089 | Just todo <- stgToDo dflags = todo -- set explicitly by user
1092 stg_stats = dopt Opt_StgStats dflags
1094 todo1 = if stg_stats then [D_stg_stats] else []
1096 todo2 | WayProf `elem` wayNames dflags
1097 = StgDoMassageForProfiling : todo1
1101 -- -----------------------------------------------------------------------------
1104 allFlags :: [String]
1105 allFlags = map ('-':) $
1106 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1107 map ("fno-"++) flags ++
1108 map ("f"++) flags ++
1109 map ("X"++) supportedLanguages ++
1110 map ("XNo"++) supportedLanguages
1111 where ok (PrefixPred _ _) = False
1113 flags = [ name | (name, _, _) <- fFlags ]
1115 dynamic_flags :: [Flag DynP]
1117 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1118 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1119 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1120 , Flag "#include" (HasArg (addCmdlineHCInclude)) Supported
1121 , Flag "v" (OptIntSuffix setVerbosity) Supported
1123 ------- Specific phases --------------------------------------------
1124 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1125 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1126 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1127 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1128 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1129 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1130 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1131 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1132 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1133 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1135 , Flag "optL" (HasArg (upd . addOptL)) Supported
1136 , Flag "optP" (HasArg (upd . addOptP)) Supported
1137 , Flag "optF" (HasArg (upd . addOptF)) Supported
1138 , Flag "optc" (HasArg (upd . addOptc)) Supported
1139 , Flag "optm" (HasArg (upd . addOptm)) Supported
1140 , Flag "opta" (HasArg (upd . addOpta)) Supported
1141 , Flag "optl" (HasArg (upd . addOptl)) Supported
1142 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1145 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1148 -------- ghc -M -----------------------------------------------------
1149 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1150 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1151 (Deprecated "Use -dep-suffix instead")
1152 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1153 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1154 (Deprecated "Use -dep-makefile instead")
1155 , Flag "optdep-w" (NoArg (upd (setDepWarnings False)))
1156 (Deprecated "-optdep-w doesn't do anything")
1157 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1158 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1159 (Deprecated "Use -include-pkg-deps instead")
1160 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1161 (Deprecated "Use -include-pkg-deps instead")
1162 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1163 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1164 (Deprecated "Use -exclude-module instead")
1165 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1166 (Deprecated "Use -exclude-module instead")
1168 -------- Linking ----------------------------------------------------
1169 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1171 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1172 (Deprecated "Use -c instead")
1173 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1175 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1178 ------- Libraries ---------------------------------------------------
1179 , Flag "L" (Prefix addLibraryPath ) Supported
1180 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1182 ------- Frameworks --------------------------------------------------
1183 -- -framework-path should really be -F ...
1184 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1185 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1187 ------- Output Redirection ------------------------------------------
1188 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1189 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1190 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1191 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1192 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1193 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1194 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1195 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1196 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1197 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1200 ------- Keeping temporary files -------------------------------------
1201 -- These can be singular (think ghc -c) or plural (think ghc --make)
1202 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1203 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1204 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1205 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1206 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1207 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1208 -- This only makes sense as plural
1209 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1211 ------- Miscellaneous ----------------------------------------------
1212 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1213 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1214 , Flag "main-is" (SepArg setMainIs ) Supported
1215 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1216 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1217 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1219 ------- recompilation checker --------------------------------------
1220 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1221 (Deprecated "Use -fno-force-recomp instead")
1222 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1223 (Deprecated "Use -fforce-recomp instead")
1225 ------- Packages ----------------------------------------------------
1226 , Flag "package-conf" (HasArg extraPkgConf_) Supported
1227 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1229 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1230 , Flag "package" (HasArg exposePackage) Supported
1231 , Flag "hide-package" (HasArg hidePackage) Supported
1232 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1234 , Flag "ignore-package" (HasArg ignorePackage)
1236 , Flag "syslib" (HasArg exposePackage)
1237 (Deprecated "Use -package instead")
1239 ------ HsCpp opts ---------------------------------------------------
1240 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1241 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1243 ------- Include/Import Paths ----------------------------------------
1244 , Flag "I" (Prefix addIncludePath) Supported
1245 , Flag "i" (OptPrefix addImportPath ) Supported
1247 ------ Debugging ----------------------------------------------------
1248 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1250 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1252 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1254 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1256 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1258 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1260 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1262 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1264 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1266 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1268 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1270 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1272 , Flag "ddump-asm-regalloc-stages"
1273 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1275 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1277 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1279 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1281 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1283 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1285 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1287 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1289 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1291 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1293 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1295 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1297 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1299 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1301 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1303 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1305 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1307 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1309 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1311 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1313 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1315 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1317 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1319 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1321 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1323 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1325 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1327 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1329 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1331 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1333 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1335 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1337 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1339 , Flag "dverbose-core2core" (NoArg setVerboseCore2Core)
1341 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1343 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1345 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1347 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1349 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1351 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1353 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1355 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1357 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1360 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1362 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1364 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1366 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1368 , Flag "dshow-passes"
1369 (NoArg (do forceRecompile
1370 setVerbosity (Just 2)))
1372 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1375 ------ Machine dependant (-m<blah>) stuff ---------------------------
1377 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1379 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1381 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1384 ------ Warning opts -------------------------------------------------
1385 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1387 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1389 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1391 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1393 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1394 (Deprecated "Use -w instead")
1395 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1398 ------ Optimisation flags ------------------------------------------
1399 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1400 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1401 (Deprecated "Use -O0 instead")
1402 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1403 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1405 -- If the number is missing, use 1
1407 , Flag "fsimplifier-phases"
1408 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1410 , Flag "fmax-simplifier-iterations"
1411 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1414 , Flag "fspec-constr-threshold"
1415 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1417 , Flag "fno-spec-constr-threshold"
1418 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1420 , Flag "fspec-constr-count"
1421 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1423 , Flag "fno-spec-constr-count"
1424 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1426 , Flag "fliberate-case-threshold"
1427 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1429 , Flag "fno-liberate-case-threshold"
1430 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1433 , Flag "frule-check"
1434 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1436 , Flag "fcontext-stack"
1437 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1440 ------ DPH flags ----------------------------------------------------
1443 (NoArg (setDPHBackend DPHSeq))
1446 (NoArg (setDPHBackend DPHPar))
1449 (NoArg (setDPHBackend DPHThis))
1452 ------ Compiler flags -----------------------------------------------
1454 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1455 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1456 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1458 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1459 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1460 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1462 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1464 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1467 ++ map (mkFlag True "f" setDynFlag ) fFlags
1468 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1469 ++ map (mkFlag True "X" setDynFlag ) xFlags
1470 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1472 mkFlag :: Bool -- ^ True <=> it should be turned on
1473 -> String -- ^ The flag prefix
1474 -> (DynFlag -> DynP ())
1475 -> (String, DynFlag, Bool -> Deprecated)
1477 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1478 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1480 deprecatedForLanguage :: String -> Bool -> Deprecated
1481 deprecatedForLanguage lang turn_on
1482 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ "#-} instead")
1484 flag | turn_on = lang
1485 | otherwise = "No"++lang
1487 useInstead :: String -> Bool -> Deprecated
1488 useInstead flag turn_on
1489 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1491 no = if turn_on then "" else "no-"
1493 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1494 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1496 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1497 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1498 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1499 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1500 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1501 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1502 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1503 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1504 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1505 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1506 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1507 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1508 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1509 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1510 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1511 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1512 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1513 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1514 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1515 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1516 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1517 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1518 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1519 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1520 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1521 ( "strictness", Opt_Strictness, const Supported ),
1522 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1523 ( "full-laziness", Opt_FullLaziness, const Supported ),
1524 ( "liberate-case", Opt_LiberateCase, const Supported ),
1525 ( "spec-constr", Opt_SpecConstr, const Supported ),
1526 ( "cse", Opt_CSE, const Supported ),
1527 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1528 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1529 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1530 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1531 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1532 ( "case-merge", Opt_CaseMerge, const Supported ),
1533 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1534 ( "method-sharing", Opt_MethodSharing, const Supported ),
1535 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1536 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1537 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1538 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1539 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1540 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1541 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1542 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1543 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1544 ( "break-on-error", Opt_BreakOnError, const Supported ),
1545 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1546 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1547 ( "run-cps", Opt_RunCPSZ, const Supported ),
1548 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1549 ( "vectorise", Opt_Vectorise, const Supported ),
1550 ( "regs-graph", Opt_RegsGraph, const Supported ),
1551 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1552 ( "th", Opt_TemplateHaskell,
1553 deprecatedForLanguage "TemplateHaskell" ),
1554 ( "fi", Opt_ForeignFunctionInterface,
1555 deprecatedForLanguage "ForeignFunctionInterface" ),
1556 ( "ffi", Opt_ForeignFunctionInterface,
1557 deprecatedForLanguage "ForeignFunctionInterface" ),
1558 ( "arrows", Opt_Arrows,
1559 deprecatedForLanguage "Arrows" ),
1560 ( "generics", Opt_Generics,
1561 deprecatedForLanguage "Generics" ),
1562 ( "implicit-prelude", Opt_ImplicitPrelude,
1563 deprecatedForLanguage "ImplicitPrelude" ),
1564 ( "bang-patterns", Opt_BangPatterns,
1565 deprecatedForLanguage "BangPatterns" ),
1566 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1567 deprecatedForLanguage "MonomorphismRestriction" ),
1568 ( "mono-pat-binds", Opt_MonoPatBinds,
1569 deprecatedForLanguage "MonoPatBinds" ),
1570 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1571 deprecatedForLanguage "ExtendedDefaultRules" ),
1572 ( "implicit-params", Opt_ImplicitParams,
1573 deprecatedForLanguage "ImplicitParams" ),
1574 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1575 deprecatedForLanguage "ScopedTypeVariables" ),
1577 deprecatedForLanguage "PArr" ),
1578 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1579 deprecatedForLanguage "OverlappingInstances" ),
1580 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1581 deprecatedForLanguage "UndecidableInstances" ),
1582 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1583 deprecatedForLanguage "IncoherentInstances" ),
1584 ( "gen-manifest", Opt_GenManifest, const Supported ),
1585 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1586 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1589 supportedLanguages :: [String]
1590 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1592 -- This may contain duplicates
1593 languageOptions :: [DynFlag]
1594 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1596 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1597 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1599 ( "CPP", Opt_Cpp, const Supported ),
1600 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1601 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1602 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1603 ( "MagicHash", Opt_MagicHash, const Supported ),
1604 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1605 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1606 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1607 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1608 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1609 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1610 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1611 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1612 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1613 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1614 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1615 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, const Supported ),
1616 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1617 ( "RecursiveDo", Opt_RecursiveDo, const Supported ),
1618 ( "Arrows", Opt_Arrows, const Supported ),
1619 ( "PArr", Opt_PArr, const Supported ),
1620 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1621 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1622 ( "Generics", Opt_Generics, const Supported ),
1624 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1625 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1626 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1627 ( "RecordPuns", Opt_RecordPuns,
1628 deprecatedForLanguage "NamedFieldPuns" ),
1629 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1630 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1631 ( "GADTs", Opt_GADTs, const Supported ),
1632 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1633 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1634 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1636 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1637 -- On by default (which is not strictly H98):
1638 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1639 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1640 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1641 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1642 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1644 ( "PatternSignatures", Opt_ScopedTypeVariables,
1645 deprecatedForLanguage "ScopedTypeVariables" ),
1647 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1648 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1649 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1650 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1651 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1652 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1653 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1654 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1655 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1656 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1657 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1658 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1659 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1660 ( "PackageImports", Opt_PackageImports, const Supported )
1663 impliedFlags :: [(DynFlag, DynFlag)]
1665 = [ (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1666 -- be completely rigid for GADTs
1668 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1669 -- Note [Scoped tyvars] in TcBinds
1672 glasgowExtsFlags :: [DynFlag]
1673 glasgowExtsFlags = [
1674 Opt_PrintExplicitForalls
1675 , Opt_ForeignFunctionInterface
1676 , Opt_UnliftedFFITypes
1678 , Opt_ImplicitParams
1679 , Opt_ScopedTypeVariables
1681 , Opt_TypeSynonymInstances
1682 , Opt_StandaloneDeriving
1683 , Opt_DeriveDataTypeable
1684 , Opt_FlexibleContexts
1685 , Opt_FlexibleInstances
1686 , Opt_ConstrainedClassMethods
1687 , Opt_MultiParamTypeClasses
1688 , Opt_FunctionalDependencies
1690 , Opt_PolymorphicComponents
1691 , Opt_ExistentialQuantification
1693 , Opt_PostfixOperators
1695 , Opt_LiberalTypeSynonyms
1697 , Opt_ImpredicativeTypes
1700 , Opt_ParallelListComp
1701 , Opt_EmptyDataDecls
1702 , Opt_KindSignatures
1703 , Opt_GeneralizedNewtypeDeriving
1704 , Opt_TypeFamilies ]
1706 -- -----------------------------------------------------------------------------
1707 -- Parsing the dynamic flags.
1709 -- | Parse dynamic flags from a list of command line argument. Returns the
1710 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1711 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1712 -- flags or missing arguments).
1713 parseDynamicFlags :: Monad m =>
1714 DynFlags -> [Located String]
1715 -> m (DynFlags, [Located String], [Located String])
1716 -- ^ Updated 'DynFlags', left-over arguments, and
1717 -- list of warnings.
1718 parseDynamicFlags dflags args = do
1719 -- XXX Legacy support code
1720 -- We used to accept things like
1721 -- optdep-f -optdepdepend
1722 -- optdep-f -optdep depend
1723 -- optdep -f -optdepdepend
1724 -- optdep -f -optdep depend
1725 -- but the spaces trip up proper argument handling. So get rid of them.
1726 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1727 f (x : xs) = x : f xs
1730 let ((leftover, errs, warns), dflags')
1731 = runCmdLine (processArgs dynamic_flags args') dflags
1732 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1733 return (dflags', leftover, warns)
1735 type DynP = CmdLineP DynFlags
1737 upd :: (DynFlags -> DynFlags) -> DynP ()
1739 dfs <- getCmdLineState
1740 putCmdLineState $! (f dfs)
1742 --------------------------
1743 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1744 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1745 ; mapM_ setDynFlag deps }
1747 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1748 -- When you set f, set the ones it implies
1749 -- NB: use setDynFlag recursively, in case the implied flags
1750 -- implies further flags
1751 -- When you un-set f, however, we don't un-set the things it implies
1752 -- (except for -fno-glasgow-exts, which is treated specially)
1754 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1756 --------------------------
1757 setDumpFlag :: DynFlag -> OptKind DynP
1758 setDumpFlag dump_flag
1759 = NoArg (setDynFlag dump_flag >> when want_recomp forceRecompile)
1761 -- Certain dumpy-things are really interested in what's going
1762 -- on during recompilation checking, so in those cases we
1763 -- don't want to turn it off.
1764 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1765 Opt_D_dump_hi_diffs]
1767 forceRecompile :: DynP ()
1768 -- Whenver we -ddump, force recompilation (by switching off the
1769 -- recompilation checker), else you don't see the dump! However,
1770 -- don't switch it off in --make mode, else *everything* gets
1771 -- recompiled which probably isn't what you want
1772 forceRecompile = do { dfs <- getCmdLineState
1773 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1775 force_recomp dfs = isOneShot (ghcMode dfs)
1777 setVerboseCore2Core :: DynP ()
1778 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
1780 upd (\s -> s { shouldDumpSimplPhase = const True })
1782 setDumpSimplPhases :: String -> DynP ()
1783 setDumpSimplPhases s = do forceRecompile
1784 upd (\s -> s { shouldDumpSimplPhase = spec })
1786 spec :: SimplifierMode -> Bool
1788 . map (join (&&) . map match . split ':')
1794 join :: (Bool -> Bool -> Bool)
1795 -> [SimplifierMode -> Bool]
1796 -> SimplifierMode -> Bool
1797 join _ [] = const True
1798 join op ss = foldr1 (\f g x -> f x `op` g x) ss
1800 match :: String -> SimplifierMode -> Bool
1801 match "" = const True
1802 match s = case reads s of
1803 [(n,"")] -> phase_num n
1806 phase_num :: Int -> SimplifierMode -> Bool
1807 phase_num n (SimplPhase k _) = n == k
1808 phase_num _ _ = False
1810 phase_name :: String -> SimplifierMode -> Bool
1811 phase_name s SimplGently = s == "gentle"
1812 phase_name s (SimplPhase _ ss) = s `elem` ss
1814 setVerbosity :: Maybe Int -> DynP ()
1815 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1817 addCmdlineHCInclude :: String -> DynP ()
1818 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
1820 extraPkgConf_ :: FilePath -> DynP ()
1821 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1823 exposePackage, hidePackage, ignorePackage :: String -> DynP ()
1825 upd (\s -> s{ packageFlags = ExposePackage 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
1833 | Nothing <- unpackPackageId pid
1834 = ghcError (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
1836 = \s -> s{ thisPackage = pid }
1838 pid = stringToPackageId p
1840 -- If we're linking a binary, then only targets that produce object
1841 -- code are allowed (requests for other target types are ignored).
1842 setTarget :: HscTarget -> DynP ()
1843 setTarget l = upd set
1846 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
1849 -- Changes the target only if we're compiling object code. This is
1850 -- used by -fasm and -fvia-C, which switch from one to the other, but
1851 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
1852 -- can be safely used in an OPTIONS_GHC pragma.
1853 setObjTarget :: HscTarget -> DynP ()
1854 setObjTarget l = upd set
1857 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1860 setOptLevel :: Int -> DynFlags -> DynFlags
1861 setOptLevel n dflags
1862 | hscTarget dflags == HscInterpreted && n > 0
1864 -- not in IO any more, oh well:
1865 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1867 = updOptLevel n dflags
1870 -- -Odph is equivalent to
1872 -- -O2 optimise as much as possible
1873 -- -fno-method-sharing sharing specialisation defeats fusion
1875 -- -fdicts-cheap always inline dictionaries
1876 -- -fmax-simplifier-iterations20 this is necessary sometimes
1877 -- -fno-spec-constr-threshold run SpecConstr even for big loops
1878 -- -fno-spec-constr-count SpecConstr as much as possible
1880 setDPHOpt :: DynFlags -> DynFlags
1881 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
1882 , specConstrThreshold = Nothing
1883 , specConstrCount = Nothing
1885 `dopt_set` Opt_DictsCheap
1886 `dopt_unset` Opt_MethodSharing
1888 data DPHBackend = DPHPar
1891 deriving(Eq, Ord, Enum, Show)
1893 setDPHBackend :: DPHBackend -> DynP ()
1894 setDPHBackend backend
1896 upd $ \dflags -> dflags { dphBackend = backend }
1897 mapM_ exposePackage (dph_packages backend)
1899 dph_packages DPHThis = []
1900 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
1901 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
1903 dphPackage :: DynFlags -> PackageId
1904 dphPackage dflags = case dphBackend dflags of
1905 DPHPar -> dphParPackageId
1906 DPHSeq -> dphSeqPackageId
1907 DPHThis -> thisPackage dflags
1909 setMainIs :: String -> DynP ()
1911 | not (null main_fn) && isLower (head main_fn)
1912 -- The arg looked like "Foo.Bar.baz"
1913 = upd $ \d -> d{ mainFunIs = Just main_fn,
1914 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1916 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
1917 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1919 | otherwise -- The arg looked like "baz"
1920 = upd $ \d -> d{ mainFunIs = Just arg }
1922 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1924 -- | Get the unqualified name of the function to use as the \"main\" for the main module.
1925 -- Either returns the default name or the one configured on the command line with -main-is
1926 getMainFun :: DynFlags -> RdrName
1927 getMainFun dflags = case (mainFunIs dflags) of
1928 Just fn -> mkRdrUnqual (mkVarOccFS (mkFastString fn))
1929 Nothing -> main_RDR_Unqual
1931 -----------------------------------------------------------------------------
1932 -- Paths & Libraries
1934 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1936 -- -i on its own deletes the import paths
1937 addImportPath "" = upd (\s -> s{importPaths = []})
1938 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1942 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1945 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1947 addFrameworkPath p =
1948 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1950 #ifndef mingw32_TARGET_OS
1951 split_marker :: Char
1952 split_marker = ':' -- not configurable (ToDo)
1955 splitPathList :: String -> [String]
1956 splitPathList s = filter notNull (splitUp s)
1957 -- empty paths are ignored: there might be a trailing
1958 -- ':' in the initial list, for example. Empty paths can
1959 -- cause confusion when they are translated into -I options
1960 -- for passing to gcc.
1962 #ifndef mingw32_TARGET_OS
1963 splitUp xs = split split_marker xs
1965 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
1967 -- That is, if "foo:bar:baz" is used, this interpreted as
1968 -- consisting of three entries, 'foo', 'bar', 'baz'.
1969 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
1970 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
1972 -- Notice that no attempt is made to fully replace the 'standard'
1973 -- split marker ':' with the Windows / DOS one, ';'. The reason being
1974 -- that this will cause too much breakage for users & ':' will
1975 -- work fine even with DOS paths, if you're not insisting on being silly.
1978 splitUp (x:':':div:xs) | div `elem` dir_markers
1979 = ((x:':':div:p): splitUp rs)
1981 (p,rs) = findNextPath xs
1982 -- we used to check for existence of the path here, but that
1983 -- required the IO monad to be threaded through the command-line
1984 -- parser which is quite inconvenient. The
1985 splitUp xs = cons p (splitUp rs)
1987 (p,rs) = findNextPath xs
1992 -- will be called either when we've consumed nought or the
1993 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
1994 -- finding the next split marker.
1996 case break (`elem` split_markers) xs of
1997 (p, _:ds) -> (p, ds)
2000 split_markers :: [Char]
2001 split_markers = [':', ';']
2003 dir_markers :: [Char]
2004 dir_markers = ['/', '\\']
2007 -- -----------------------------------------------------------------------------
2008 -- tmpDir, where we store temporary files.
2010 setTmpDir :: FilePath -> DynFlags -> DynFlags
2011 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2012 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2013 -- seem necessary now --SDM 7/2/2008
2015 -----------------------------------------------------------------------------
2018 setOptHpcDir :: String -> DynP ()
2019 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2021 -----------------------------------------------------------------------------
2022 -- Via-C compilation stuff
2024 -- There are some options that we need to pass to gcc when compiling
2025 -- Haskell code via C, but are only supported by recent versions of
2026 -- gcc. The configure script decides which of these options we need,
2027 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2028 -- read before each via-C compilation. The advantage of having these
2029 -- in a separate file is that the file can be created at install-time
2030 -- depending on the available gcc version, and even re-generated later
2031 -- if gcc is upgraded.
2033 -- The options below are not dependent on the version of gcc, only the
2036 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2037 [String]) -- for registerised HC compilations
2038 machdepCCOpts _dflags
2039 #if alpha_TARGET_ARCH
2041 #ifdef HAVE_THREADED_RTS_SUPPORT
2045 -- For now, to suppress the gcc warning "call-clobbered
2046 -- register used for global register variable", we simply
2047 -- disable all warnings altogether using the -w flag. Oh well.
2049 #elif hppa_TARGET_ARCH
2050 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2051 -- (very nice, but too bad the HP /usr/include files don't agree.)
2052 = ( ["-D_HPUX_SOURCE"], [] )
2054 #elif m68k_TARGET_ARCH
2055 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2056 -- popping of args to routines to be explicit; if we let things
2057 -- be deferred 'til after an STGJUMP, imminent death is certain!
2059 -- -fomit-frame-pointer : *don't*
2060 -- It's better to have a6 completely tied up being a frame pointer
2061 -- rather than let GCC pick random things to do with it.
2062 -- (If we want to steal a6, then we would try to do things
2063 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2064 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2066 #elif i386_TARGET_ARCH
2067 -- -fno-defer-pop : basically the same game as for m68k
2069 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2070 -- the fp (%ebp) for our register maps.
2071 = let n_regs = stolen_x86_regs _dflags
2074 ( [ if sta then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2077 "-fomit-frame-pointer",
2078 -- we want -fno-builtin, because when gcc inlines
2079 -- built-in functions like memcpy() it tends to
2080 -- run out of registers, requiring -monly-n-regs
2082 "-DSTOLEN_X86_REGS="++show n_regs ]
2085 #elif ia64_TARGET_ARCH
2086 = ( [], ["-fomit-frame-pointer", "-G0"] )
2088 #elif x86_64_TARGET_ARCH
2089 = ( [], ["-fomit-frame-pointer",
2090 "-fno-asynchronous-unwind-tables",
2091 -- the unwind tables are unnecessary for HC code,
2092 -- and get in the way of -split-objs. Another option
2093 -- would be to throw them away in the mangler, but this
2096 -- calling builtins like strlen() using the FFI can
2097 -- cause gcc to run out of regs, so use the external
2101 #elif sparc_TARGET_ARCH
2103 -- For now, to suppress the gcc warning "call-clobbered
2104 -- register used for global register variable", we simply
2105 -- disable all warnings altogether using the -w flag. Oh well.
2107 #elif powerpc_apple_darwin_TARGET
2109 -- Disable Apple's precompiling preprocessor. It's a great thing
2110 -- for "normal" programs, but it doesn't support register variable
2112 = ( [], ["-no-cpp-precomp"] )
2117 picCCOpts :: DynFlags -> [String]
2119 #if darwin_TARGET_OS
2120 -- Apple prefers to do things the other way round.
2121 -- PIC is on by default.
2122 -- -mdynamic-no-pic:
2123 -- Turn off PIC code generation.
2125 -- Don't generate "common" symbols - these are unwanted
2126 -- in dynamic libraries.
2129 = ["-fno-common", "-D__PIC__"]
2131 = ["-mdynamic-no-pic"]
2132 #elif mingw32_TARGET_OS
2133 -- no -fPIC for Windows
2140 = ["-fPIC", "-D__PIC__"]
2145 -- -----------------------------------------------------------------------------
2149 can_split = cSplitObjs == "YES"
2151 -- -----------------------------------------------------------------------------
2154 compilerInfo :: [(String, String)]
2155 compilerInfo = [("Project name", cProjectName),
2156 ("Project version", cProjectVersion),
2157 ("Booter version", cBooterVersion),
2159 ("Interface file version", cHscIfaceFileVersion),
2160 ("Have interpreter", cGhcWithInterpreter),
2161 ("Object splitting", cSplitObjs),
2162 ("Have native code generator", cGhcWithNativeCodeGen),
2163 ("Support SMP", cGhcWithSMP),
2164 ("Unregisterised", cGhcUnregisterised),
2165 ("Tables next to code", cGhcEnableTablesNextToCode),
2166 ("Win32 DLLs", cEnableWin32DLLs),
2167 ("RTS ways", cGhcRTSWays),
2168 ("Leading underscore", cLeadingUnderscore),
2169 ("Debug on", show debugIsOn)