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