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