Keep the flag lists as IntSets rather than lists
[ghc.git] / compiler / main / DynFlags.hs
1 -------------------------------------------------------------------------------
2 --
3 -- | Dynamic flags
4 --
5 -- Most flags are dynamic flags, which means they can change from compilation
6 -- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each
7 -- session can be using different dynamic flags. Dynamic flags can also be set
8 -- at the prompt in GHCi.
9 --
10 -- (c) The University of Glasgow 2005
11 --
12 -------------------------------------------------------------------------------
13
14 module DynFlags (
15 -- * Dynamic flags and associated configuration types
16 DynFlag(..),
17 WarningFlag(..),
18 ExtensionFlag(..),
19 LogAction,
20 ProfAuto(..),
21 glasgowExtsFlags,
22 dopt,
23 dopt_set,
24 dopt_unset,
25 wopt,
26 wopt_set,
27 wopt_unset,
28 xopt,
29 xopt_set,
30 xopt_unset,
31 DynFlags(..),
32 RtsOptsEnabled(..),
33 HscTarget(..), isObjectTarget, defaultObjectTarget,
34 GhcMode(..), isOneShot,
35 GhcLink(..), isNoLink,
36 PackageFlag(..),
37 Option(..), showOpt,
38 DynLibLoader(..),
39 fFlags, fWarningFlags, fLangFlags, xFlags,
40 wayNames, dynFlagDependencies,
41
42 -- ** Safe Haskell
43 SafeHaskellMode(..),
44 safeHaskellOn, safeImportsOn, safeLanguageOn, safeInferOn,
45 packageTrustOn,
46 safeDirectImpsReq, safeImplicitImpsReq,
47
48 -- ** System tool settings and locations
49 Settings(..),
50 targetPlatform,
51 ghcUsagePath, ghciUsagePath, topDir, tmpDir, rawSettings,
52 extraGccViaCFlags, systemPackageConfig,
53 pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,
54 pgm_sysman, pgm_windres, pgm_lo, pgm_lc,
55 opt_L, opt_P, opt_F, opt_c, opt_a, opt_l,
56 opt_windres, opt_lo, opt_lc,
57
58
59 -- ** Manipulating DynFlags
60 defaultDynFlags, -- Settings -> DynFlags
61 initDynFlags, -- DynFlags -> IO DynFlags
62 defaultLogAction,
63
64 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
65 getVerbFlags,
66 updOptLevel,
67 setTmpDir,
68 setPackageName,
69 doingTickyProfiling,
70
71 -- ** Parsing DynFlags
72 parseDynamicFlagsCmdLine,
73 parseDynamicFilePragma,
74 allFlags,
75
76 supportedLanguagesAndExtensions,
77
78 -- ** DynFlag C compiler options
79 picCCOpts,
80
81 -- * Configuration of the stg-to-stg passes
82 StgToDo(..),
83 getStgToDo,
84
85 -- * Compiler configuration suitable for display to the user
86 compilerInfo
87 #ifdef GHCI
88 -- Only in stage 2 can we be sure that the RTS
89 -- exposes the appropriate runtime boolean
90 , rtsIsProfiled
91 #endif
92 ) where
93
94 #include "HsVersions.h"
95
96 import Platform
97 import Module
98 import PackageConfig
99 import PrelNames ( mAIN )
100 import StaticFlags
101 import {-# SOURCE #-} Packages (PackageState)
102 import DriverPhases ( Phase(..), phaseInputExt )
103 import Config
104 import CmdLineParser
105 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
106 import Panic
107 import Util
108 import Maybes ( orElse )
109 import SrcLoc
110 import FastString
111 import Outputable
112 #ifdef GHCI
113 import Foreign.C ( CInt(..) )
114 #endif
115 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
116
117 #ifdef GHCI
118 import System.IO.Unsafe ( unsafePerformIO )
119 #endif
120 import Data.IORef
121 import Control.Monad ( when )
122
123 import Data.Char
124 import Data.List
125 import Data.Map (Map)
126 import qualified Data.Map as Map
127 import Data.Set (Set)
128 import qualified Data.Set as Set
129 import System.FilePath
130 import System.IO ( stderr, hPutChar )
131
132 import Data.IntSet (IntSet)
133 import qualified Data.IntSet as IntSet
134
135 -- -----------------------------------------------------------------------------
136 -- DynFlags
137
138 -- | Enumerates the simple on-or-off dynamic flags
139 data DynFlag
140
141 -- debugging flags
142 = Opt_D_dump_cmm
143 | Opt_D_dump_raw_cmm
144 | Opt_D_dump_cmmz
145 | Opt_D_dump_cmmz_pretty
146 -- All of the cmmz subflags (there are a lot!) Automatically
147 -- enabled if you run -ddump-cmmz
148 | Opt_D_dump_cmmz_cbe
149 | Opt_D_dump_cmmz_proc
150 | Opt_D_dump_cmmz_spills
151 | Opt_D_dump_cmmz_rewrite
152 | Opt_D_dump_cmmz_dead
153 | Opt_D_dump_cmmz_stub
154 | Opt_D_dump_cmmz_sp
155 | Opt_D_dump_cmmz_procmap
156 | Opt_D_dump_cmmz_split
157 | Opt_D_dump_cmmz_lower
158 | Opt_D_dump_cmmz_info
159 | Opt_D_dump_cmmz_cafs
160 -- end cmmz subflags
161 | Opt_D_dump_cps_cmm
162 | Opt_D_dump_cvt_cmm
163 | Opt_D_dump_asm
164 | Opt_D_dump_asm_native
165 | Opt_D_dump_asm_liveness
166 | Opt_D_dump_asm_coalesce
167 | Opt_D_dump_asm_regalloc
168 | Opt_D_dump_asm_regalloc_stages
169 | Opt_D_dump_asm_conflicts
170 | Opt_D_dump_asm_stats
171 | Opt_D_dump_asm_expanded
172 | Opt_D_dump_llvm
173 | Opt_D_dump_core_stats
174 | Opt_D_dump_cpranal
175 | Opt_D_dump_deriv
176 | Opt_D_dump_ds
177 | Opt_D_dump_flatC
178 | Opt_D_dump_foreign
179 | Opt_D_dump_inlinings
180 | Opt_D_dump_rule_firings
181 | Opt_D_dump_rule_rewrites
182 | Opt_D_dump_occur_anal
183 | Opt_D_dump_parsed
184 | Opt_D_dump_rn
185 | Opt_D_dump_core_pipeline -- TODO FIXME: dump after simplifier stats
186 | Opt_D_dump_simpl
187 | Opt_D_dump_simpl_iterations
188 | Opt_D_dump_simpl_phases
189 | Opt_D_dump_spec
190 | Opt_D_dump_prep
191 | Opt_D_dump_stg
192 | Opt_D_dump_stranal
193 | Opt_D_dump_tc
194 | Opt_D_dump_types
195 | Opt_D_dump_rules
196 | Opt_D_dump_cse
197 | Opt_D_dump_worker_wrapper
198 | Opt_D_dump_rn_trace
199 | Opt_D_dump_rn_stats
200 | Opt_D_dump_opt_cmm
201 | Opt_D_dump_simpl_stats
202 | Opt_D_dump_cs_trace -- Constraint solver in type checker
203 | Opt_D_dump_tc_trace
204 | Opt_D_dump_if_trace
205 | Opt_D_dump_vt_trace
206 | Opt_D_dump_splices
207 | Opt_D_dump_BCOs
208 | Opt_D_dump_vect
209 | Opt_D_dump_ticked
210 | Opt_D_dump_rtti
211 | Opt_D_source_stats
212 | Opt_D_verbose_core2core
213 | Opt_D_verbose_stg2stg
214 | Opt_D_dump_hi
215 | Opt_D_dump_hi_diffs
216 | Opt_D_dump_minimal_imports
217 | Opt_D_dump_mod_cycles
218 | Opt_D_dump_view_pattern_commoning
219 | Opt_D_faststring_stats
220 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
221 | Opt_D_no_debug_output
222 | Opt_DoCoreLinting
223 | Opt_DoStgLinting
224 | Opt_DoCmmLinting
225 | Opt_DoAsmLinting
226 | Opt_NoLlvmMangler
227
228 | Opt_WarnIsError -- -Werror; makes warnings fatal
229
230 | Opt_PrintExplicitForalls
231
232 -- optimisation opts
233 | Opt_Strictness
234 | Opt_FullLaziness
235 | Opt_FloatIn
236 | Opt_Specialise
237 | Opt_StaticArgumentTransformation
238 | Opt_CSE
239 | Opt_LiberateCase
240 | Opt_SpecConstr
241 | Opt_DoLambdaEtaExpansion
242 | Opt_IgnoreAsserts
243 | Opt_DoEtaReduction
244 | Opt_CaseMerge
245 | Opt_UnboxStrictFields
246 | Opt_DictsCheap
247 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
248 | Opt_Vectorise
249 | Opt_RegsGraph -- do graph coloring register allocation
250 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
251 | Opt_PedanticBottoms -- Be picky about how we treat bottom
252
253 -- Interface files
254 | Opt_IgnoreInterfacePragmas
255 | Opt_OmitInterfacePragmas
256 | Opt_ExposeAllUnfoldings
257
258 -- profiling opts
259 | Opt_AutoSccsOnIndividualCafs
260 | Opt_ProfCountEntries
261
262 -- misc opts
263 | Opt_Pp
264 | Opt_ForceRecomp
265 | Opt_ExcessPrecision
266 | Opt_EagerBlackHoling
267 | Opt_ReadUserPackageConf
268 | Opt_NoHsMain
269 | Opt_SplitObjs
270 | Opt_StgStats
271 | Opt_HideAllPackages
272 | Opt_PrintBindResult
273 | Opt_Haddock
274 | Opt_HaddockOptions
275 | Opt_Hpc_No_Auto
276 | Opt_BreakOnException
277 | Opt_BreakOnError
278 | Opt_PrintEvldWithShow
279 | Opt_PrintBindContents
280 | Opt_GenManifest
281 | Opt_EmbedManifest
282 | Opt_EmitExternalCore
283 | Opt_SharedImplib
284 | Opt_BuildingCabalPackage
285 | Opt_SSE2
286 | Opt_SSE4_2
287 | Opt_GhciSandbox
288 | Opt_GhciHistory
289 | Opt_HelpfulErrors
290
291 -- temporary flags
292 | Opt_RunCPS
293 | Opt_RunCPSZ
294 | Opt_AutoLinkPackages
295 | Opt_ImplicitImportQualified
296 | Opt_TryNewCodeGen
297
298 -- keeping stuff
299 | Opt_KeepHiDiffs
300 | Opt_KeepHcFiles
301 | Opt_KeepSFiles
302 | Opt_KeepTmpFiles
303 | Opt_KeepRawTokenStream
304 | Opt_KeepLlvmFiles
305
306 -- safe haskell flags
307 | Opt_DistrustAllPackages
308 | Opt_PackageTrust
309
310 deriving (Eq, Show, Enum)
311
312 data WarningFlag =
313 Opt_WarnDuplicateExports
314 | Opt_WarnHiShadows
315 | Opt_WarnImplicitPrelude
316 | Opt_WarnIncompletePatterns
317 | Opt_WarnIncompleteUniPatterns
318 | Opt_WarnIncompletePatternsRecUpd
319 | Opt_WarnMissingFields
320 | Opt_WarnMissingImportList
321 | Opt_WarnMissingMethods
322 | Opt_WarnMissingSigs
323 | Opt_WarnMissingLocalSigs
324 | Opt_WarnNameShadowing
325 | Opt_WarnOverlappingPatterns
326 | Opt_WarnTypeDefaults
327 | Opt_WarnMonomorphism
328 | Opt_WarnUnusedBinds
329 | Opt_WarnUnusedImports
330 | Opt_WarnUnusedMatches
331 | Opt_WarnWarningsDeprecations
332 | Opt_WarnDeprecatedFlags
333 | Opt_WarnDodgyExports
334 | Opt_WarnDodgyImports
335 | Opt_WarnOrphans
336 | Opt_WarnAutoOrphans
337 | Opt_WarnIdentities
338 | Opt_WarnTabs
339 | Opt_WarnUnrecognisedPragmas
340 | Opt_WarnDodgyForeignImports
341 | Opt_WarnLazyUnliftedBindings
342 | Opt_WarnUnusedDoBind
343 | Opt_WarnWrongDoBind
344 | Opt_WarnAlternativeLayoutRuleTransitional
345 | Opt_WarnUnsafe
346 | Opt_WarnSafe
347 deriving (Eq, Show, Enum)
348
349 data Language = Haskell98 | Haskell2010
350 deriving Enum
351
352 -- | The various Safe Haskell modes
353 data SafeHaskellMode
354 = Sf_None
355 | Sf_Unsafe
356 | Sf_Trustworthy
357 | Sf_Safe
358 | Sf_SafeInfered
359 deriving (Eq)
360
361 instance Outputable SafeHaskellMode where
362 ppr Sf_None = ptext $ sLit "None"
363 ppr Sf_Unsafe = ptext $ sLit "Unsafe"
364 ppr Sf_Trustworthy = ptext $ sLit "Trustworthy"
365 ppr Sf_Safe = ptext $ sLit "Safe"
366 ppr Sf_SafeInfered = ptext $ sLit "Safe-Infered"
367
368 data ExtensionFlag
369 = Opt_Cpp
370 | Opt_OverlappingInstances
371 | Opt_UndecidableInstances
372 | Opt_IncoherentInstances
373 | Opt_MonomorphismRestriction
374 | Opt_MonoPatBinds
375 | Opt_MonoLocalBinds
376 | Opt_RelaxedPolyRec -- Deprecated
377 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
378 | Opt_ForeignFunctionInterface
379 | Opt_UnliftedFFITypes
380 | Opt_InterruptibleFFI
381 | Opt_GHCForeignImportPrim
382 | Opt_ParallelArrays -- Syntactic support for parallel arrays
383 | Opt_Arrows -- Arrow-notation syntax
384 | Opt_TemplateHaskell
385 | Opt_QuasiQuotes
386 | Opt_ImplicitParams
387 | Opt_ImplicitPrelude
388 | Opt_ScopedTypeVariables
389 | Opt_UnboxedTuples
390 | Opt_BangPatterns
391 | Opt_TypeFamilies
392 | Opt_OverloadedStrings
393 | Opt_DisambiguateRecordFields
394 | Opt_RecordWildCards
395 | Opt_RecordPuns
396 | Opt_ViewPatterns
397 | Opt_GADTs
398 | Opt_GADTSyntax
399 | Opt_NPlusKPatterns
400 | Opt_DoAndIfThenElse
401 | Opt_RebindableSyntax
402 | Opt_ConstraintKinds
403 | Opt_PolyKinds -- Kind polymorphism
404
405 | Opt_StandaloneDeriving
406 | Opt_DeriveDataTypeable
407 | Opt_DeriveFunctor
408 | Opt_DeriveTraversable
409 | Opt_DeriveFoldable
410 | Opt_DeriveGeneric -- Allow deriving Generic/1
411 | Opt_DefaultSignatures -- Allow extra signatures for defmeths
412
413 | Opt_TypeSynonymInstances
414 | Opt_FlexibleContexts
415 | Opt_FlexibleInstances
416 | Opt_ConstrainedClassMethods
417 | Opt_MultiParamTypeClasses
418 | Opt_FunctionalDependencies
419 | Opt_UnicodeSyntax
420 | Opt_PolymorphicComponents
421 | Opt_ExistentialQuantification
422 | Opt_MagicHash
423 | Opt_EmptyDataDecls
424 | Opt_KindSignatures
425 | Opt_ParallelListComp
426 | Opt_TransformListComp
427 | Opt_MonadComprehensions
428 | Opt_GeneralizedNewtypeDeriving
429 | Opt_RecursiveDo
430 | Opt_DoRec
431 | Opt_PostfixOperators
432 | Opt_TupleSections
433 | Opt_PatternGuards
434 | Opt_LiberalTypeSynonyms
435 | Opt_Rank2Types
436 | Opt_RankNTypes
437 | Opt_ImpredicativeTypes
438 | Opt_TypeOperators
439 | Opt_PackageImports
440 | Opt_ExplicitForAll
441 | Opt_AlternativeLayoutRule
442 | Opt_AlternativeLayoutRuleTransitional
443 | Opt_DatatypeContexts
444 | Opt_NondecreasingIndentation
445 | Opt_RelaxedLayout
446 | Opt_TraditionalRecordSyntax
447 deriving (Eq, Enum, Show)
448
449 -- | Contains not only a collection of 'DynFlag's but also a plethora of
450 -- information relating to the compilation of a single file or GHC session
451 data DynFlags = DynFlags {
452 ghcMode :: GhcMode,
453 ghcLink :: GhcLink,
454 hscTarget :: HscTarget,
455 settings :: Settings,
456 hscOutName :: String, -- ^ Name of the output file
457 extCoreName :: String, -- ^ Name of the .hcr output file
458 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
459 optLevel :: Int, -- ^ Optimisation level
460 simplPhases :: Int, -- ^ Number of simplifier phases
461 maxSimplIterations :: Int, -- ^ Max simplifier iterations
462 shouldDumpSimplPhase :: Maybe String,
463 ruleCheck :: Maybe String,
464 strictnessBefore :: [Int], -- ^ Additional demand analysis
465
466 simplTickFactor :: Int, -- ^ Multiplier for simplifier ticks
467 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
468 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
469 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
470 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
471 -- See CoreMonad.FloatOutSwitches
472
473 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
474 importPaths :: [FilePath],
475 mainModIs :: Module,
476 mainFunIs :: Maybe String,
477 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
478
479 thisPackage :: PackageId, -- ^ name of package currently being compiled
480
481 -- ways
482 ways :: [Way], -- ^ Way flags from the command line
483 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
484 rtsBuildTag :: String, -- ^ The RTS \"way\"
485
486 -- For object splitting
487 splitInfo :: Maybe (String,Int),
488
489 -- paths etc.
490 objectDir :: Maybe String,
491 dylibInstallName :: Maybe String,
492 hiDir :: Maybe String,
493 stubDir :: Maybe String,
494 dumpDir :: Maybe String,
495
496 objectSuf :: String,
497 hcSuf :: String,
498 hiSuf :: String,
499
500 outputFile :: Maybe String,
501 outputHi :: Maybe String,
502 dynLibLoader :: DynLibLoader,
503
504 -- | This is set by 'DriverPipeline.runPipeline' based on where
505 -- its output is going.
506 dumpPrefix :: Maybe FilePath,
507
508 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
509 -- Set by @-ddump-file-prefix@
510 dumpPrefixForce :: Maybe FilePath,
511
512 includePaths :: [String],
513 libraryPaths :: [String],
514 frameworkPaths :: [String], -- used on darwin only
515 cmdlineFrameworks :: [String], -- ditto
516
517 rtsOpts :: Maybe String,
518 rtsOptsEnabled :: RtsOptsEnabled,
519
520 hpcDir :: String, -- ^ Path to store the .mix files
521
522 -- Plugins
523 pluginModNames :: [ModuleName],
524 pluginModNameOpts :: [(ModuleName,String)],
525
526 -- For ghc -M
527 depMakefile :: FilePath,
528 depIncludePkgDeps :: Bool,
529 depExcludeMods :: [ModuleName],
530 depSuffixes :: [String],
531
532 -- Package flags
533 extraPkgConfs :: [FilePath],
534 -- ^ The @-package-conf@ flags given on the command line, in the order
535 -- they appeared.
536
537 packageFlags :: [PackageFlag],
538 -- ^ The @-package@ and @-hide-package@ flags from the command-line
539
540 -- Package state
541 -- NB. do not modify this field, it is calculated by
542 -- Packages.initPackages and Packages.updatePackages.
543 pkgDatabase :: Maybe [PackageConfig],
544 pkgState :: PackageState,
545
546 -- Temporary files
547 -- These have to be IORefs, because the defaultCleanupHandler needs to
548 -- know what to clean when an exception happens
549 filesToClean :: IORef [FilePath],
550 dirsToClean :: IORef (Map FilePath FilePath),
551
552 -- Names of files which were generated from -ddump-to-file; used to
553 -- track which ones we need to truncate because it's our first run
554 -- through
555 generatedDumps :: IORef (Set FilePath),
556
557 -- hsc dynamic flags
558 flags :: IntSet,
559 warningFlags :: IntSet,
560 -- Don't change this without updating extensionFlags:
561 language :: Maybe Language,
562 -- | Safe Haskell mode
563 safeHaskell :: SafeHaskellMode,
564 -- We store the location of where template haskell and newtype deriving were
565 -- turned on so we can produce accurate error messages when Safe Haskell turns
566 -- them off.
567 thOnLoc :: SrcSpan,
568 newDerivOnLoc :: SrcSpan,
569 warnSafeOnLoc :: SrcSpan,
570 warnUnsafeOnLoc :: SrcSpan,
571 -- Don't change this without updating extensionFlags:
572 extensions :: [OnOff ExtensionFlag],
573 -- extensionFlags should always be equal to
574 -- flattenExtensionFlags language extensions
575 extensionFlags :: IntSet,
576
577 -- | Message output action: use "ErrUtils" instead of this if you can
578 log_action :: LogAction,
579
580 haddockOptions :: Maybe String,
581
582 -- | what kind of {-# SCC #-} to add automatically
583 profAuto :: ProfAuto
584 }
585
586 data ProfAuto
587 = NoProfAuto -- ^ no SCC annotations added
588 | ProfAutoAll -- ^ top-level and nested functions are annotated
589 | ProfAutoTop -- ^ top-level functions annotated only
590 | ProfAutoExports -- ^ exported functions annotated only
591
592 data Settings = Settings {
593 sTargetPlatform :: Platform, -- Filled in by SysTools
594 sGhcUsagePath :: FilePath, -- Filled in by SysTools
595 sGhciUsagePath :: FilePath, -- ditto
596 sTopDir :: FilePath,
597 sTmpDir :: String, -- no trailing '/'
598 -- You shouldn't need to look things up in rawSettings directly.
599 -- They should have their own fields instead.
600 sRawSettings :: [(String, String)],
601 sExtraGccViaCFlags :: [String],
602 sSystemPackageConfig :: FilePath,
603 -- commands for particular phases
604 sPgm_L :: String,
605 sPgm_P :: (String,[Option]),
606 sPgm_F :: String,
607 sPgm_c :: (String,[Option]),
608 sPgm_s :: (String,[Option]),
609 sPgm_a :: (String,[Option]),
610 sPgm_l :: (String,[Option]),
611 sPgm_dll :: (String,[Option]),
612 sPgm_T :: String,
613 sPgm_sysman :: String,
614 sPgm_windres :: String,
615 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
616 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
617 -- options for particular phases
618 sOpt_L :: [String],
619 sOpt_P :: [String],
620 sOpt_F :: [String],
621 sOpt_c :: [String],
622 sOpt_a :: [String],
623 sOpt_l :: [String],
624 sOpt_windres :: [String],
625 sOpt_lo :: [String], -- LLVM: llvm optimiser
626 sOpt_lc :: [String] -- LLVM: llc static compiler
627
628 }
629
630 targetPlatform :: DynFlags -> Platform
631 targetPlatform dflags = sTargetPlatform (settings dflags)
632
633 ghcUsagePath :: DynFlags -> FilePath
634 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
635 ghciUsagePath :: DynFlags -> FilePath
636 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
637 topDir :: DynFlags -> FilePath
638 topDir dflags = sTopDir (settings dflags)
639 tmpDir :: DynFlags -> String
640 tmpDir dflags = sTmpDir (settings dflags)
641 rawSettings :: DynFlags -> [(String, String)]
642 rawSettings dflags = sRawSettings (settings dflags)
643 extraGccViaCFlags :: DynFlags -> [String]
644 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
645 systemPackageConfig :: DynFlags -> FilePath
646 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
647 pgm_L :: DynFlags -> String
648 pgm_L dflags = sPgm_L (settings dflags)
649 pgm_P :: DynFlags -> (String,[Option])
650 pgm_P dflags = sPgm_P (settings dflags)
651 pgm_F :: DynFlags -> String
652 pgm_F dflags = sPgm_F (settings dflags)
653 pgm_c :: DynFlags -> (String,[Option])
654 pgm_c dflags = sPgm_c (settings dflags)
655 pgm_s :: DynFlags -> (String,[Option])
656 pgm_s dflags = sPgm_s (settings dflags)
657 pgm_a :: DynFlags -> (String,[Option])
658 pgm_a dflags = sPgm_a (settings dflags)
659 pgm_l :: DynFlags -> (String,[Option])
660 pgm_l dflags = sPgm_l (settings dflags)
661 pgm_dll :: DynFlags -> (String,[Option])
662 pgm_dll dflags = sPgm_dll (settings dflags)
663 pgm_T :: DynFlags -> String
664 pgm_T dflags = sPgm_T (settings dflags)
665 pgm_sysman :: DynFlags -> String
666 pgm_sysman dflags = sPgm_sysman (settings dflags)
667 pgm_windres :: DynFlags -> String
668 pgm_windres dflags = sPgm_windres (settings dflags)
669 pgm_lo :: DynFlags -> (String,[Option])
670 pgm_lo dflags = sPgm_lo (settings dflags)
671 pgm_lc :: DynFlags -> (String,[Option])
672 pgm_lc dflags = sPgm_lc (settings dflags)
673 opt_L :: DynFlags -> [String]
674 opt_L dflags = sOpt_L (settings dflags)
675 opt_P :: DynFlags -> [String]
676 opt_P dflags = sOpt_P (settings dflags)
677 opt_F :: DynFlags -> [String]
678 opt_F dflags = sOpt_F (settings dflags)
679 opt_c :: DynFlags -> [String]
680 opt_c dflags = sOpt_c (settings dflags)
681 opt_a :: DynFlags -> [String]
682 opt_a dflags = sOpt_a (settings dflags)
683 opt_l :: DynFlags -> [String]
684 opt_l dflags = sOpt_l (settings dflags)
685 opt_windres :: DynFlags -> [String]
686 opt_windres dflags = sOpt_windres (settings dflags)
687 opt_lo :: DynFlags -> [String]
688 opt_lo dflags = sOpt_lo (settings dflags)
689 opt_lc :: DynFlags -> [String]
690 opt_lc dflags = sOpt_lc (settings dflags)
691
692 wayNames :: DynFlags -> [WayName]
693 wayNames = map wayName . ways
694
695 -- | The target code type of the compilation (if any).
696 --
697 -- Whenever you change the target, also make sure to set 'ghcLink' to
698 -- something sensible.
699 --
700 -- 'HscNothing' can be used to avoid generating any output, however, note
701 -- that:
702 --
703 -- * This will not run the desugaring step, thus no warnings generated in
704 -- this step will be output. In particular, this includes warnings related
705 -- to pattern matching. You can run the desugarer manually using
706 -- 'GHC.desugarModule'.
707 --
708 -- * If a program uses Template Haskell the typechecker may try to run code
709 -- from an imported module. This will fail if no code has been generated
710 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
711 -- whether this might be the case and choose to either switch to a
712 -- different target or avoid typechecking such modules. (The latter may
713 -- preferable for security reasons.)
714 --
715 data HscTarget
716 = HscC -- ^ Generate C code.
717 | HscAsm -- ^ Generate assembly using the native code generator.
718 | HscLlvm -- ^ Generate assembly using the llvm code generator.
719 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
720 | HscNothing -- ^ Don't generate any code. See notes above.
721 deriving (Eq, Show)
722
723 showHscTargetFlag :: HscTarget -> String
724 showHscTargetFlag HscC = "-fvia-c"
725 showHscTargetFlag HscAsm = "-fasm"
726 showHscTargetFlag HscLlvm = "-fllvm"
727 showHscTargetFlag HscInterpreted = "-fbyte-code"
728 showHscTargetFlag HscNothing = "-fno-code"
729
730 -- | Will this target result in an object file on the disk?
731 isObjectTarget :: HscTarget -> Bool
732 isObjectTarget HscC = True
733 isObjectTarget HscAsm = True
734 isObjectTarget HscLlvm = True
735 isObjectTarget _ = False
736
737 -- | The 'GhcMode' tells us whether we're doing multi-module
738 -- compilation (controlled via the "GHC" API) or one-shot
739 -- (single-module) compilation. This makes a difference primarily to
740 -- the "Finder": in one-shot mode we look for interface files for
741 -- imported modules, but in multi-module mode we look for source files
742 -- in order to check whether they need to be recompiled.
743 data GhcMode
744 = CompManager -- ^ @\-\-make@, GHCi, etc.
745 | OneShot -- ^ @ghc -c Foo.hs@
746 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
747 deriving Eq
748
749 instance Outputable GhcMode where
750 ppr CompManager = ptext (sLit "CompManager")
751 ppr OneShot = ptext (sLit "OneShot")
752 ppr MkDepend = ptext (sLit "MkDepend")
753
754 isOneShot :: GhcMode -> Bool
755 isOneShot OneShot = True
756 isOneShot _other = False
757
758 -- | What to do in the link step, if there is one.
759 data GhcLink
760 = NoLink -- ^ Don't link at all
761 | LinkBinary -- ^ Link object code into a binary
762 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
763 -- bytecode and object code).
764 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
765 deriving (Eq, Show)
766
767 isNoLink :: GhcLink -> Bool
768 isNoLink NoLink = True
769 isNoLink _ = False
770
771 -- Is it worth evaluating this Bool and caching it in the DynFlags value
772 -- during initDynFlags?
773 doingTickyProfiling :: DynFlags -> Bool
774 doingTickyProfiling _ = opt_Ticky
775 -- XXX -ticky is a static flag, because it implies -debug which is also
776 -- static. If the way flags were made dynamic, we could fix this.
777
778 data PackageFlag
779 = ExposePackage String
780 | ExposePackageId String
781 | HidePackage String
782 | IgnorePackage String
783 | TrustPackage String
784 | DistrustPackage String
785 deriving Eq
786
787 defaultHscTarget :: HscTarget
788 defaultHscTarget = defaultObjectTarget
789
790 -- | The 'HscTarget' value corresponding to the default way to create
791 -- object files on the current platform.
792 defaultObjectTarget :: HscTarget
793 defaultObjectTarget
794 | cGhcUnregisterised == "YES" = HscC
795 | cGhcWithNativeCodeGen == "YES" = HscAsm
796 | otherwise = HscLlvm
797
798 data DynLibLoader
799 = Deployable
800 | SystemDependent
801 deriving Eq
802
803 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
804 deriving (Show)
805
806 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
807 initDynFlags :: DynFlags -> IO DynFlags
808 initDynFlags dflags = do
809 -- someday these will be dynamic flags
810 ways <- readIORef v_Ways
811 refFilesToClean <- newIORef []
812 refDirsToClean <- newIORef Map.empty
813 refGeneratedDumps <- newIORef Set.empty
814 return dflags{
815 ways = ways,
816 buildTag = mkBuildTag (filter (not . wayRTSOnly) ways),
817 rtsBuildTag = mkBuildTag ways,
818 filesToClean = refFilesToClean,
819 dirsToClean = refDirsToClean,
820 generatedDumps = refGeneratedDumps
821 }
822
823 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
824 -- and must be fully initialized by 'GHC.newSession' first.
825 defaultDynFlags :: Settings -> DynFlags
826 defaultDynFlags mySettings =
827 DynFlags {
828 ghcMode = CompManager,
829 ghcLink = LinkBinary,
830 hscTarget = defaultHscTarget,
831 hscOutName = "",
832 extCoreName = "",
833 verbosity = 0,
834 optLevel = 0,
835 simplPhases = 2,
836 maxSimplIterations = 4,
837 shouldDumpSimplPhase = Nothing,
838 ruleCheck = Nothing,
839 simplTickFactor = 100,
840 specConstrThreshold = Just 2000,
841 specConstrCount = Just 3,
842 liberateCaseThreshold = Just 2000,
843 floatLamArgs = Just 0, -- Default: float only if no fvs
844 strictnessBefore = [],
845
846 cmdlineHcIncludes = [],
847 importPaths = ["."],
848 mainModIs = mAIN,
849 mainFunIs = Nothing,
850 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
851
852 thisPackage = mainPackageId,
853
854 objectDir = Nothing,
855 dylibInstallName = Nothing,
856 hiDir = Nothing,
857 stubDir = Nothing,
858 dumpDir = Nothing,
859
860 objectSuf = phaseInputExt StopLn,
861 hcSuf = phaseInputExt HCc,
862 hiSuf = "hi",
863
864 pluginModNames = [],
865 pluginModNameOpts = [],
866
867 outputFile = Nothing,
868 outputHi = Nothing,
869 dynLibLoader = SystemDependent,
870 dumpPrefix = Nothing,
871 dumpPrefixForce = Nothing,
872 includePaths = [],
873 libraryPaths = [],
874 frameworkPaths = [],
875 cmdlineFrameworks = [],
876 rtsOpts = Nothing,
877 rtsOptsEnabled = RtsOptsSafeOnly,
878
879 hpcDir = ".hpc",
880
881 extraPkgConfs = [],
882 packageFlags = [],
883 pkgDatabase = Nothing,
884 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
885 ways = panic "defaultDynFlags: No ways",
886 buildTag = panic "defaultDynFlags: No buildTag",
887 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
888 splitInfo = Nothing,
889 settings = mySettings,
890 -- ghc -M values
891 depMakefile = "Makefile",
892 depIncludePkgDeps = False,
893 depExcludeMods = [],
894 depSuffixes = [],
895 -- end of ghc -M values
896 filesToClean = panic "defaultDynFlags: No filesToClean",
897 dirsToClean = panic "defaultDynFlags: No dirsToClean",
898 generatedDumps = panic "defaultDynFlags: No generatedDumps",
899 haddockOptions = Nothing,
900 flags = IntSet.fromList (map fromEnum defaultFlags),
901 warningFlags = IntSet.fromList (map fromEnum standardWarnings),
902 language = Nothing,
903 safeHaskell = Sf_SafeInfered,
904 thOnLoc = noSrcSpan,
905 newDerivOnLoc = noSrcSpan,
906 warnSafeOnLoc = noSrcSpan,
907 warnUnsafeOnLoc = noSrcSpan,
908 extensions = [],
909 extensionFlags = flattenExtensionFlags Nothing [],
910 log_action = defaultLogAction,
911 profAuto = NoProfAuto
912 }
913
914 type LogAction = Severity -> SrcSpan -> PprStyle -> Message -> IO ()
915
916 defaultLogAction :: LogAction
917 defaultLogAction severity srcSpan style msg
918 = case severity of
919 SevOutput -> printSDoc msg style
920 SevInfo -> printErrs msg style
921 SevFatal -> printErrs msg style
922 _ -> do hPutChar stderr '\n'
923 printErrs (mkLocMessage srcSpan msg) style
924 -- careful (#2302): printErrs prints in UTF-8, whereas
925 -- converting to string first and using hPutStr would
926 -- just emit the low 8 bits of each unicode char.
927
928 {-
929 Note [Verbosity levels]
930 ~~~~~~~~~~~~~~~~~~~~~~~
931 0 | print errors & warnings only
932 1 | minimal verbosity: print "compiling M ... done." for each module.
933 2 | equivalent to -dshow-passes
934 3 | equivalent to existing "ghc -v"
935 4 | "ghc -v -ddump-most"
936 5 | "ghc -v -ddump-all"
937 -}
938
939 data OnOff a = On a
940 | Off a
941
942 -- OnOffs accumulate in reverse order, so we use foldr in order to
943 -- process them in the right order
944 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag] -> IntSet
945 flattenExtensionFlags ml = foldr f defaultExtensionFlags
946 where f (On f) flags = IntSet.insert (fromEnum f) flags
947 f (Off f) flags = IntSet.delete (fromEnum f) flags
948 defaultExtensionFlags = IntSet.fromList (map fromEnum (languageExtensions ml))
949
950 languageExtensions :: Maybe Language -> [ExtensionFlag]
951
952 languageExtensions Nothing
953 -- Nothing => the default case
954 = Opt_NondecreasingIndentation -- This has been on by default for some time
955 : delete Opt_DatatypeContexts -- The Haskell' committee decided to
956 -- remove datatype contexts from the
957 -- language:
958 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
959 (languageExtensions (Just Haskell2010))
960
961 -- NB: MonoPatBinds is no longer the default
962
963 languageExtensions (Just Haskell98)
964 = [Opt_ImplicitPrelude,
965 Opt_MonomorphismRestriction,
966 Opt_NPlusKPatterns,
967 Opt_DatatypeContexts,
968 Opt_TraditionalRecordSyntax,
969 Opt_NondecreasingIndentation
970 -- strictly speaking non-standard, but we always had this
971 -- on implicitly before the option was added in 7.1, and
972 -- turning it off breaks code, so we're keeping it on for
973 -- backwards compatibility. Cabal uses -XHaskell98 by
974 -- default unless you specify another language.
975 ]
976
977 languageExtensions (Just Haskell2010)
978 = [Opt_ImplicitPrelude,
979 Opt_MonomorphismRestriction,
980 Opt_DatatypeContexts,
981 Opt_TraditionalRecordSyntax,
982 Opt_EmptyDataDecls,
983 Opt_ForeignFunctionInterface,
984 Opt_PatternGuards,
985 Opt_DoAndIfThenElse,
986 Opt_RelaxedPolyRec]
987
988 -- | Test whether a 'DynFlag' is set
989 dopt :: DynFlag -> DynFlags -> Bool
990 dopt f dflags = fromEnum f `IntSet.member` flags dflags
991
992 -- | Set a 'DynFlag'
993 dopt_set :: DynFlags -> DynFlag -> DynFlags
994 dopt_set dfs f = dfs{ flags = IntSet.insert (fromEnum f) (flags dfs) }
995
996 -- | Unset a 'DynFlag'
997 dopt_unset :: DynFlags -> DynFlag -> DynFlags
998 dopt_unset dfs f = dfs{ flags = IntSet.delete (fromEnum f) (flags dfs) }
999
1000 -- | Test whether a 'WarningFlag' is set
1001 wopt :: WarningFlag -> DynFlags -> Bool
1002 wopt f dflags = fromEnum f `IntSet.member` warningFlags dflags
1003
1004 -- | Set a 'WarningFlag'
1005 wopt_set :: DynFlags -> WarningFlag -> DynFlags
1006 wopt_set dfs f = dfs{ warningFlags = IntSet.insert (fromEnum f) (warningFlags dfs) }
1007
1008 -- | Unset a 'WarningFlag'
1009 wopt_unset :: DynFlags -> WarningFlag -> DynFlags
1010 wopt_unset dfs f = dfs{ warningFlags = IntSet.delete (fromEnum f) (warningFlags dfs) }
1011
1012 -- | Test whether a 'ExtensionFlag' is set
1013 xopt :: ExtensionFlag -> DynFlags -> Bool
1014 xopt f dflags = fromEnum f `IntSet.member` extensionFlags dflags
1015
1016 -- | Set a 'ExtensionFlag'
1017 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
1018 xopt_set dfs f
1019 = let onoffs = On f : extensions dfs
1020 in dfs { extensions = onoffs,
1021 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1022
1023 -- | Unset a 'ExtensionFlag'
1024 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
1025 xopt_unset dfs f
1026 = let onoffs = Off f : extensions dfs
1027 in dfs { extensions = onoffs,
1028 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1029
1030 -- | Set the Haskell language standard to use
1031 setLanguage :: Language -> DynP ()
1032 setLanguage l = upd f
1033 where f dfs = let mLang = Just l
1034 oneoffs = extensions dfs
1035 in dfs {
1036 language = mLang,
1037 extensionFlags = flattenExtensionFlags mLang oneoffs
1038 }
1039
1040 -- | Some modules have dependencies on others through the DynFlags rather than textual imports
1041 dynFlagDependencies :: DynFlags -> [ModuleName]
1042 dynFlagDependencies = pluginModNames
1043
1044 -- | Is the -fpackage-trust mode on
1045 packageTrustOn :: DynFlags -> Bool
1046 packageTrustOn = dopt Opt_PackageTrust
1047
1048 -- | Is Safe Haskell on in some way (including inference mode)
1049 safeHaskellOn :: DynFlags -> Bool
1050 safeHaskellOn dflags = safeHaskell dflags /= Sf_None
1051
1052 -- | Is the Safe Haskell safe language in use
1053 safeLanguageOn :: DynFlags -> Bool
1054 safeLanguageOn dflags = safeHaskell dflags == Sf_Safe
1055
1056 -- | Is the Safe Haskell safe inference mode active
1057 safeInferOn :: DynFlags -> Bool
1058 safeInferOn dflags = safeHaskell dflags == Sf_SafeInfered
1059
1060 -- | Test if Safe Imports are on in some form
1061 safeImportsOn :: DynFlags -> Bool
1062 safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||
1063 safeHaskell dflags == Sf_Trustworthy ||
1064 safeHaskell dflags == Sf_Safe
1065
1066 -- | Set a 'Safe Haskell' flag
1067 setSafeHaskell :: SafeHaskellMode -> DynP ()
1068 setSafeHaskell s = updM f
1069 where f dfs = do
1070 let sf = safeHaskell dfs
1071 safeM <- combineSafeFlags sf s
1072 return $ dfs { safeHaskell = safeM }
1073
1074 -- | Are all direct imports required to be safe for this Safe Haskell mode?
1075 -- Direct imports are when the code explicitly imports a module
1076 safeDirectImpsReq :: DynFlags -> Bool
1077 safeDirectImpsReq d = safeLanguageOn d
1078
1079 -- | Are all implicit imports required to be safe for this Safe Haskell mode?
1080 -- Implicit imports are things in the prelude. e.g System.IO when print is used.
1081 safeImplicitImpsReq :: DynFlags -> Bool
1082 safeImplicitImpsReq d = safeLanguageOn d
1083
1084 -- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.
1085 -- This makes Safe Haskell very much a monoid but for now I prefer this as I don't
1086 -- want to export this functionality from the module but do want to export the
1087 -- type constructors.
1088 combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
1089 combineSafeFlags a b | a == Sf_SafeInfered = return b
1090 | b == Sf_SafeInfered = return a
1091 | a == Sf_None = return b
1092 | b == Sf_None = return a
1093 | a == b = return a
1094 | otherwise = addErr errm >> return (panic errm)
1095 where errm = "Incompatible Safe Haskell flags! ("
1096 ++ showPpr a ++ ", " ++ showPpr b ++ ")"
1097
1098 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
1099 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
1100 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
1101 -> [a] -- ^ Correctly ordered extracted options
1102 getOpts dflags opts = reverse (opts dflags)
1103 -- We add to the options from the front, so we need to reverse the list
1104
1105 -- | Gets the verbosity flag for the current verbosity level. This is fed to
1106 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
1107 getVerbFlags :: DynFlags -> [String]
1108 getVerbFlags dflags
1109 | verbosity dflags >= 4 = ["-v"]
1110 | otherwise = []
1111
1112 setObjectDir, setHiDir, setStubDir, setDumpDir, setOutputDir,
1113 setDylibInstallName,
1114 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
1115 setPgmP, addOptl, addOptP,
1116 addCmdlineFramework, addHaddockOpts
1117 :: String -> DynFlags -> DynFlags
1118 setOutputFile, setOutputHi, setDumpPrefixForce
1119 :: Maybe String -> DynFlags -> DynFlags
1120
1121 setObjectDir f d = d{ objectDir = Just f}
1122 setHiDir f d = d{ hiDir = Just f}
1123 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
1124 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
1125 -- \#included from the .hc file when compiling via C (i.e. unregisterised
1126 -- builds).
1127 setDumpDir f d = d{ dumpDir = Just f}
1128 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f . setDumpDir f
1129 setDylibInstallName f d = d{ dylibInstallName = Just f}
1130
1131 setObjectSuf f d = d{ objectSuf = f}
1132 setHiSuf f d = d{ hiSuf = f}
1133 setHcSuf f d = d{ hcSuf = f}
1134
1135 setOutputFile f d = d{ outputFile = f}
1136 setOutputHi f d = d{ outputHi = f}
1137
1138 addPluginModuleName :: String -> DynFlags -> DynFlags
1139 addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }
1140
1141 addPluginModuleNameOption :: String -> DynFlags -> DynFlags
1142 addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }
1143 where (m, rest) = break (== ':') optflag
1144 option = case rest of
1145 [] -> "" -- should probably signal an error
1146 (_:plug_opt) -> plug_opt -- ignore the ':' from break
1147
1148 parseDynLibLoaderMode f d =
1149 case splitAt 8 f of
1150 ("deploy", "") -> d{ dynLibLoader = Deployable }
1151 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
1152 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
1153
1154 setDumpPrefixForce f d = d { dumpPrefixForce = f}
1155
1156 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
1157 -- Config.hs should really use Option.
1158 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
1159 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
1160 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
1161
1162
1163 setDepMakefile :: FilePath -> DynFlags -> DynFlags
1164 setDepMakefile f d = d { depMakefile = deOptDep f }
1165
1166 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1167 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1168
1169 addDepExcludeMod :: String -> DynFlags -> DynFlags
1170 addDepExcludeMod m d
1171 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1172
1173 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1174 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1175
1176 -- XXX Legacy code:
1177 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1178 -- we need to strip the "-optdep" off of the arg
1179 deOptDep :: String -> String
1180 deOptDep x = case stripPrefix "-optdep" x of
1181 Just rest -> rest
1182 Nothing -> x
1183
1184 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1185
1186 addHaddockOpts f d = d{ haddockOptions = Just f}
1187
1188 -- -----------------------------------------------------------------------------
1189 -- Command-line options
1190
1191 -- | When invoking external tools as part of the compilation pipeline, we
1192 -- pass these a sequence of options on the command-line. Rather than
1193 -- just using a list of Strings, we use a type that allows us to distinguish
1194 -- between filepaths and 'other stuff'. The reason for this is that
1195 -- this type gives us a handle on transforming filenames, and filenames only,
1196 -- to whatever format they're expected to be on a particular platform.
1197 data Option
1198 = FileOption -- an entry that _contains_ filename(s) / filepaths.
1199 String -- a non-filepath prefix that shouldn't be
1200 -- transformed (e.g., "/out=")
1201 String -- the filepath/filename portion
1202 | Option String
1203 deriving ( Eq )
1204
1205 showOpt :: Option -> String
1206 showOpt (FileOption pre f) = pre ++ f
1207 showOpt (Option s) = s
1208
1209 -----------------------------------------------------------------------------
1210 -- Setting the optimisation level
1211
1212 updOptLevel :: Int -> DynFlags -> DynFlags
1213 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1214 updOptLevel n dfs
1215 = dfs2{ optLevel = final_n }
1216 where
1217 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
1218 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
1219 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
1220
1221 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1222 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1223
1224 -- -----------------------------------------------------------------------------
1225 -- StgToDo: abstraction of stg-to-stg passes to run.
1226
1227 data StgToDo
1228 = StgDoMassageForProfiling -- should be (next to) last
1229 -- There's also setStgVarInfo, but its absolute "lastness"
1230 -- is so critical that it is hardwired in (no flag).
1231 | D_stg_stats
1232
1233 getStgToDo :: DynFlags -> [StgToDo]
1234 getStgToDo dflags
1235 = todo2
1236 where
1237 stg_stats = dopt Opt_StgStats dflags
1238
1239 todo1 = if stg_stats then [D_stg_stats] else []
1240
1241 todo2 | WayProf `elem` wayNames dflags
1242 = StgDoMassageForProfiling : todo1
1243 | otherwise
1244 = todo1
1245
1246 {- **********************************************************************
1247 %* *
1248 DynFlags parser
1249 %* *
1250 %********************************************************************* -}
1251
1252 -- -----------------------------------------------------------------------------
1253 -- Parsing the dynamic flags.
1254
1255 -- | Parse dynamic flags from a list of command line arguments. Returns the
1256 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1257 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1258 -- flags or missing arguments).
1259 parseDynamicFlagsCmdLine :: Monad m =>
1260 DynFlags -> [Located String]
1261 -> m (DynFlags, [Located String], [Located String])
1262 -- ^ Updated 'DynFlags', left-over arguments, and
1263 -- list of warnings.
1264 parseDynamicFlagsCmdLine dflags args = parseDynamicFlags dflags args True
1265
1266 -- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
1267 -- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1268 -- Used to parse flags set in a modules pragma.
1269 parseDynamicFilePragma :: Monad m =>
1270 DynFlags -> [Located String]
1271 -> m (DynFlags, [Located String], [Located String])
1272 -- ^ Updated 'DynFlags', left-over arguments, and
1273 -- list of warnings.
1274 parseDynamicFilePragma dflags args = parseDynamicFlags dflags args False
1275
1276 parseDynamicFlags :: Monad m =>
1277 DynFlags -> [Located String] -> Bool
1278 -> m (DynFlags, [Located String], [Located String])
1279 parseDynamicFlags dflags0 args cmdline = do
1280 -- XXX Legacy support code
1281 -- We used to accept things like
1282 -- optdep-f -optdepdepend
1283 -- optdep-f -optdep depend
1284 -- optdep -f -optdepdepend
1285 -- optdep -f -optdep depend
1286 -- but the spaces trip up proper argument handling. So get rid of them.
1287 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1288 f (x : xs) = x : f xs
1289 f xs = xs
1290 args' = f args
1291
1292 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1293 flag_spec | cmdline = package_flags ++ dynamic_flags
1294 | otherwise = dynamic_flags
1295
1296 let ((leftover, errs, warns), dflags1)
1297 = runCmdLine (processArgs flag_spec args') dflags0
1298 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1299
1300 -- check for disabled flags in safe haskell
1301 let (dflags2, sh_warns) = safeFlagCheck dflags1
1302
1303 return (dflags2, leftover, sh_warns ++ warns)
1304
1305 -- | Check (and potentially disable) any extensions that aren't allowed
1306 -- in safe mode.
1307 safeFlagCheck :: DynFlags -> (DynFlags, [Located String])
1308 safeFlagCheck dflags | not (safeLanguageOn dflags || safeInferOn dflags)
1309 = (dflags, [])
1310 safeFlagCheck dflags =
1311 case safeLanguageOn dflags of
1312 True -> (dflags', warns)
1313
1314 False | null warns && safeInfOk
1315 -> (dflags', [])
1316
1317 | otherwise
1318 -> (dflags' { safeHaskell = Sf_None }, [])
1319 -- Have we infered Unsafe?
1320 -- See Note [HscMain . Safe Haskell Inference]
1321 where
1322 -- TODO: Can we do better than this for inference?
1323 safeInfOk = not $ xopt Opt_OverlappingInstances dflags
1324
1325 (dflags', warns) = foldl check_method (dflags, []) bad_flags
1326
1327 check_method (df, warns) (str,loc,test,fix)
1328 | test df = (apFix fix df, warns ++ safeFailure loc str)
1329 | otherwise = (df, warns)
1330
1331 apFix f = if safeInferOn dflags then id else f
1332
1333 safeFailure loc str = [L loc $ "Warning: " ++ str ++ " is not allowed in"
1334 ++ " Safe Haskell; ignoring " ++ str]
1335
1336 bad_flags = [("-XGeneralizedNewtypeDeriving", newDerivOnLoc dflags,
1337 xopt Opt_GeneralizedNewtypeDeriving,
1338 flip xopt_unset Opt_GeneralizedNewtypeDeriving),
1339 ("-XTemplateHaskell", thOnLoc dflags,
1340 xopt Opt_TemplateHaskell,
1341 flip xopt_unset Opt_TemplateHaskell)]
1342
1343
1344 {- **********************************************************************
1345 %* *
1346 DynFlags specifications
1347 %* *
1348 %********************************************************************* -}
1349
1350 allFlags :: [String]
1351 allFlags = map ('-':) $
1352 [ flagName flag | flag <- dynamic_flags ++ package_flags, ok (flagOptKind flag) ] ++
1353 map ("fno-"++) fflags ++
1354 map ("f"++) fflags ++
1355 map ("X"++) supportedExtensions
1356 where ok (PrefixPred _ _) = False
1357 ok _ = True
1358 fflags = fflags0 ++ fflags1 ++ fflags2
1359 fflags0 = [ name | (name, _, _) <- fFlags ]
1360 fflags1 = [ name | (name, _, _) <- fWarningFlags ]
1361 fflags2 = [ name | (name, _, _) <- fLangFlags ]
1362
1363 --------------- The main flags themselves ------------------
1364 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1365 dynamic_flags = [
1366 Flag "n" (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
1367 , Flag "cpp" (NoArg (setExtensionFlag Opt_Cpp))
1368 , Flag "F" (NoArg (setDynFlag Opt_Pp))
1369 , Flag "#include"
1370 (HasArg (\s -> do addCmdlineHCInclude s
1371 addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect"))
1372 , Flag "v" (OptIntSuffix setVerbosity)
1373
1374 ------- Specific phases --------------------------------------------
1375 -- need to appear before -pgmL to be parsed as LLVM flags.
1376 , Flag "pgmlo" (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
1377 , Flag "pgmlc" (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
1378 , Flag "pgmL" (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
1379 , Flag "pgmP" (hasArg setPgmP)
1380 , Flag "pgmF" (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
1381 , Flag "pgmc" (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
1382 , Flag "pgmm" (HasArg (\_ -> addWarn "The -pgmm flag does nothing; it will be removed in a future GHC release"))
1383 , Flag "pgms" (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
1384 , Flag "pgma" (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
1385 , Flag "pgml" (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
1386 , Flag "pgmdll" (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1387 , Flag "pgmwindres" (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1388
1389 -- need to appear before -optl/-opta to be parsed as LLVM flags.
1390 , Flag "optlo" (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
1391 , Flag "optlc" (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
1392 , Flag "optL" (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
1393 , Flag "optP" (hasArg addOptP)
1394 , Flag "optF" (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
1395 , Flag "optc" (hasArg (\f -> alterSettings (\s -> s { sOpt_c = f : sOpt_c s})))
1396 , Flag "optm" (HasArg (\_ -> addWarn "The -optm flag does nothing; it will be removed in a future GHC release"))
1397 , Flag "opta" (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
1398 , Flag "optl" (hasArg addOptl)
1399 , Flag "optwindres" (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1400
1401 , Flag "split-objs"
1402 (NoArg (if can_split
1403 then setDynFlag Opt_SplitObjs
1404 else addWarn "ignoring -fsplit-objs"))
1405
1406 -------- ghc -M -----------------------------------------------------
1407 , Flag "dep-suffix" (hasArg addDepSuffix)
1408 , Flag "optdep-s" (hasArgDF addDepSuffix "Use -dep-suffix instead")
1409 , Flag "dep-makefile" (hasArg setDepMakefile)
1410 , Flag "optdep-f" (hasArgDF setDepMakefile "Use -dep-makefile instead")
1411 , Flag "optdep-w" (NoArg (deprecate "doesn't do anything"))
1412 , Flag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
1413 , Flag "optdep--include-prelude" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1414 , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1415 , Flag "exclude-module" (hasArg addDepExcludeMod)
1416 , Flag "optdep--exclude-module" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1417 , Flag "optdep-x" (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1418
1419 -------- Linking ----------------------------------------------------
1420 , Flag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
1421 , Flag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
1422 , Flag "dynload" (hasArg parseDynLibLoaderMode)
1423 , Flag "dylib-install-name" (hasArg setDylibInstallName)
1424
1425 ------- Libraries ---------------------------------------------------
1426 , Flag "L" (Prefix addLibraryPath)
1427 , Flag "l" (hasArg (addOptl . ("-l" ++)))
1428
1429 ------- Frameworks --------------------------------------------------
1430 -- -framework-path should really be -F ...
1431 , Flag "framework-path" (HasArg addFrameworkPath)
1432 , Flag "framework" (hasArg addCmdlineFramework)
1433
1434 ------- Output Redirection ------------------------------------------
1435 , Flag "odir" (hasArg setObjectDir)
1436 , Flag "o" (sepArg (setOutputFile . Just))
1437 , Flag "ohi" (hasArg (setOutputHi . Just ))
1438 , Flag "osuf" (hasArg setObjectSuf)
1439 , Flag "hcsuf" (hasArg setHcSuf)
1440 , Flag "hisuf" (hasArg setHiSuf)
1441 , Flag "hidir" (hasArg setHiDir)
1442 , Flag "tmpdir" (hasArg setTmpDir)
1443 , Flag "stubdir" (hasArg setStubDir)
1444 , Flag "dumpdir" (hasArg setDumpDir)
1445 , Flag "outputdir" (hasArg setOutputDir)
1446 , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1447
1448 ------- Keeping temporary files -------------------------------------
1449 -- These can be singular (think ghc -c) or plural (think ghc --make)
1450 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles))
1451 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles))
1452 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles))
1453 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles))
1454 , Flag "keep-raw-s-file" (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1455 , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1456 , Flag "keep-llvm-file" (NoArg (do setObjTarget HscLlvm
1457 setDynFlag Opt_KeepLlvmFiles))
1458 , Flag "keep-llvm-files" (NoArg (do setObjTarget HscLlvm
1459 setDynFlag Opt_KeepLlvmFiles))
1460 -- This only makes sense as plural
1461 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles))
1462
1463 ------- Miscellaneous ----------------------------------------------
1464 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1465 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain))
1466 , Flag "with-rtsopts" (HasArg setRtsOpts)
1467 , Flag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
1468 , Flag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
1469 , Flag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1470 , Flag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
1471 , Flag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
1472 , Flag "main-is" (SepArg setMainIs)
1473 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock))
1474 , Flag "haddock-opts" (hasArg addHaddockOpts)
1475 , Flag "hpcdir" (SepArg setOptHpcDir)
1476
1477 ------- recompilation checker --------------------------------------
1478 , Flag "recomp" (NoArg (do unSetDynFlag Opt_ForceRecomp
1479 deprecate "Use -fno-force-recomp instead"))
1480 , Flag "no-recomp" (NoArg (do setDynFlag Opt_ForceRecomp
1481 deprecate "Use -fforce-recomp instead"))
1482
1483 ------ HsCpp opts ---------------------------------------------------
1484 , Flag "D" (AnySuffix (upd . addOptP))
1485 , Flag "U" (AnySuffix (upd . addOptP))
1486
1487 ------- Include/Import Paths ----------------------------------------
1488 , Flag "I" (Prefix addIncludePath)
1489 , Flag "i" (OptPrefix addImportPath)
1490
1491 ------ Debugging ----------------------------------------------------
1492 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats))
1493
1494 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1495 , Flag "ddump-raw-cmm" (setDumpFlag Opt_D_dump_raw_cmm)
1496 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1497 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1498 , Flag "ddump-cmmz-cbe" (setDumpFlag Opt_D_dump_cmmz_cbe)
1499 , Flag "ddump-cmmz-spills" (setDumpFlag Opt_D_dump_cmmz_spills)
1500 , Flag "ddump-cmmz-proc" (setDumpFlag Opt_D_dump_cmmz_proc)
1501 , Flag "ddump-cmmz-rewrite" (setDumpFlag Opt_D_dump_cmmz_rewrite)
1502 , Flag "ddump-cmmz-dead" (setDumpFlag Opt_D_dump_cmmz_dead)
1503 , Flag "ddump-cmmz-stub" (setDumpFlag Opt_D_dump_cmmz_stub)
1504 , Flag "ddump-cmmz-sp" (setDumpFlag Opt_D_dump_cmmz_sp)
1505 , Flag "ddump-cmmz-procmap" (setDumpFlag Opt_D_dump_cmmz_procmap)
1506 , Flag "ddump-cmmz-split" (setDumpFlag Opt_D_dump_cmmz_split)
1507 , Flag "ddump-cmmz-lower" (setDumpFlag Opt_D_dump_cmmz_lower)
1508 , Flag "ddump-cmmz-info" (setDumpFlag Opt_D_dump_cmmz_info)
1509 , Flag "ddump-cmmz-cafs" (setDumpFlag Opt_D_dump_cmmz_cafs)
1510 , Flag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
1511 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1512 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1513 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1514 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1515 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1516 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1517 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1518 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1519 , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1520 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1521 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1522 , Flag "ddump-llvm" (NoArg (do setObjTarget HscLlvm
1523 setDumpFlag' Opt_D_dump_llvm))
1524 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1525 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1526 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1527 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1528 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1529 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1530 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1531 , Flag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
1532 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1533 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1534 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1535 , Flag "ddump-core-pipeline" (setDumpFlag Opt_D_dump_core_pipeline)
1536 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1537 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1538 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1539 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1540 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1541 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1542 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1543 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1544 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1545 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1546 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1547 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1548 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1549 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1550 , Flag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
1551 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1552 , Flag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
1553 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1554 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1555 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1556 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1557 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1558 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1559 , Flag "dverbose-core2core" (NoArg (do setVerbosity (Just 2)
1560 setVerboseCore2Core))
1561 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1562 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1563 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1564 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1565 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_ticked) -- back compat
1566 , Flag "ddump-ticked" (setDumpFlag Opt_D_dump_ticked)
1567 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1568 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1569 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1570 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1571 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1572 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1573 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1574 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1575 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1576 , Flag "dshow-passes" (NoArg (do forceRecompile
1577 setVerbosity $ Just 2))
1578 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1579 , Flag "dno-llvm-mangler" (NoArg (setDynFlag Opt_NoLlvmMangler))
1580
1581 ------ Machine dependant (-m<blah>) stuff ---------------------------
1582
1583 , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1584 , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1585 , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1586 , Flag "msse2" (NoArg (setDynFlag Opt_SSE2))
1587 , Flag "msse4.2" (NoArg (setDynFlag Opt_SSE4_2))
1588
1589 ------ Warning opts -------------------------------------------------
1590 , Flag "W" (NoArg (mapM_ setWarningFlag minusWOpts))
1591 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1592 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1593 , Flag "Wall" (NoArg (mapM_ setWarningFlag minusWallOpts))
1594 , Flag "Wnot" (NoArg (do upd (\dfs -> dfs {warningFlags = IntSet.empty})
1595 deprecate "Use -w instead"))
1596 , Flag "w" (NoArg (upd (\dfs -> dfs {warningFlags = IntSet.empty})))
1597
1598 ------ Plugin flags ------------------------------------------------
1599 , Flag "fplugin-opt" (hasArg addPluginModuleNameOption)
1600 , Flag "fplugin" (hasArg addPluginModuleName)
1601
1602 ------ Optimisation flags ------------------------------------------
1603 , Flag "O" (noArgM (setOptLevel 1))
1604 , Flag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
1605 setOptLevel 0 dflags))
1606 , Flag "Odph" (noArgM setDPHOpt)
1607 , Flag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1608 -- If the number is missing, use 1
1609
1610 , Flag "fsimplifier-phases" (intSuffix (\n d -> d{ simplPhases = n }))
1611 , Flag "fmax-simplifier-iterations" (intSuffix (\n d -> d{ maxSimplIterations = n }))
1612 , Flag "fsimpl-tick-factor" (intSuffix (\n d -> d{ simplTickFactor = n }))
1613 , Flag "fspec-constr-threshold" (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1614 , Flag "fno-spec-constr-threshold" (noArg (\d -> d{ specConstrThreshold = Nothing }))
1615 , Flag "fspec-constr-count" (intSuffix (\n d -> d{ specConstrCount = Just n }))
1616 , Flag "fno-spec-constr-count" (noArg (\d -> d{ specConstrCount = Nothing }))
1617 , Flag "fliberate-case-threshold" (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1618 , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1619 , Flag "frule-check" (sepArg (\s d -> d{ ruleCheck = Just s }))
1620 , Flag "fcontext-stack" (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1621 , Flag "fstrictness-before" (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1622 , Flag "ffloat-lam-args" (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1623 , Flag "ffloat-all-lams" (noArg (\d -> d{ floatLamArgs = Nothing }))
1624
1625 ------ Profiling ----------------------------------------------------
1626
1627 -- OLD profiling flags
1628 , Flag "auto-all" (noArg (\d -> d { profAuto = ProfAutoAll } ))
1629 , Flag "no-auto-all" (noArg (\d -> d { profAuto = NoProfAuto } ))
1630 , Flag "auto" (noArg (\d -> d { profAuto = ProfAutoExports } ))
1631 , Flag "no-auto" (noArg (\d -> d { profAuto = NoProfAuto } ))
1632 , Flag "caf-all" (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1633 , Flag "no-caf-all" (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1634
1635 -- NEW profiling flags
1636 , Flag "fprof-auto" (noArg (\d -> d { profAuto = ProfAutoAll } ))
1637 , Flag "fprof-auto-top" (noArg (\d -> d { profAuto = ProfAutoTop } ))
1638 , Flag "fprof-auto-exported" (noArg (\d -> d { profAuto = ProfAutoExports } ))
1639 , Flag "fno-prof-auto" (noArg (\d -> d { profAuto = NoProfAuto } ))
1640
1641 ------ Compiler flags -----------------------------------------------
1642
1643 , Flag "fasm" (NoArg (setObjTarget HscAsm))
1644 , Flag "fvia-c" (NoArg
1645 (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1646 , Flag "fvia-C" (NoArg
1647 (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1648 , Flag "fllvm" (NoArg (setObjTarget HscLlvm))
1649
1650 , Flag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1651 setTarget HscNothing))
1652 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted))
1653 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget))
1654 , Flag "fglasgow-exts" (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1655 , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1656
1657 ------ Safe Haskell flags -------------------------------------------
1658 , Flag "fpackage-trust" (NoArg (setDynFlag Opt_PackageTrust))
1659 , Flag "fno-safe-infer" (NoArg (setSafeHaskell Sf_None))
1660 ]
1661 ++ map (mkFlag turnOn "f" setDynFlag ) fFlags
1662 ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1663 ++ map (mkFlag turnOn "f" setWarningFlag ) fWarningFlags
1664 ++ map (mkFlag turnOff "fno-" unSetWarningFlag) fWarningFlags
1665 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
1666 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1667 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
1668 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
1669 ++ map (mkFlag turnOn "X" setLanguage) languageFlags
1670 ++ map (mkFlag turnOn "X" setSafeHaskell) safeHaskellFlags
1671 ++ [ Flag "XGenerics" (NoArg (deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support."))
1672 , Flag "XNoGenerics" (NoArg (deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support.")) ]
1673
1674 package_flags :: [Flag (CmdLineP DynFlags)]
1675 package_flags = [
1676 ------- Packages ----------------------------------------------------
1677 Flag "package-conf" (HasArg extraPkgConf_)
1678 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1679 , Flag "package-name" (hasArg setPackageName)
1680 , Flag "package-id" (HasArg exposePackageId)
1681 , Flag "package" (HasArg exposePackage)
1682 , Flag "hide-package" (HasArg hidePackage)
1683 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1684 , Flag "ignore-package" (HasArg ignorePackage)
1685 , Flag "syslib" (HasArg (\s -> do exposePackage s
1686 deprecate "Use -package instead"))
1687 , Flag "trust" (HasArg trustPackage)
1688 , Flag "distrust" (HasArg distrustPackage)
1689 , Flag "distrust-all-packages" (NoArg (setDynFlag Opt_DistrustAllPackages))
1690 ]
1691
1692 type TurnOnFlag = Bool -- True <=> we are turning the flag on
1693 -- False <=> we are turning the flag off
1694 turnOn :: TurnOnFlag; turnOn = True
1695 turnOff :: TurnOnFlag; turnOff = False
1696
1697 type FlagSpec flag
1698 = ( String -- Flag in string form
1699 , flag -- Flag in internal form
1700 , TurnOnFlag -> DynP ()) -- Extra action to run when the flag is found
1701 -- Typically, emit a warning or error
1702
1703 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
1704 -> String -- ^ The flag prefix
1705 -> (flag -> DynP ()) -- ^ What to do when the flag is found
1706 -> FlagSpec flag -- ^ Specification of this particular flag
1707 -> Flag (CmdLineP DynFlags)
1708 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1709 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1710
1711 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1712 deprecatedForExtension lang turn_on
1713 = deprecate ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1714 where
1715 flag | turn_on = lang
1716 | otherwise = "No"++lang
1717
1718 useInstead :: String -> TurnOnFlag -> DynP ()
1719 useInstead flag turn_on
1720 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1721 where
1722 no = if turn_on then "" else "no-"
1723
1724 nop :: TurnOnFlag -> DynP ()
1725 nop _ = return ()
1726
1727 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1728 fWarningFlags :: [FlagSpec WarningFlag]
1729 fWarningFlags = [
1730 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, nop ),
1731 ( "warn-dodgy-exports", Opt_WarnDodgyExports, nop ),
1732 ( "warn-dodgy-imports", Opt_WarnDodgyImports, nop ),
1733 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, nop ),
1734 ( "warn-hi-shadowing", Opt_WarnHiShadows, nop ),
1735 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, nop ),
1736 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, nop ),
1737 ( "warn-incomplete-uni-patterns", Opt_WarnIncompleteUniPatterns, nop ),
1738 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, nop ),
1739 ( "warn-missing-fields", Opt_WarnMissingFields, nop ),
1740 ( "warn-missing-import-lists", Opt_WarnMissingImportList, nop ),
1741 ( "warn-missing-methods", Opt_WarnMissingMethods, nop ),
1742 ( "warn-missing-signatures", Opt_WarnMissingSigs, nop ),
1743 ( "warn-missing-local-sigs", Opt_WarnMissingLocalSigs, nop ),
1744 ( "warn-name-shadowing", Opt_WarnNameShadowing, nop ),
1745 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, nop ),
1746 ( "warn-type-defaults", Opt_WarnTypeDefaults, nop ),
1747 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, nop ),
1748 ( "warn-unused-binds", Opt_WarnUnusedBinds, nop ),
1749 ( "warn-unused-imports", Opt_WarnUnusedImports, nop ),
1750 ( "warn-unused-matches", Opt_WarnUnusedMatches, nop ),
1751 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, nop ),
1752 ( "warn-deprecations", Opt_WarnWarningsDeprecations, nop ),
1753 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, nop ),
1754 ( "warn-orphans", Opt_WarnOrphans, nop ),
1755 ( "warn-identities", Opt_WarnIdentities, nop ),
1756 ( "warn-auto-orphans", Opt_WarnAutoOrphans, nop ),
1757 ( "warn-tabs", Opt_WarnTabs, nop ),
1758 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, nop ),
1759 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings, nop ),
1760 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, nop ),
1761 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, nop ),
1762 ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1763 ( "warn-unsafe", Opt_WarnUnsafe, setWarnUnsafe ),
1764 ( "warn-safe", Opt_WarnSafe, setWarnSafe ) ]
1765
1766 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1767 fFlags :: [FlagSpec DynFlag]
1768 fFlags = [
1769 ( "print-explicit-foralls", Opt_PrintExplicitForalls, nop ),
1770 ( "strictness", Opt_Strictness, nop ),
1771 ( "specialise", Opt_Specialise, nop ),
1772 ( "float-in", Opt_FloatIn, nop ),
1773 ( "static-argument-transformation", Opt_StaticArgumentTransformation, nop ),
1774 ( "full-laziness", Opt_FullLaziness, nop ),
1775 ( "liberate-case", Opt_LiberateCase, nop ),
1776 ( "spec-constr", Opt_SpecConstr, nop ),
1777 ( "cse", Opt_CSE, nop ),
1778 ( "pedantic-bottoms", Opt_PedanticBottoms, nop ),
1779 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, nop ),
1780 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, nop ),
1781 ( "expose-all-unfoldings", Opt_ExposeAllUnfoldings, nop ),
1782 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, nop ),
1783 ( "ignore-asserts", Opt_IgnoreAsserts, nop ),
1784 ( "do-eta-reduction", Opt_DoEtaReduction, nop ),
1785 ( "case-merge", Opt_CaseMerge, nop ),
1786 ( "unbox-strict-fields", Opt_UnboxStrictFields, nop ),
1787 ( "dicts-cheap", Opt_DictsCheap, nop ),
1788 ( "excess-precision", Opt_ExcessPrecision, nop ),
1789 ( "eager-blackholing", Opt_EagerBlackHoling, nop ),
1790 ( "print-bind-result", Opt_PrintBindResult, nop ),
1791 ( "force-recomp", Opt_ForceRecomp, nop ),
1792 ( "hpc-no-auto", Opt_Hpc_No_Auto, nop ),
1793 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1794 ( "enable-rewrite-rules", Opt_EnableRewriteRules, nop ),
1795 ( "break-on-exception", Opt_BreakOnException, nop ),
1796 ( "break-on-error", Opt_BreakOnError, nop ),
1797 ( "print-evld-with-show", Opt_PrintEvldWithShow, nop ),
1798 ( "print-bind-contents", Opt_PrintBindContents, nop ),
1799 ( "run-cps", Opt_RunCPS, nop ),
1800 ( "run-cpsz", Opt_RunCPSZ, nop ),
1801 ( "new-codegen", Opt_TryNewCodeGen, nop ),
1802 ( "vectorise", Opt_Vectorise, nop ),
1803 ( "regs-graph", Opt_RegsGraph, nop ),
1804 ( "regs-iterative", Opt_RegsIterative, nop ),
1805 ( "gen-manifest", Opt_GenManifest, nop ),
1806 ( "embed-manifest", Opt_EmbedManifest, nop ),
1807 ( "ext-core", Opt_EmitExternalCore, nop ),
1808 ( "shared-implib", Opt_SharedImplib, nop ),
1809 ( "ghci-sandbox", Opt_GhciSandbox, nop ),
1810 ( "ghci-history", Opt_GhciHistory, nop ),
1811 ( "helpful-errors", Opt_HelpfulErrors, nop ),
1812 ( "building-cabal-package", Opt_BuildingCabalPackage, nop ),
1813 ( "implicit-import-qualified", Opt_ImplicitImportQualified, nop ),
1814 ( "prof-count-entries", Opt_ProfCountEntries, nop ),
1815 ( "prof-cafs", Opt_AutoSccsOnIndividualCafs, nop )
1816 ]
1817
1818 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1819 fLangFlags :: [FlagSpec ExtensionFlag]
1820 fLangFlags = [
1821 ( "th", Opt_TemplateHaskell,
1822 deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1823 ( "fi", Opt_ForeignFunctionInterface,
1824 deprecatedForExtension "ForeignFunctionInterface" ),
1825 ( "ffi", Opt_ForeignFunctionInterface,
1826 deprecatedForExtension "ForeignFunctionInterface" ),
1827 ( "arrows", Opt_Arrows,
1828 deprecatedForExtension "Arrows" ),
1829 ( "implicit-prelude", Opt_ImplicitPrelude,
1830 deprecatedForExtension "ImplicitPrelude" ),
1831 ( "bang-patterns", Opt_BangPatterns,
1832 deprecatedForExtension "BangPatterns" ),
1833 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1834 deprecatedForExtension "MonomorphismRestriction" ),
1835 ( "mono-pat-binds", Opt_MonoPatBinds,
1836 deprecatedForExtension "MonoPatBinds" ),
1837 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1838 deprecatedForExtension "ExtendedDefaultRules" ),
1839 ( "implicit-params", Opt_ImplicitParams,
1840 deprecatedForExtension "ImplicitParams" ),
1841 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1842 deprecatedForExtension "ScopedTypeVariables" ),
1843 ( "parr", Opt_ParallelArrays,
1844 deprecatedForExtension "ParallelArrays" ),
1845 ( "PArr", Opt_ParallelArrays,
1846 deprecatedForExtension "ParallelArrays" ),
1847 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1848 deprecatedForExtension "OverlappingInstances" ),
1849 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1850 deprecatedForExtension "UndecidableInstances" ),
1851 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1852 deprecatedForExtension "IncoherentInstances" )
1853 ]
1854
1855 supportedLanguages :: [String]
1856 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1857
1858 supportedLanguageOverlays :: [String]
1859 supportedLanguageOverlays = [ name | (name, _, _) <- safeHaskellFlags ]
1860
1861 supportedExtensions :: [String]
1862 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1863
1864 supportedLanguagesAndExtensions :: [String]
1865 supportedLanguagesAndExtensions =
1866 supportedLanguages ++ supportedLanguageOverlays ++ supportedExtensions
1867
1868 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1869 languageFlags :: [FlagSpec Language]
1870 languageFlags = [
1871 ( "Haskell98", Haskell98, nop ),
1872 ( "Haskell2010", Haskell2010, nop )
1873 ]
1874
1875 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1876 -- They are used to place hard requirements on what GHC Haskell language
1877 -- features can be used.
1878 safeHaskellFlags :: [FlagSpec SafeHaskellMode]
1879 safeHaskellFlags = [mkF Sf_Unsafe, mkF Sf_Trustworthy, mkF Sf_Safe]
1880 where mkF flag = (showPpr flag, flag, nop)
1881
1882 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1883 xFlags :: [FlagSpec ExtensionFlag]
1884 xFlags = [
1885 ( "CPP", Opt_Cpp, nop ),
1886 ( "PostfixOperators", Opt_PostfixOperators, nop ),
1887 ( "TupleSections", Opt_TupleSections, nop ),
1888 ( "PatternGuards", Opt_PatternGuards, nop ),
1889 ( "UnicodeSyntax", Opt_UnicodeSyntax, nop ),
1890 ( "MagicHash", Opt_MagicHash, nop ),
1891 ( "PolymorphicComponents", Opt_PolymorphicComponents, nop ),
1892 ( "ExistentialQuantification", Opt_ExistentialQuantification, nop ),
1893 ( "KindSignatures", Opt_KindSignatures, nop ),
1894 ( "EmptyDataDecls", Opt_EmptyDataDecls, nop ),
1895 ( "ParallelListComp", Opt_ParallelListComp, nop ),
1896 ( "TransformListComp", Opt_TransformListComp, nop ),
1897 ( "MonadComprehensions", Opt_MonadComprehensions, nop),
1898 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, nop ),
1899 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, nop ),
1900 ( "InterruptibleFFI", Opt_InterruptibleFFI, nop ),
1901 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, nop ),
1902 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, nop ),
1903 ( "Rank2Types", Opt_Rank2Types, nop ),
1904 ( "RankNTypes", Opt_RankNTypes, nop ),
1905 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, nop),
1906 ( "TypeOperators", Opt_TypeOperators, nop ),
1907 ( "RecursiveDo", Opt_RecursiveDo, -- Enables 'mdo'
1908 deprecatedForExtension "DoRec"),
1909 ( "DoRec", Opt_DoRec, nop ), -- Enables 'rec' keyword
1910 ( "Arrows", Opt_Arrows, nop ),
1911 ( "ParallelArrays", Opt_ParallelArrays, nop ),
1912 ( "TemplateHaskell", Opt_TemplateHaskell, checkTemplateHaskellOk ),
1913 ( "QuasiQuotes", Opt_QuasiQuotes, nop ),
1914 ( "ImplicitPrelude", Opt_ImplicitPrelude, nop ),
1915 ( "RecordWildCards", Opt_RecordWildCards, nop ),
1916 ( "NamedFieldPuns", Opt_RecordPuns, nop ),
1917 ( "RecordPuns", Opt_RecordPuns,
1918 deprecatedForExtension "NamedFieldPuns" ),
1919 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, nop ),
1920 ( "OverloadedStrings", Opt_OverloadedStrings, nop ),
1921 ( "GADTs", Opt_GADTs, nop ),
1922 ( "GADTSyntax", Opt_GADTSyntax, nop ),
1923 ( "ViewPatterns", Opt_ViewPatterns, nop ),
1924 ( "TypeFamilies", Opt_TypeFamilies, nop ),
1925 ( "BangPatterns", Opt_BangPatterns, nop ),
1926 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, nop ),
1927 ( "NPlusKPatterns", Opt_NPlusKPatterns, nop ),
1928 ( "DoAndIfThenElse", Opt_DoAndIfThenElse, nop ),
1929 ( "RebindableSyntax", Opt_RebindableSyntax, nop ),
1930 ( "ConstraintKinds", Opt_ConstraintKinds, nop ),
1931 ( "PolyKinds", Opt_PolyKinds, nop ),
1932 ( "MonoPatBinds", Opt_MonoPatBinds,
1933 \ turn_on -> when turn_on $ deprecate "Experimental feature now removed; has no effect" ),
1934 ( "ExplicitForAll", Opt_ExplicitForAll, nop ),
1935 ( "AlternativeLayoutRule", Opt_AlternativeLayoutRule, nop ),
1936 ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1937 ( "DatatypeContexts", Opt_DatatypeContexts,
1938 \ turn_on -> when turn_on $ deprecate "It was widely considered a misfeature, and has been removed from the Haskell language." ),
1939 ( "NondecreasingIndentation", Opt_NondecreasingIndentation, nop ),
1940 ( "RelaxedLayout", Opt_RelaxedLayout, nop ),
1941 ( "TraditionalRecordSyntax", Opt_TraditionalRecordSyntax, nop ),
1942 ( "MonoLocalBinds", Opt_MonoLocalBinds, nop ),
1943 ( "RelaxedPolyRec", Opt_RelaxedPolyRec,
1944 \ turn_on -> if not turn_on
1945 then deprecate "You can't turn off RelaxedPolyRec any more"
1946 else return () ),
1947 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, nop ),
1948 ( "ImplicitParams", Opt_ImplicitParams, nop ),
1949 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, nop ),
1950
1951 ( "PatternSignatures", Opt_ScopedTypeVariables,
1952 deprecatedForExtension "ScopedTypeVariables" ),
1953
1954 ( "UnboxedTuples", Opt_UnboxedTuples, nop ),
1955 ( "StandaloneDeriving", Opt_StandaloneDeriving, nop ),
1956 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, nop ),
1957 ( "DeriveFunctor", Opt_DeriveFunctor, nop ),
1958 ( "DeriveTraversable", Opt_DeriveTraversable, nop ),
1959 ( "DeriveFoldable", Opt_DeriveFoldable, nop ),
1960 ( "DeriveGeneric", Opt_DeriveGeneric, nop ),
1961 ( "DefaultSignatures", Opt_DefaultSignatures, nop ),
1962 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, nop ),
1963 ( "FlexibleContexts", Opt_FlexibleContexts, nop ),
1964 ( "FlexibleInstances", Opt_FlexibleInstances, nop ),
1965 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, nop ),
1966 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, nop ),
1967 ( "FunctionalDependencies", Opt_FunctionalDependencies, nop ),
1968 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, setGenDeriving ),
1969 ( "OverlappingInstances", Opt_OverlappingInstances, nop ),
1970 ( "UndecidableInstances", Opt_UndecidableInstances, nop ),
1971 ( "IncoherentInstances", Opt_IncoherentInstances, nop ),
1972 ( "PackageImports", Opt_PackageImports, nop )
1973 ]
1974
1975 defaultFlags :: [DynFlag]
1976 defaultFlags
1977 = [ Opt_AutoLinkPackages,
1978 Opt_ReadUserPackageConf,
1979
1980 Opt_SharedImplib,
1981
1982 #if GHC_DEFAULT_NEW_CODEGEN
1983 Opt_TryNewCodeGen,
1984 #endif
1985
1986 Opt_GenManifest,
1987 Opt_EmbedManifest,
1988 Opt_PrintBindContents,
1989 Opt_GhciSandbox,
1990 Opt_GhciHistory,
1991 Opt_HelpfulErrors,
1992 Opt_ProfCountEntries
1993 ]
1994
1995 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1996 -- The default -O0 options
1997
1998 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1999 impliedFlags
2000 = [ (Opt_RankNTypes, turnOn, Opt_ExplicitForAll)
2001 , (Opt_Rank2Types, turnOn, Opt_ExplicitForAll)
2002 , (Opt_ScopedTypeVariables, turnOn, Opt_ExplicitForAll)
2003 , (Opt_LiberalTypeSynonyms, turnOn, Opt_ExplicitForAll)
2004 , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
2005 , (Opt_PolymorphicComponents, turnOn, Opt_ExplicitForAll)
2006 , (Opt_FlexibleInstances, turnOn, Opt_TypeSynonymInstances)
2007 , (Opt_FunctionalDependencies, turnOn, Opt_MultiParamTypeClasses)
2008
2009 , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude) -- NB: turn off!
2010
2011 , (Opt_GADTs, turnOn, Opt_GADTSyntax)
2012 , (Opt_GADTs, turnOn, Opt_MonoLocalBinds)
2013 , (Opt_TypeFamilies, turnOn, Opt_MonoLocalBinds)
2014
2015 , (Opt_TypeFamilies, turnOn, Opt_KindSignatures) -- Type families use kind signatures
2016 -- all over the place
2017
2018 , (Opt_PolyKinds, turnOn, Opt_KindSignatures)
2019
2020 , (Opt_ImpredicativeTypes, turnOn, Opt_RankNTypes)
2021
2022 -- Record wild-cards implies field disambiguation
2023 -- Otherwise if you write (C {..}) you may well get
2024 -- stuff like " 'a' not in scope ", which is a bit silly
2025 -- if the compiler has just filled in field 'a' of constructor 'C'
2026 , (Opt_RecordWildCards, turnOn, Opt_DisambiguateRecordFields)
2027
2028 , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
2029 ]
2030
2031 optLevelFlags :: [([Int], DynFlag)]
2032 optLevelFlags
2033 = [ ([0], Opt_IgnoreInterfacePragmas)
2034 , ([0], Opt_OmitInterfacePragmas)
2035
2036 , ([1,2], Opt_IgnoreAsserts)
2037 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
2038 -- in PrelRules
2039 , ([1,2], Opt_DoEtaReduction)
2040 , ([1,2], Opt_CaseMerge)
2041 , ([1,2], Opt_Strictness)
2042 , ([1,2], Opt_CSE)
2043 , ([1,2], Opt_FullLaziness)
2044 , ([1,2], Opt_Specialise)
2045 , ([1,2], Opt_FloatIn)
2046
2047 , ([2], Opt_LiberateCase)
2048 , ([2], Opt_SpecConstr)
2049 , ([2], Opt_RegsGraph)
2050
2051 -- , ([2], Opt_StaticArgumentTransformation)
2052 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
2053 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
2054 -- several improvements to the heuristics, and I'm concerned that without
2055 -- those changes SAT will interfere with some attempts to write "high
2056 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
2057 -- this year. In particular, the version in HEAD lacks the tail call
2058 -- criterion, so many things that look like reasonable loops will be
2059 -- turned into functions with extra (unneccesary) thunk creation.
2060
2061 , ([0,1,2], Opt_DoLambdaEtaExpansion)
2062 -- This one is important for a tiresome reason:
2063 -- we want to make sure that the bindings for data
2064 -- constructors are eta-expanded. This is probably
2065 -- a good thing anyway, but it seems fragile.
2066 ]
2067
2068 -- -----------------------------------------------------------------------------
2069 -- Standard sets of warning options
2070
2071 standardWarnings :: [WarningFlag]
2072 standardWarnings
2073 = [ Opt_WarnWarningsDeprecations,
2074 Opt_WarnDeprecatedFlags,
2075 Opt_WarnUnrecognisedPragmas,
2076 Opt_WarnOverlappingPatterns,
2077 Opt_WarnMissingFields,
2078 Opt_WarnMissingMethods,
2079 Opt_WarnDuplicateExports,
2080 Opt_WarnLazyUnliftedBindings,
2081 Opt_WarnDodgyForeignImports,
2082 Opt_WarnWrongDoBind,
2083 Opt_WarnAlternativeLayoutRuleTransitional
2084 ]
2085
2086 minusWOpts :: [WarningFlag]
2087 -- Things you get with -W
2088 minusWOpts
2089 = standardWarnings ++
2090 [ Opt_WarnUnusedBinds,
2091 Opt_WarnUnusedMatches,
2092 Opt_WarnUnusedImports,
2093 Opt_WarnIncompletePatterns,
2094 Opt_WarnDodgyExports,
2095 Opt_WarnDodgyImports
2096 ]
2097
2098 minusWallOpts :: [WarningFlag]
2099 -- Things you get with -Wall
2100 minusWallOpts
2101 = minusWOpts ++
2102 [ Opt_WarnTypeDefaults,
2103 Opt_WarnNameShadowing,
2104 Opt_WarnMissingSigs,
2105 Opt_WarnHiShadows,
2106 Opt_WarnOrphans,
2107 Opt_WarnUnusedDoBind
2108 ]
2109
2110 enableGlasgowExts :: DynP ()
2111 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
2112 mapM_ setExtensionFlag glasgowExtsFlags
2113
2114 disableGlasgowExts :: DynP ()
2115 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
2116 mapM_ unSetExtensionFlag glasgowExtsFlags
2117
2118 glasgowExtsFlags :: [ExtensionFlag]
2119 glasgowExtsFlags = [
2120 Opt_ForeignFunctionInterface
2121 , Opt_UnliftedFFITypes
2122 , Opt_ImplicitParams
2123 , Opt_ScopedTypeVariables
2124 , Opt_UnboxedTuples
2125 , Opt_TypeSynonymInstances
2126 , Opt_StandaloneDeriving
2127 , Opt_DeriveDataTypeable
2128 , Opt_DeriveFunctor
2129 , Opt_DeriveFoldable
2130 , Opt_DeriveTraversable
2131 , Opt_DeriveGeneric
2132 , Opt_FlexibleContexts
2133 , Opt_FlexibleInstances
2134 , Opt_ConstrainedClassMethods
2135 , Opt_MultiParamTypeClasses
2136 , Opt_FunctionalDependencies
2137 , Opt_MagicHash
2138 , Opt_PolymorphicComponents
2139 , Opt_ExistentialQuantification
2140 , Opt_UnicodeSyntax
2141 , Opt_PostfixOperators
2142 , Opt_PatternGuards
2143 , Opt_LiberalTypeSynonyms
2144 , Opt_RankNTypes
2145 , Opt_TypeOperators
2146 , Opt_DoRec
2147 , Opt_ParallelListComp
2148 , Opt_EmptyDataDecls
2149 , Opt_KindSignatures
2150 , Opt_GeneralizedNewtypeDeriving ]
2151
2152 #ifdef GHCI
2153 -- Consult the RTS to find whether GHC itself has been built profiled
2154 -- If so, you can't use Template Haskell
2155 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
2156
2157 rtsIsProfiled :: Bool
2158 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
2159 #endif
2160
2161 setWarnSafe :: Bool -> DynP ()
2162 setWarnSafe True = getCurLoc >>= \l -> upd (\d -> d { warnSafeOnLoc = l })
2163 setWarnSafe False = return ()
2164
2165 setWarnUnsafe :: Bool -> DynP ()
2166 setWarnUnsafe True = getCurLoc >>= \l -> upd (\d -> d { warnUnsafeOnLoc = l })
2167 setWarnUnsafe False = return ()
2168
2169 setGenDeriving :: Bool -> DynP ()
2170 setGenDeriving True = getCurLoc >>= \l -> upd (\d -> d { newDerivOnLoc = l })
2171 setGenDeriving False = return ()
2172
2173 checkTemplateHaskellOk :: Bool -> DynP ()
2174 #ifdef GHCI
2175 checkTemplateHaskellOk turn_on
2176 | turn_on && rtsIsProfiled
2177 = addErr "You can't use Template Haskell with a profiled compiler"
2178 | otherwise
2179 = getCurLoc >>= \l -> upd (\d -> d { thOnLoc = l })
2180 #else
2181 -- In stage 1 we don't know that the RTS has rts_isProfiled,
2182 -- so we simply say "ok". It doesn't matter because TH isn't
2183 -- available in stage 1 anyway.
2184 checkTemplateHaskellOk _ = return ()
2185 #endif
2186
2187 {- **********************************************************************
2188 %* *
2189 DynFlags constructors
2190 %* *
2191 %********************************************************************* -}
2192
2193 type DynP = EwM (CmdLineP DynFlags)
2194
2195 upd :: (DynFlags -> DynFlags) -> DynP ()
2196 upd f = liftEwM (do dflags <- getCmdLineState
2197 putCmdLineState $! f dflags)
2198
2199 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
2200 updM f = do dflags <- liftEwM getCmdLineState
2201 dflags' <- f dflags
2202 liftEwM $ putCmdLineState $! dflags'
2203
2204 --------------- Constructor functions for OptKind -----------------
2205 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2206 noArg fn = NoArg (upd fn)
2207
2208 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
2209 noArgM fn = NoArg (updM fn)
2210
2211 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
2212 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
2213
2214 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2215 hasArg fn = HasArg (upd . fn)
2216
2217 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
2218 hasArgDF fn deprec = HasArg (\s -> do upd (fn s)
2219 deprecate deprec)
2220
2221 sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2222 sepArg fn = SepArg (upd . fn)
2223
2224 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2225 intSuffix fn = IntSuffix (\n -> upd (fn n))
2226
2227 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
2228 -> OptKind (CmdLineP DynFlags)
2229 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
2230
2231 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
2232 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
2233
2234 --------------------------
2235 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2236 setDynFlag f = upd (\dfs -> dopt_set dfs f)
2237 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2238
2239 --------------------------
2240 setWarningFlag, unSetWarningFlag :: WarningFlag -> DynP ()
2241 setWarningFlag f = upd (\dfs -> wopt_set dfs f)
2242 unSetWarningFlag f = upd (\dfs -> wopt_unset dfs f)
2243
2244 --------------------------
2245 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
2246 setExtensionFlag f = do upd (\dfs -> xopt_set dfs f)
2247 sequence_ deps
2248 where
2249 deps = [ if turn_on then setExtensionFlag d
2250 else unSetExtensionFlag d
2251 | (f', turn_on, d) <- impliedFlags, f' == f ]
2252 -- When you set f, set the ones it implies
2253 -- NB: use setExtensionFlag recursively, in case the implied flags
2254 -- implies further flags
2255
2256 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
2257 -- When you un-set f, however, we don't un-set the things it implies
2258 -- (except for -fno-glasgow-exts, which is treated specially)
2259
2260 --------------------------
2261 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2262 alterSettings f dflags = dflags { settings = f (settings dflags) }
2263
2264 --------------------------
2265 setDumpFlag' :: DynFlag -> DynP ()
2266 setDumpFlag' dump_flag
2267 = do setDynFlag dump_flag
2268 when want_recomp forceRecompile
2269 where
2270 -- Certain dumpy-things are really interested in what's going
2271 -- on during recompilation checking, so in those cases we
2272 -- don't want to turn it off.
2273 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2274 Opt_D_dump_hi_diffs]
2275
2276 forceRecompile :: DynP ()
2277 -- Whenver we -ddump, force recompilation (by switching off the
2278 -- recompilation checker), else you don't see the dump! However,
2279 -- don't switch it off in --make mode, else *everything* gets
2280 -- recompiled which probably isn't what you want
2281 forceRecompile = do dfs <- liftEwM getCmdLineState
2282 when (force_recomp dfs) (setDynFlag Opt_ForceRecomp)
2283 where
2284 force_recomp dfs = isOneShot (ghcMode dfs)
2285
2286 setVerboseCore2Core :: DynP ()
2287 setVerboseCore2Core = do forceRecompile
2288 setDynFlag Opt_D_verbose_core2core
2289 upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2290
2291 setDumpSimplPhases :: String -> DynP ()
2292 setDumpSimplPhases s = do forceRecompile
2293 upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2294 where
2295 spec = case s of { ('=' : s') -> s'; _ -> s }
2296
2297 setVerbosity :: Maybe Int -> DynP ()
2298 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2299
2300 addCmdlineHCInclude :: String -> DynP ()
2301 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2302
2303 extraPkgConf_ :: FilePath -> DynP ()
2304 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2305
2306 exposePackage, exposePackageId, hidePackage, ignorePackage,
2307 trustPackage, distrustPackage :: String -> DynP ()
2308 exposePackage p =
2309 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2310 exposePackageId p =
2311 upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2312 hidePackage p =
2313 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2314 ignorePackage p =
2315 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2316 trustPackage p = exposePackage p >> -- both trust and distrust also expose a package
2317 upd (\s -> s{ packageFlags = TrustPackage p : packageFlags s })
2318 distrustPackage p = exposePackage p >>
2319 upd (\s -> s{ packageFlags = DistrustPackage p : packageFlags s })
2320
2321 setPackageName :: String -> DynFlags -> DynFlags
2322 setPackageName p s = s{ thisPackage = stringToPackageId p }
2323
2324 -- If we're linking a binary, then only targets that produce object
2325 -- code are allowed (requests for other target types are ignored).
2326 setTarget :: HscTarget -> DynP ()
2327 setTarget l = upd set
2328 where
2329 set dfs
2330 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2331 | otherwise = dfs
2332
2333 -- Changes the target only if we're compiling object code. This is
2334 -- used by -fasm and -fllvm, which switch from one to the other, but
2335 -- not from bytecode to object-code. The idea is that -fasm/-fllvm
2336 -- can be safely used in an OPTIONS_GHC pragma.
2337 setObjTarget :: HscTarget -> DynP ()
2338 setObjTarget l = updM set
2339 where
2340 set dflags
2341 | isObjectTarget (hscTarget dflags)
2342 = case l of
2343 HscC
2344 | cGhcUnregisterised /= "YES" ->
2345 do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2346 return dflags
2347 HscAsm
2348 | cGhcWithNativeCodeGen /= "YES" ->
2349 do addWarn ("Compiler has no native codegen, so ignoring " ++
2350 flag)
2351 return dflags
2352 HscLlvm
2353 | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2354 (not opt_Static || opt_PIC)
2355 ->
2356 do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2357 return dflags
2358 _ -> return $ dflags { hscTarget = l }
2359 | otherwise = return dflags
2360 where platform = targetPlatform dflags
2361 arch = platformArch platform
2362 os = platformOS platform
2363 flag = showHscTargetFlag l
2364
2365 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2366 setOptLevel n dflags
2367 | hscTarget dflags == HscInterpreted && n > 0
2368 = do addWarn "-O conflicts with --interactive; -O ignored."
2369 return dflags
2370 | otherwise
2371 = return (updOptLevel n dflags)
2372
2373
2374 -- -Odph is equivalent to
2375 --
2376 -- -O2 optimise as much as possible
2377 -- -fmax-simplifier-iterations20 this is necessary sometimes
2378 -- -fsimplifier-phases=3 we use an additional simplifier phase for fusion
2379 --
2380 setDPHOpt :: DynFlags -> DynP DynFlags
2381 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2382 , simplPhases = 3
2383 })
2384
2385 setMainIs :: String -> DynP ()
2386 setMainIs arg
2387 | not (null main_fn) && isLower (head main_fn)
2388 -- The arg looked like "Foo.Bar.baz"
2389 = upd $ \d -> d{ mainFunIs = Just main_fn,
2390 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2391
2392 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2393 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2394
2395 | otherwise -- The arg looked like "baz"
2396 = upd $ \d -> d{ mainFunIs = Just arg }
2397 where
2398 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2399
2400 -----------------------------------------------------------------------------
2401 -- Paths & Libraries
2402
2403 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2404
2405 -- -i on its own deletes the import paths
2406 addImportPath "" = upd (\s -> s{importPaths = []})
2407 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2408
2409 addLibraryPath p =
2410 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2411
2412 addIncludePath p =
2413 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2414
2415 addFrameworkPath p =
2416 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2417
2418 #ifndef mingw32_TARGET_OS
2419 split_marker :: Char
2420 split_marker = ':' -- not configurable (ToDo)
2421 #endif
2422
2423 splitPathList :: String -> [String]
2424 splitPathList s = filter notNull (splitUp s)
2425 -- empty paths are ignored: there might be a trailing
2426 -- ':' in the initial list, for example. Empty paths can
2427 -- cause confusion when they are translated into -I options
2428 -- for passing to gcc.
2429 where
2430 #ifndef mingw32_TARGET_OS
2431 splitUp xs = split split_marker xs
2432 #else
2433 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2434 --
2435 -- That is, if "foo:bar:baz" is used, this interpreted as
2436 -- consisting of three entries, 'foo', 'bar', 'baz'.
2437 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2438 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2439 --
2440 -- Notice that no attempt is made to fully replace the 'standard'
2441 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2442 -- that this will cause too much breakage for users & ':' will
2443 -- work fine even with DOS paths, if you're not insisting on being silly.
2444 -- So, use either.
2445 splitUp [] = []
2446 splitUp (x:':':div:xs) | div `elem` dir_markers
2447 = ((x:':':div:p): splitUp rs)
2448 where
2449 (p,rs) = findNextPath xs
2450 -- we used to check for existence of the path here, but that
2451 -- required the IO monad to be threaded through the command-line
2452 -- parser which is quite inconvenient. The
2453 splitUp xs = cons p (splitUp rs)
2454 where
2455 (p,rs) = findNextPath xs
2456
2457 cons "" xs = xs
2458 cons x xs = x:xs
2459
2460 -- will be called either when we've consumed nought or the
2461 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2462 -- finding the next split marker.
2463 findNextPath xs =
2464 case break (`elem` split_markers) xs of
2465 (p, _:ds) -> (p, ds)
2466 (p, xs) -> (p, xs)
2467
2468 split_markers :: [Char]
2469 split_markers = [':', ';']
2470
2471 dir_markers :: [Char]
2472 dir_markers = ['/', '\\']
2473 #endif
2474
2475 -- -----------------------------------------------------------------------------
2476 -- tmpDir, where we store temporary files.
2477
2478 setTmpDir :: FilePath -> DynFlags -> DynFlags
2479 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2480 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2481 -- seem necessary now --SDM 7/2/2008
2482
2483 -----------------------------------------------------------------------------
2484 -- RTS opts
2485
2486 setRtsOpts :: String -> DynP ()
2487 setRtsOpts arg = upd $ \ d -> d {rtsOpts = Just arg}
2488
2489 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2490 setRtsOptsEnabled arg = upd $ \ d -> d {rtsOptsEnabled = arg}
2491
2492 -----------------------------------------------------------------------------
2493 -- Hpc stuff
2494
2495 setOptHpcDir :: String -> DynP ()
2496 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2497
2498 -----------------------------------------------------------------------------
2499 -- Via-C compilation stuff
2500
2501 -- There are some options that we need to pass to gcc when compiling
2502 -- Haskell code via C, but are only supported by recent versions of
2503 -- gcc. The configure script decides which of these options we need,
2504 -- and puts them in the "settings" file in $topdir. The advantage of
2505 -- having these in a separate file is that the file can be created at
2506 -- install-time depending on the available gcc version, and even
2507 -- re-generated later if gcc is upgraded.
2508 --
2509 -- The options below are not dependent on the version of gcc, only the
2510 -- platform.
2511
2512 picCCOpts :: DynFlags -> [String]
2513 picCCOpts dflags
2514 = case platformOS (targetPlatform dflags) of
2515 OSDarwin
2516 -- Apple prefers to do things the other way round.
2517 -- PIC is on by default.
2518 -- -mdynamic-no-pic:
2519 -- Turn off PIC code generation.
2520 -- -fno-common:
2521 -- Don't generate "common" symbols - these are unwanted
2522 -- in dynamic libraries.
2523
2524 | opt_PIC -> ["-fno-common", "-U __PIC__", "-D__PIC__"]
2525 | otherwise -> ["-mdynamic-no-pic"]
2526 OSMinGW32 -- no -fPIC for Windows
2527 | opt_PIC -> ["-U __PIC__", "-D__PIC__"]
2528 | otherwise -> []
2529 _
2530 -- we need -fPIC for C files when we are compiling with -dynamic,
2531 -- otherwise things like stub.c files don't get compiled
2532 -- correctly. They need to reference data in the Haskell
2533 -- objects, but can't without -fPIC. See
2534 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2535 | opt_PIC || not opt_Static -> ["-fPIC", "-U __PIC__", "-D__PIC__"]
2536 | otherwise -> []
2537
2538 -- -----------------------------------------------------------------------------
2539 -- Splitting
2540
2541 can_split :: Bool
2542 can_split = cSupportsSplitObjs == "YES"
2543
2544 -- -----------------------------------------------------------------------------
2545 -- Compiler Info
2546
2547 compilerInfo :: DynFlags -> [(String, String)]
2548 compilerInfo dflags
2549 = -- We always make "Project name" be first to keep parsing in
2550 -- other languages simple, i.e. when looking for other fields,
2551 -- you don't have to worry whether there is a leading '[' or not
2552 ("Project name", cProjectName)
2553 -- Next come the settings, so anything else can be overridden
2554 -- in the settings file (as "lookup" uses the first match for the
2555 -- key)
2556 : rawSettings dflags
2557 ++ [("Project version", cProjectVersion),
2558 ("Booter version", cBooterVersion),
2559 ("Stage", cStage),
2560 ("Build platform", cBuildPlatformString),
2561 ("Host platform", cHostPlatformString),
2562 ("Target platform", cTargetPlatformString),
2563 ("Have interpreter", cGhcWithInterpreter),
2564 ("Object splitting supported", cSupportsSplitObjs),
2565 ("Have native code generator", cGhcWithNativeCodeGen),
2566 ("Support SMP", cGhcWithSMP),
2567 ("Unregisterised", cGhcUnregisterised),
2568 ("Tables next to code", cGhcEnableTablesNextToCode),
2569 ("RTS ways", cGhcRTSWays),
2570 ("Leading underscore", cLeadingUnderscore),
2571 ("Debug on", show debugIsOn),
2572 ("LibDir", topDir dflags),
2573 ("Global Package DB", systemPackageConfig dflags),
2574 ("Gcc Linker flags", show cGccLinkerOpts),
2575 ("Ld Linker flags", show cLdLinkerOpts)
2576 ]
2577