ghc/compiler/main/CmdLineOpts.lhs

   1
   2 % (c) The University of Glasgow, 1996-2000
   3 %
   4 \section[CmdLineOpts]{Things to do with command-line options}
   5
   6 \begin{code}
   7
   8 module CmdLineOpts (
   9         CoreToDo(..), buildCoreToDo, StgToDo(..),
  10         SimplifierSwitch(..),
  11         SimplifierMode(..), FloatOutSwitches(..),
  12
  13         HscTarget(..),
  14         DynFlag(..),    -- needed non-abstractly by DriverFlags
  15         DynFlags(..),
  16         PackageFlag(..),
  17
  18         v_Static_hsc_opts,
  19
  20         isStaticHscFlag,
  21
  22         -- Manipulating DynFlags
  23         defaultDynFlags,                -- DynFlags
  24         dopt,                           -- DynFlag -> DynFlags -> Bool
  25         dopt_set, dopt_unset,           -- DynFlags -> DynFlag -> DynFlags
  26         dopt_CoreToDo,                  -- DynFlags -> [CoreToDo]
  27         dopt_StgToDo,                   -- DynFlags -> [StgToDo]
  28         dopt_HscTarget,                 -- DynFlags -> HscTarget
  29         dopt_OutName,                   -- DynFlags -> String
  30         getOpts,                        -- (DynFlags -> [a]) -> IO [a]
  31         getVerbFlag,
  32         updOptLevel,
  33
  34         -- sets of warning opts
  35         minusWOpts,
  36         minusWallOpts,
  37
  38         -- Output style options
  39         opt_PprUserLength,
  40         opt_PprStyle_Debug,
  41
  42         -- profiling opts
  43         opt_AutoSccsOnAllToplevs,
  44         opt_AutoSccsOnExportedToplevs,
  45         opt_AutoSccsOnIndividualCafs,
  46         opt_SccProfilingOn,
  47         opt_DoTickyProfiling,
  48
  49         -- language opts
  50         opt_DictsStrict,
  51         opt_MaxContextReductionDepth,
  52         opt_IrrefutableTuples,
  53         opt_Parallel,
  54         opt_SMP,
  55         opt_RuntimeTypes,
  56         opt_Flatten,
  57
  58         -- optimisation opts
  59         opt_NoMethodSharing,
  60         opt_NoStateHack,
  61         opt_LiberateCaseThreshold,
  62         opt_CprOff,
  63         opt_RulesOff,
  64         opt_SimplNoPreInlining,
  65         opt_SimplExcessPrecision,
  66         opt_MaxWorkerArgs,
  67
  68         -- Unfolding control
  69         opt_UF_CreationThreshold,
  70         opt_UF_UseThreshold,
  71         opt_UF_FunAppDiscount,
  72         opt_UF_KeenessFactor,
  73         opt_UF_UpdateInPlace,
  74         opt_UF_DearOp,
  75
  76         -- misc opts
  77         opt_ErrorSpans,
  78         opt_EmitCExternDecls,
  79         opt_EnsureSplittableC,
  80         opt_GranMacros,
  81         opt_HiVersion,
  82         opt_HistorySize,
  83         opt_OmitBlackHoling,
  84         opt_Static,
  85         opt_Unregisterised,
  86         opt_EmitExternalCore,
  87         opt_PIC
  88     ) where
  89
  90 #include "HsVersions.h"
  91
  92 import {-# SOURCE #-} Packages (PackageState)
  93 import DriverPhases     ( HscTarget(..) )
  94 import Constants        -- Default values for some flags
  95 import Util
  96 import FastString       ( FastString, mkFastString )
  97 import Config
  98 import Maybes           ( firstJust )
  99
 100 import Panic            ( ghcError, GhcException(UsageError) )
 101 import GLAEXTS
 102 import DATA_IOREF       ( IORef, readIORef )
 103 import UNSAFE_IO        ( unsafePerformIO )
 104 \end{code}
 105
 106 %************************************************************************
 107 %*                                                                      *
 108 \subsection{Command-line options}
 109 %*                                                                      *
 110 %************************************************************************
 111
 112 The hsc command-line options are split into two categories:
 113
 114   - static flags
 115   - dynamic flags
 116
 117 Static flags are represented by top-level values of type Bool or Int,
 118 for example.  They therefore have the same value throughout the
 119 invocation of hsc.
 120
 121 Dynamic flags are represented by an abstract type, DynFlags, which is
 122 passed into hsc by the compilation manager for every compilation.
 123 Dynamic flags are those that change on a per-compilation basis,
 124 perhaps because they may be present in the OPTIONS pragma at the top
 125 of a module.
 126
 127 Other flag-related blurb:
 128
 129 A list of {\em ToDo}s is things to be done in a particular part of
 130 processing.  A (fictitious) example for the Core-to-Core simplifier
 131 might be: run the simplifier, then run the strictness analyser, then
 132 run the simplifier again (three ``todos'').
 133
 134 There are three ``to-do processing centers'' at the moment.  In the
 135 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
 136 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
 137 (\tr{simplStg/SimplStg.lhs}).
 138
 139 %************************************************************************
 140 %*                                                                      *
 141 \subsection{Datatypes associated with command-line options}
 142 %*                                                                      *
 143 %************************************************************************
 144
 145 \begin{code}
 146 data CoreToDo           -- These are diff core-to-core passes,
 147                         -- which may be invoked in any order,
 148                         -- as many times as you like.
 149
 150   = CoreDoSimplify      -- The core-to-core simplifier.
 151         SimplifierMode
 152         [SimplifierSwitch]
 153                         -- Each run of the simplifier can take a different
 154                         -- set of simplifier-specific flags.
 155   | CoreDoFloatInwards
 156   | CoreDoFloatOutwards FloatOutSwitches
 157   | CoreLiberateCase
 158   | CoreDoPrintCore
 159   | CoreDoStaticArgs
 160   | CoreDoStrictness
 161   | CoreDoWorkerWrapper
 162   | CoreDoSpecialising
 163   | CoreDoSpecConstr
 164   | CoreDoOldStrictness
 165   | CoreDoGlomBinds
 166   | CoreCSE
 167   | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
 168                                                 -- matching this string
 169
 170   | CoreDoNothing        -- useful when building up lists of these things
 171 \end{code}
 172
 173 \begin{code}
 174 data StgToDo
 175   = StgDoMassageForProfiling  -- should be (next to) last
 176   -- There's also setStgVarInfo, but its absolute "lastness"
 177   -- is so critical that it is hardwired in (no flag).
 178   | D_stg_stats
 179 \end{code}
 180
 181 \begin{code}
 182 data SimplifierMode             -- See comments in SimplMonad
 183   = SimplGently
 184   | SimplPhase Int
 185
 186 data SimplifierSwitch
 187   = MaxSimplifierIterations Int
 188   | NoCaseOfCase
 189
 190 data FloatOutSwitches
 191   = FloatOutSw  Bool    -- True <=> float lambdas to top level
 192                 Bool    -- True <=> float constants to top level,
 193                         --          even if they do not escape a lambda
 194 \end{code}
 195
 196 %************************************************************************
 197 %*                                                                      *
 198 \subsection{Dynamic command-line options}
 199 %*                                                                      *
 200 %************************************************************************
 201
 202 \begin{code}
 203 data DynFlag
 204
 205    -- debugging flags
 206    = Opt_D_dump_cmm
 207    | Opt_D_dump_asm
 208    | Opt_D_dump_cpranal
 209    | Opt_D_dump_deriv
 210    | Opt_D_dump_ds
 211    | Opt_D_dump_flatC
 212    | Opt_D_dump_foreign
 213    | Opt_D_dump_inlinings
 214    | Opt_D_dump_occur_anal
 215    | Opt_D_dump_parsed
 216    | Opt_D_dump_rn
 217    | Opt_D_dump_simpl
 218    | Opt_D_dump_simpl_iterations
 219    | Opt_D_dump_spec
 220    | Opt_D_dump_prep
 221    | Opt_D_dump_stg
 222    | Opt_D_dump_stranal
 223    | Opt_D_dump_tc
 224    | Opt_D_dump_types
 225    | Opt_D_dump_rules
 226    | Opt_D_dump_cse
 227    | Opt_D_dump_worker_wrapper
 228    | Opt_D_dump_rn_trace
 229    | Opt_D_dump_rn_stats
 230    | Opt_D_dump_opt_cmm
 231    | Opt_D_dump_simpl_stats
 232    | Opt_D_dump_tc_trace
 233    | Opt_D_dump_if_trace
 234    | Opt_D_dump_splices
 235    | Opt_D_dump_BCOs
 236    | Opt_D_dump_vect
 237    | Opt_D_source_stats
 238    | Opt_D_verbose_core2core
 239    | Opt_D_verbose_stg2stg
 240    | Opt_D_dump_hi
 241    | Opt_D_dump_hi_diffs
 242    | Opt_D_dump_minimal_imports
 243    | Opt_DoCoreLinting
 244    | Opt_DoStgLinting
 245    | Opt_DoCmmLinting
 246
 247    | Opt_WarnIsError            -- -Werror; makes warnings fatal
 248    | Opt_WarnDuplicateExports
 249    | Opt_WarnHiShadows
 250    | Opt_WarnIncompletePatterns
 251    | Opt_WarnIncompletePatternsRecUpd
 252    | Opt_WarnMissingFields
 253    | Opt_WarnMissingMethods
 254    | Opt_WarnMissingSigs
 255    | Opt_WarnNameShadowing
 256    | Opt_WarnOverlappingPatterns
 257    | Opt_WarnSimplePatterns
 258    | Opt_WarnTypeDefaults
 259    | Opt_WarnUnusedBinds
 260    | Opt_WarnUnusedImports
 261    | Opt_WarnUnusedMatches
 262    | Opt_WarnDeprecations
 263    | Opt_WarnDodgyImports
 264    | Opt_WarnOrphans
 265
 266    -- language opts
 267    | Opt_AllowOverlappingInstances
 268    | Opt_AllowUndecidableInstances
 269    | Opt_AllowIncoherentInstances
 270    | Opt_MonomorphismRestriction
 271    | Opt_GlasgowExts
 272    | Opt_FFI
 273    | Opt_PArr                          -- syntactic support for parallel arrays
 274    | Opt_Arrows                        -- Arrow-notation syntax
 275    | Opt_TH
 276    | Opt_ImplicitParams
 277    | Opt_Generics
 278    | Opt_ImplicitPrelude
 279    | Opt_ScopedTypeVariables
 280
 281    -- optimisation opts
 282    | Opt_Strictness
 283    | Opt_FullLaziness
 284    | Opt_CSE
 285    | Opt_IgnoreInterfacePragmas
 286    | Opt_OmitInterfacePragmas
 287    | Opt_DoLambdaEtaExpansion
 288    | Opt_IgnoreAsserts
 289    | Opt_DoEtaReduction
 290    | Opt_CaseMerge
 291    | Opt_UnboxStrictFields
 292
 293    deriving (Eq)
 294
 295 data DynFlags = DynFlags {
 296   coreToDo              :: Maybe [CoreToDo], -- reserved for use with -Ofile
 297   stgToDo               :: [StgToDo],
 298   hscTarget             :: HscTarget,
 299   hscOutName            :: String,      -- name of the output file
 300   hscStubHOutName       :: String,      -- name of the .stub_h output file
 301   hscStubCOutName       :: String,      -- name of the .stub_c output file
 302   extCoreName           :: String,      -- name of the .core output file
 303   verbosity             :: Int,         -- verbosity level
 304   optLevel              :: Int,         -- optimisation level
 305   maxSimplIterations    :: Int,         -- max simplifier iterations
 306   ruleCheck             :: Maybe String,
 307   cppFlag               :: Bool,        -- preprocess with cpp?
 308   ppFlag                :: Bool,        -- preprocess with a Haskell Pp?
 309   recompFlag            :: Bool,        -- True <=> recompilation checker is on
 310   stolen_x86_regs       :: Int,
 311   cmdlineHcIncludes     :: [String],    -- -#includes
 312   importPaths           :: [FilePath],
 313
 314   -- options for particular phases
 315   opt_L                 :: [String],
 316   opt_P                 :: [String],
 317   opt_F                 :: [String],
 318   opt_c                 :: [String],
 319   opt_a                 :: [String],
 320   opt_m                 :: [String],
 321 #ifdef ILX
 322   opt_I                 :: [String],
 323   opt_i                 :: [String],
 324 #endif
 325
 326   -- ** Package flags
 327   extraPkgConfs         :: [FilePath],
 328         -- The -package-conf flags given on the command line, in the order
 329         -- they appeared.
 330
 331   readUserPkgConf       :: Bool,
 332         -- Whether or not to read the user package database
 333         -- (-no-user-package-conf).
 334
 335   packageFlags          :: [PackageFlag],
 336         -- The -package and -hide-package flags from the command-line
 337
 338   -- ** Package state
 339   pkgState              :: PackageState,
 340
 341   -- hsc dynamic flags
 342   flags                 :: [DynFlag]
 343  }
 344
 345 data PackageFlag
 346   = ExposePackage  String
 347   | HidePackage    String
 348   | IgnorePackage  String
 349
 350 defaultHscTarget
 351   | cGhcWithNativeCodeGen == "YES" &&
 352         (prefixMatch "i386" cTARGETPLATFORM ||
 353          prefixMatch "sparc" cTARGETPLATFORM ||
 354          prefixMatch "powerpc" cTARGETPLATFORM) =  HscAsm
 355   | otherwise                                   =  HscC
 356
 357 defaultDynFlags = DynFlags {
 358   coreToDo = Nothing, stgToDo = [],
 359   hscTarget = defaultHscTarget,
 360   hscOutName = "",
 361   hscStubHOutName = "", hscStubCOutName = "",
 362   extCoreName = "",
 363   verbosity             = 0,
 364   optLevel              = 0,
 365   maxSimplIterations    = 4,
 366   ruleCheck             = Nothing,
 367   cppFlag               = False,
 368   ppFlag                = False,
 369   recompFlag            = True,
 370   stolen_x86_regs       = 4,
 371   cmdlineHcIncludes     = [],
 372   importPaths           = ["."],
 373   opt_L                 = [],
 374   opt_P                 = [],
 375   opt_F                 = [],
 376   opt_c                 = [],
 377   opt_a                 = [],
 378   opt_m                 = [],
 379 #ifdef ILX
 380   opt_I                 = [],
 381   opt_i                 = [],
 382 #endif
 383
 384   extraPkgConfs         = [],
 385   readUserPkgConf       = True,
 386   packageFlags          = [],
 387   pkgState              = error "pkgState",
 388
 389   flags = [
 390             Opt_ImplicitPrelude,
 391             Opt_MonomorphismRestriction,
 392             Opt_Generics,
 393                         -- Generating the helper-functions for
 394                         -- generics is now on by default
 395             Opt_Strictness,
 396                         -- strictness is on by default, but this only
 397                         -- applies to -O.
 398             Opt_CSE,            -- similarly for CSE.
 399             Opt_FullLaziness,   -- ...and for full laziness
 400
 401             Opt_DoLambdaEtaExpansion,
 402                         -- This one is important for a tiresome reason:
 403                         -- we want to make sure that the bindings for data
 404                         -- constructors are eta-expanded.  This is probably
 405                         -- a good thing anyway, but it seems fragile.
 406
 407             -- and the default no-optimisation options:
 408             Opt_IgnoreInterfacePragmas,
 409             Opt_OmitInterfacePragmas
 410
 411            ] ++ standardWarnings
 412   }
 413
 414 {-
 415     Verbosity levels:
 416
 417     0   |   print errors & warnings only
 418     1   |   minimal verbosity: print "compiling M ... done." for each module.
 419     2   |   equivalent to -dshow-passes
 420     3   |   equivalent to existing "ghc -v"
 421     4   |   "ghc -v -ddump-most"
 422     5   |   "ghc -v -ddump-all"
 423 -}
 424
 425 dopt :: DynFlag -> DynFlags -> Bool
 426 dopt f dflags  = f `elem` (flags dflags)
 427
 428 dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
 429 dopt_CoreToDo = coreToDo
 430
 431 dopt_StgToDo :: DynFlags -> [StgToDo]
 432 dopt_StgToDo = stgToDo
 433
 434 dopt_OutName :: DynFlags -> String
 435 dopt_OutName = hscOutName
 436
 437 dopt_HscTarget :: DynFlags -> HscTarget
 438 dopt_HscTarget = hscTarget
 439
 440 dopt_set :: DynFlags -> DynFlag -> DynFlags
 441 dopt_set dfs f = dfs{ flags = f : flags dfs }
 442
 443 dopt_unset :: DynFlags -> DynFlag -> DynFlags
 444 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
 445
 446 getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]
 447         -- We add to the options from the front, so we need to reverse the list
 448 getOpts dflags opts = reverse (opts dflags)
 449
 450 getVerbFlag dflags
 451   | verbosity dflags >= 3  = "-v"
 452   | otherwise =  ""
 453
 454 -----------------------------------------------------------------------------
 455 -- Setting the optimisation level
 456
 457 updOptLevel n dfs
 458   = if (n >= 1)
 459      then dfs2{ hscTarget = HscC, optLevel = n } -- turn on -fvia-C with -O
 460      else dfs2{ optLevel = n }
 461   where
 462    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
 463    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
 464
 465    extra_dopts
 466         | n == 0    = opt_0_dopts
 467         | otherwise = opt_1_dopts
 468
 469    remove_dopts
 470         | n == 0    = opt_1_dopts
 471         | otherwise = opt_0_dopts
 472
 473 opt_0_dopts =  [
 474         Opt_IgnoreInterfacePragmas,
 475         Opt_OmitInterfacePragmas
 476     ]
 477
 478 opt_1_dopts = [
 479         Opt_IgnoreAsserts,
 480         Opt_DoEtaReduction,
 481         Opt_CaseMerge
 482      ]
 483
 484 -- Core-to-core phases:
 485
 486 buildCoreToDo :: DynFlags -> [CoreToDo]
 487 buildCoreToDo dflags = core_todo
 488   where
 489     opt_level     = optLevel dflags
 490     max_iter      = maxSimplIterations dflags
 491     strictness    = dopt Opt_Strictness dflags
 492     full_laziness = dopt Opt_FullLaziness dflags
 493     cse           = dopt Opt_CSE dflags
 494     rule_check    = ruleCheck dflags
 495
 496     core_todo =
 497      if opt_level == 0 then
 498       [
 499         CoreDoSimplify (SimplPhase 0) [
 500             MaxSimplifierIterations max_iter
 501         ]
 502       ]
 503
 504      else {- opt_level >= 1 -} [
 505
 506         -- initial simplify: mk specialiser happy: minimum effort please
 507         CoreDoSimplify SimplGently [
 508                         --      Simplify "gently"
 509                         -- Don't inline anything till full laziness has bitten
 510                         -- In particular, inlining wrappers inhibits floating
 511                         -- e.g. ...(case f x of ...)...
 512                         --  ==> ...(case (case x of I# x# -> fw x#) of ...)...
 513                         --  ==> ...(case x of I# x# -> case fw x# of ...)...
 514                         -- and now the redex (f x) isn't floatable any more
 515                         -- Similarly, don't apply any rules until after full
 516                         -- laziness.  Notably, list fusion can prevent floating.
 517
 518             NoCaseOfCase,
 519                         -- Don't do case-of-case transformations.
 520                         -- This makes full laziness work better
 521             MaxSimplifierIterations max_iter
 522         ],
 523
 524         -- Specialisation is best done before full laziness
 525         -- so that overloaded functions have all their dictionary lambdas manifest
 526         CoreDoSpecialising,
 527
 528         if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
 529                          else CoreDoNothing,
 530
 531         CoreDoFloatInwards,
 532
 533         CoreDoSimplify (SimplPhase 2) [
 534                 -- Want to run with inline phase 2 after the specialiser to give
 535                 -- maximum chance for fusion to work before we inline build/augment
 536                 -- in phase 1.  This made a difference in 'ansi' where an
 537                 -- overloaded function wasn't inlined till too late.
 538            MaxSimplifierIterations max_iter
 539         ],
 540         case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
 541
 542         CoreDoSimplify (SimplPhase 1) [
 543                 -- Need inline-phase2 here so that build/augment get
 544                 -- inlined.  I found that spectral/hartel/genfft lost some useful
 545                 -- strictness in the function sumcode' if augment is not inlined
 546                 -- before strictness analysis runs
 547            MaxSimplifierIterations max_iter
 548         ],
 549         case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
 550
 551         CoreDoSimplify (SimplPhase 0) [
 552                 -- Phase 0: allow all Ids to be inlined now
 553                 -- This gets foldr inlined before strictness analysis
 554
 555            MaxSimplifierIterations 3
 556                 -- At least 3 iterations because otherwise we land up with
 557                 -- huge dead expressions because of an infelicity in the
 558                 -- simpifier.
 559                 --      let k = BIG in foldr k z xs
 560                 -- ==>  let k = BIG in letrec go = \xs -> ...(k x).... in go xs
 561                 -- ==>  let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
 562                 -- Don't stop now!
 563
 564         ],
 565         case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
 566
 567 #ifdef OLD_STRICTNESS
 568         CoreDoOldStrictness
 569 #endif
 570         if strictness then CoreDoStrictness else CoreDoNothing,
 571         CoreDoWorkerWrapper,
 572         CoreDoGlomBinds,
 573
 574         CoreDoSimplify (SimplPhase 0) [
 575            MaxSimplifierIterations max_iter
 576         ],
 577
 578         if full_laziness then
 579           CoreDoFloatOutwards (FloatOutSw False   -- Not lambdas
 580                                           True)   -- Float constants
 581         else CoreDoNothing,
 582                 -- nofib/spectral/hartel/wang doubles in speed if you
 583                 -- do full laziness late in the day.  It only happens
 584                 -- after fusion and other stuff, so the early pass doesn't
 585                 -- catch it.  For the record, the redex is
 586                 --        f_el22 (f_el21 r_midblock)
 587
 588
 589         -- We want CSE to follow the final full-laziness pass, because it may
 590         -- succeed in commoning up things floated out by full laziness.
 591         -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
 592
 593         if cse then CoreCSE else CoreDoNothing,
 594
 595         CoreDoFloatInwards,
 596
 597 -- Case-liberation for -O2.  This should be after
 598 -- strictness analysis and the simplification which follows it.
 599
 600         case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
 601
 602         if opt_level >= 2 then
 603            CoreLiberateCase
 604         else
 605            CoreDoNothing,
 606         if opt_level >= 2 then
 607            CoreDoSpecConstr
 608         else
 609            CoreDoNothing,
 610
 611         -- Final clean-up simplification:
 612         CoreDoSimplify (SimplPhase 0) [
 613           MaxSimplifierIterations max_iter
 614         ]
 615      ]
 616 \end{code}
 617
 618 %************************************************************************
 619 %*                                                                      *
 620 \subsection{Warnings}
 621 %*                                                                      *
 622 %************************************************************************
 623
 624 \begin{code}
 625 standardWarnings
 626     = [ Opt_WarnDeprecations,
 627         Opt_WarnOverlappingPatterns,
 628         Opt_WarnMissingFields,
 629         Opt_WarnMissingMethods,
 630         Opt_WarnDuplicateExports
 631       ]
 632
 633 minusWOpts
 634     = standardWarnings ++
 635       [ Opt_WarnUnusedBinds,
 636         Opt_WarnUnusedMatches,
 637         Opt_WarnUnusedImports,
 638         Opt_WarnIncompletePatterns,
 639         Opt_WarnDodgyImports
 640       ]
 641
 642 minusWallOpts
 643     = minusWOpts ++
 644       [ Opt_WarnTypeDefaults,
 645         Opt_WarnNameShadowing,
 646         Opt_WarnMissingSigs,
 647         Opt_WarnHiShadows,
 648         Opt_WarnOrphans
 649       ]
 650 \end{code}
 651
 652 %************************************************************************
 653 %*                                                                      *
 654 \subsection{Classifying command-line options}
 655 %*                                                                      *
 656 %************************************************************************
 657
 658 \begin{code}
 659 -- v_Statis_hsc_opts is here to avoid a circular dependency with
 660 -- main/DriverState.
 661 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
 662
 663 lookUp           :: FastString -> Bool
 664 lookup_def_int   :: String -> Int -> Int
 665 lookup_def_float :: String -> Float -> Float
 666 lookup_str       :: String -> Maybe String
 667
 668 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
 669 packed_static_opts   = map mkFastString unpacked_static_opts
 670
 671 lookUp     sw = sw `elem` packed_static_opts
 672
 673 -- (lookup_str "foo") looks for the flag -foo=X or -fooX,
 674 -- and returns the string X
 675 lookup_str sw
 676    = case firstJust (map (startsWith sw) unpacked_static_opts) of
 677         Just ('=' : str) -> Just str
 678         Just str         -> Just str
 679         Nothing          -> Nothing
 680
 681 lookup_def_int sw def = case (lookup_str sw) of
 682                             Nothing -> def              -- Use default
 683                             Just xx -> try_read sw xx
 684
 685 lookup_def_float sw def = case (lookup_str sw) of
 686                             Nothing -> def              -- Use default
 687                             Just xx -> try_read sw xx
 688
 689
 690 try_read :: Read a => String -> String -> a
 691 -- (try_read sw str) tries to read s; if it fails, it
 692 -- bleats about flag sw
 693 try_read sw str
 694   = case reads str of
 695         ((x,_):_) -> x  -- Be forgiving: ignore trailing goop, and alternative parses
 696         []        -> ghcError (UsageError ("Malformed argument " ++ str ++ " for flag " ++ sw))
 697                         -- ToDo: hack alert. We should really parse the arugments
 698                         --       and announce errors in a more civilised way.
 699
 700
 701 {-
 702  Putting the compiler options into temporary at-files
 703  may turn out to be necessary later on if we turn hsc into
 704  a pure Win32 application where I think there's a command-line
 705  length limit of 255. unpacked_opts understands the @ option.
 706
 707 unpacked_opts :: [String]
 708 unpacked_opts =
 709   concat $
 710   map (expandAts) $
 711   map unpackFS argv  -- NOT ARGV any more: v_Static_hsc_opts
 712   where
 713    expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
 714    expandAts l = [l]
 715 -}
 716 \end{code}
 717
 718 %************************************************************************
 719 %*                                                                      *
 720 \subsection{Static options}
 721 %*                                                                      *
 722 %************************************************************************
 723
 724 \begin{code}
 725 -- debugging opts
 726 opt_PprStyle_Debug              = lookUp  FSLIT("-dppr-debug")
 727 opt_PprUserLength               = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
 728
 729 -- profiling opts
 730 opt_AutoSccsOnAllToplevs        = lookUp  FSLIT("-fauto-sccs-on-all-toplevs")
 731 opt_AutoSccsOnExportedToplevs   = lookUp  FSLIT("-fauto-sccs-on-exported-toplevs")
 732 opt_AutoSccsOnIndividualCafs    = lookUp  FSLIT("-fauto-sccs-on-individual-cafs")
 733 opt_SccProfilingOn              = lookUp  FSLIT("-fscc-profiling")
 734 opt_DoTickyProfiling            = lookUp  FSLIT("-fticky-ticky")
 735
 736 -- language opts
 737 opt_DictsStrict                 = lookUp  FSLIT("-fdicts-strict")
 738 opt_IrrefutableTuples           = lookUp  FSLIT("-firrefutable-tuples")
 739 opt_MaxContextReductionDepth    = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
 740 opt_Parallel                    = lookUp  FSLIT("-fparallel")
 741 opt_SMP                         = lookUp  FSLIT("-fsmp")
 742 opt_Flatten                     = lookUp  FSLIT("-fflatten")
 743
 744 -- optimisation opts
 745 opt_NoStateHack                 = lookUp  FSLIT("-fno-state-hack")
 746 opt_NoMethodSharing             = lookUp  FSLIT("-fno-method-sharing")
 747 opt_CprOff                      = lookUp  FSLIT("-fcpr-off")
 748 opt_RulesOff                    = lookUp  FSLIT("-frules-off")
 749         -- Switch off CPR analysis in the new demand analyser
 750 opt_LiberateCaseThreshold       = lookup_def_int "-fliberate-case-threshold" (10::Int)
 751 opt_MaxWorkerArgs               = lookup_def_int "-fmax-worker-args" (10::Int)
 752
 753 opt_EmitCExternDecls            = lookUp  FSLIT("-femit-extern-decls")
 754 opt_EnsureSplittableC           = lookUp  FSLIT("-fglobalise-toplev-names")
 755 opt_GranMacros                  = lookUp  FSLIT("-fgransim")
 756 opt_HiVersion                   = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
 757 opt_HistorySize                 = lookup_def_int "-fhistory-size" 20
 758 opt_OmitBlackHoling             = lookUp  FSLIT("-dno-black-holing")
 759 opt_RuntimeTypes                = lookUp  FSLIT("-fruntime-types")
 760
 761 -- Simplifier switches
 762 opt_SimplNoPreInlining          = lookUp  FSLIT("-fno-pre-inlining")
 763         -- NoPreInlining is there just to see how bad things
 764         -- get if you don't do it!
 765 opt_SimplExcessPrecision        = lookUp  FSLIT("-fexcess-precision")
 766
 767 -- Unfolding control
 768 opt_UF_CreationThreshold        = lookup_def_int "-funfolding-creation-threshold"  (45::Int)
 769 opt_UF_UseThreshold             = lookup_def_int "-funfolding-use-threshold"       (8::Int)     -- Discounts can be big
 770 opt_UF_FunAppDiscount           = lookup_def_int "-funfolding-fun-discount"        (6::Int)     -- It's great to inline a fn
 771 opt_UF_KeenessFactor            = lookup_def_float "-funfolding-keeness-factor"    (1.5::Float)
 772 opt_UF_UpdateInPlace            = lookUp  FSLIT("-funfolding-update-in-place")
 773
 774 opt_UF_DearOp   = ( 4 :: Int)
 775
 776 opt_Static                      = lookUp  FSLIT("-static")
 777 opt_Unregisterised              = lookUp  FSLIT("-funregisterised")
 778 opt_EmitExternalCore            = lookUp  FSLIT("-fext-core")
 779
 780 -- Include full span info in error messages, instead of just the start position.
 781 opt_ErrorSpans                  = lookUp FSLIT("-ferror-spans")
 782
 783 opt_PIC                         = lookUp FSLIT("-fPIC")
 784 \end{code}
 785
 786 %************************************************************************
 787 %*                                                                      *
 788 \subsection{List of static hsc flags}
 789 %*                                                                      *
 790 %************************************************************************
 791
 792 \begin{code}
 793 isStaticHscFlag f =
 794   f `elem` [
 795         "fauto-sccs-on-all-toplevs",
 796         "fauto-sccs-on-exported-toplevs",
 797         "fauto-sccs-on-individual-cafs",
 798         "fauto-sccs-on-dicts",
 799         "fscc-profiling",
 800         "fticky-ticky",
 801         "fall-strict",
 802         "fdicts-strict",
 803         "firrefutable-tuples",
 804         "fparallel",
 805         "fsmp",
 806         "fflatten",
 807         "fsemi-tagging",
 808         "flet-no-escape",
 809         "femit-extern-decls",
 810         "fglobalise-toplev-names",
 811         "fgransim",
 812         "fno-hi-version-check",
 813         "dno-black-holing",
 814         "fno-method-sharing",
 815         "fno-state-hack",
 816         "fruntime-types",
 817         "fno-pre-inlining",
 818         "fexcess-precision",
 819         "funfolding-update-in-place",
 820         "static",
 821         "funregisterised",
 822         "fext-core",
 823         "frule-check",
 824         "frules-off",
 825         "fcpr-off",
 826         "ferror-spans",
 827         "fPIC"
 828         ]
 829   || any (flip prefixMatch f) [
 830         "fcontext-stack",
 831         "fliberate-case-threshold",
 832         "fmax-worker-args",
 833         "fhistory-size",
 834         "funfolding-creation-threshold",
 835         "funfolding-use-threshold",
 836         "funfolding-fun-discount",
 837         "funfolding-keeness-factor"
 838      ]
 839 \end{code}
 840
 841 %************************************************************************
 842 %*                                                                      *
 843 \subsection{Misc functions for command-line options}
 844 %*                                                                      *
 845 %************************************************************************
 846
 847
 848
 849 \begin{code}
 850 startsWith :: String -> String -> Maybe String
 851 -- startsWith pfx (pfx++rest) = Just rest
 852
 853 startsWith []     str = Just str
 854 startsWith (c:cs) (s:ss)
 855   = if c /= s then Nothing else startsWith cs ss
 856 startsWith  _     []  = Nothing
 857 \end{code}