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