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